2 #include "repository.h"
3 #include "sparse-index.h"
7 #include "cache-tree.h"
10 #include "fsmonitor.h"
12 static struct cache_entry
*construct_sparse_dir_entry(
13 struct index_state
*istate
,
14 const char *sparse_dir
,
15 struct cache_tree
*tree
)
17 struct cache_entry
*de
;
19 de
= make_cache_entry(istate
, S_IFDIR
, &tree
->oid
, sparse_dir
, 0, 0);
21 de
->ce_flags
|= CE_SKIP_WORKTREE
;
26 * Returns the number of entries "inserted" into the index.
28 static int convert_to_sparse_rec(struct index_state
*istate
,
31 const char *ct_path
, size_t ct_pathlen
,
32 struct cache_tree
*ct
)
34 int i
, can_convert
= 1;
35 int start_converted
= num_converted
;
36 enum pattern_match_result match
;
37 int dtype
= DT_UNKNOWN
;
38 struct strbuf child_path
= STRBUF_INIT
;
39 struct pattern_list
*pl
= istate
->sparse_checkout_patterns
;
42 * Is the current path outside of the sparse cone?
43 * Then check if the region can be replaced by a sparse
44 * directory entry (everything is sparse and merged).
46 match
= path_matches_pattern_list(ct_path
, ct_pathlen
,
47 NULL
, &dtype
, pl
, istate
);
48 if (match
!= NOT_MATCHED
)
51 for (i
= start
; can_convert
&& i
< end
; i
++) {
52 struct cache_entry
*ce
= istate
->cache
[i
];
55 S_ISGITLINK(ce
->ce_mode
) ||
56 !(ce
->ce_flags
& CE_SKIP_WORKTREE
))
61 struct cache_entry
*se
;
62 se
= construct_sparse_dir_entry(istate
, ct_path
, ct
);
64 istate
->cache
[num_converted
++] = se
;
68 for (i
= start
; i
< end
; ) {
69 int count
, span
, pos
= -1;
70 const char *base
, *slash
;
71 struct cache_entry
*ce
= istate
->cache
[i
];
74 * Detect if this is a normal entry outside of any subtree
77 base
= ce
->name
+ ct_pathlen
;
78 slash
= strchr(base
, '/');
81 pos
= cache_tree_subtree_pos(ct
, base
, slash
- base
);
84 istate
->cache
[num_converted
++] = ce
;
89 strbuf_setlen(&child_path
, 0);
90 strbuf_add(&child_path
, ce
->name
, slash
- ce
->name
+ 1);
92 span
= ct
->down
[pos
]->cache_tree
->entry_count
;
93 count
= convert_to_sparse_rec(istate
,
94 num_converted
, i
, i
+ span
,
95 child_path
.buf
, child_path
.len
,
96 ct
->down
[pos
]->cache_tree
);
97 num_converted
+= count
;
101 strbuf_release(&child_path
);
102 return num_converted
- start_converted
;
105 int set_sparse_index_config(struct repository
*repo
, int enable
)
108 char *config_path
= repo_git_path(repo
, "config.worktree");
109 res
= git_config_set_in_file_gently(config_path
,
111 enable
? "true" : NULL
);
114 prepare_repo_settings(repo
);
115 repo
->settings
.sparse_index
= enable
;
119 static int index_has_unmerged_entries(struct index_state
*istate
)
122 for (i
= 0; i
< istate
->cache_nr
; i
++) {
123 if (ce_stage(istate
->cache
[i
]))
130 int convert_to_sparse(struct index_state
*istate
)
133 if (istate
->split_index
|| istate
->sparse_index
||
134 !core_apply_sparse_checkout
|| !core_sparse_checkout_cone
)
138 istate
->repo
= the_repository
;
141 * The GIT_TEST_SPARSE_INDEX environment variable triggers the
142 * index.sparse config variable to be on.
144 test_env
= git_env_bool("GIT_TEST_SPARSE_INDEX", -1);
146 set_sparse_index_config(istate
->repo
, test_env
);
149 * Only convert to sparse if index.sparse is set.
151 prepare_repo_settings(istate
->repo
);
152 if (!istate
->repo
->settings
.sparse_index
)
155 if (!istate
->sparse_checkout_patterns
) {
156 istate
->sparse_checkout_patterns
= xcalloc(1, sizeof(struct pattern_list
));
157 if (get_sparse_checkout_patterns(istate
->sparse_checkout_patterns
) < 0)
161 if (!istate
->sparse_checkout_patterns
->use_cone_patterns
) {
162 warning(_("attempting to use sparse-index without cone mode"));
167 * NEEDSWORK: If we have unmerged entries, then stay full.
168 * Unmerged entries prevent the cache-tree extension from working.
170 if (index_has_unmerged_entries(istate
))
173 if (cache_tree_update(istate
, 0)) {
174 warning(_("unable to update cache-tree, staying full"));
178 remove_fsmonitor(istate
);
180 trace2_region_enter("index", "convert_to_sparse", istate
->repo
);
181 istate
->cache_nr
= convert_to_sparse_rec(istate
,
182 0, 0, istate
->cache_nr
,
183 "", 0, istate
->cache_tree
);
185 /* Clear and recompute the cache-tree */
186 cache_tree_free(&istate
->cache_tree
);
187 cache_tree_update(istate
, 0);
189 istate
->sparse_index
= 1;
190 trace2_region_leave("index", "convert_to_sparse", istate
->repo
);
194 static void set_index_entry(struct index_state
*istate
, int nr
, struct cache_entry
*ce
)
196 ALLOC_GROW(istate
->cache
, nr
+ 1, istate
->cache_alloc
);
198 istate
->cache
[nr
] = ce
;
199 add_name_hash(istate
, ce
);
202 static int add_path_to_index(const struct object_id
*oid
,
203 struct strbuf
*base
, const char *path
,
204 unsigned int mode
, void *context
)
206 struct index_state
*istate
= (struct index_state
*)context
;
207 struct cache_entry
*ce
;
208 size_t len
= base
->len
;
211 return READ_TREE_RECURSIVE
;
213 strbuf_addstr(base
, path
);
215 ce
= make_cache_entry(istate
, mode
, oid
, base
->buf
, 0, 0);
216 ce
->ce_flags
|= CE_SKIP_WORKTREE
| CE_EXTENDED
;
217 set_index_entry(istate
, istate
->cache_nr
++, ce
);
219 strbuf_setlen(base
, len
);
223 void ensure_full_index(struct index_state
*istate
)
226 struct index_state
*full
;
227 struct strbuf base
= STRBUF_INIT
;
229 if (!istate
|| !istate
->sparse_index
)
233 istate
->repo
= the_repository
;
235 trace2_region_enter("index", "ensure_full_index", istate
->repo
);
237 /* initialize basics of new index */
238 full
= xcalloc(1, sizeof(struct index_state
));
239 memcpy(full
, istate
, sizeof(struct index_state
));
241 /* then change the necessary things */
242 full
->sparse_index
= 0;
243 full
->cache_alloc
= (3 * istate
->cache_alloc
) / 2;
245 ALLOC_ARRAY(full
->cache
, full
->cache_alloc
);
247 for (i
= 0; i
< istate
->cache_nr
; i
++) {
248 struct cache_entry
*ce
= istate
->cache
[i
];
252 if (!S_ISSPARSEDIR(ce
->ce_mode
)) {
253 set_index_entry(full
, full
->cache_nr
++, ce
);
256 if (!(ce
->ce_flags
& CE_SKIP_WORKTREE
))
257 warning(_("index entry is a directory, but not sparse (%08x)"),
260 /* recursively walk into cd->name */
261 tree
= lookup_tree(istate
->repo
, &ce
->oid
);
263 memset(&ps
, 0, sizeof(ps
));
268 strbuf_setlen(&base
, 0);
269 strbuf_add(&base
, ce
->name
, strlen(ce
->name
));
271 read_tree_at(istate
->repo
, tree
, &base
, &ps
,
272 add_path_to_index
, full
);
274 /* free directory entries. full entries are re-used */
275 discard_cache_entry(ce
);
278 /* Copy back into original index. */
279 memcpy(&istate
->name_hash
, &full
->name_hash
, sizeof(full
->name_hash
));
280 istate
->sparse_index
= 0;
282 istate
->cache
= full
->cache
;
283 istate
->cache_nr
= full
->cache_nr
;
284 istate
->cache_alloc
= full
->cache_alloc
;
286 strbuf_release(&base
);
289 /* Clear and recompute the cache-tree */
290 cache_tree_free(&istate
->cache_tree
);
291 cache_tree_update(istate
, 0);
293 trace2_region_leave("index", "ensure_full_index", istate
->repo
);
297 * This static global helps avoid infinite recursion between
298 * expand_to_path() and index_file_exists().
300 static int in_expand_to_path
= 0;
302 void expand_to_path(struct index_state
*istate
,
303 const char *path
, size_t pathlen
, int icase
)
305 struct strbuf path_mutable
= STRBUF_INIT
;
308 /* prevent extra recursion */
309 if (in_expand_to_path
)
312 if (!istate
|| !istate
->sparse_index
)
316 istate
->repo
= the_repository
;
318 in_expand_to_path
= 1;
321 * We only need to actually expand a region if the
322 * following are both true:
324 * 1. 'path' is not already in the index.
325 * 2. Some parent directory of 'path' is a sparse directory.
328 if (index_file_exists(istate
, path
, pathlen
, icase
))
331 strbuf_add(&path_mutable
, path
, pathlen
);
332 strbuf_addch(&path_mutable
, '/');
334 /* Check the name hash for all parent directories */
336 while (substr_len
< pathlen
) {
338 char *replace
= strchr(path_mutable
.buf
+ substr_len
, '/');
343 /* replace the character _after_ the slash */
347 if (index_file_exists(istate
, path_mutable
.buf
,
348 path_mutable
.len
, icase
)) {
350 * We found a parent directory in the name-hash
351 * hashtable, because only sparse directory entries
352 * have a trailing '/' character. Since "path" wasn't
353 * in the index, perhaps it exists within this
354 * sparse-directory. Expand accordingly.
356 ensure_full_index(istate
);
361 substr_len
= replace
- path_mutable
.buf
;
365 strbuf_release(&path_mutable
);
366 in_expand_to_path
= 0;