1 #include "cache.h"
2 #include "repository.h"
3 #include "sparse-index.h"
4 #include "tree.h"
5 #include "pathspec.h"
6 #include "trace2.h"
7 #include "cache-tree.h"
8 #include "config.h"
9 #include "dir.h"
10 #include "fsmonitor.h"
11
construct_sparse_dir_entry(struct index_state * istate,const char * sparse_dir,struct cache_tree * tree)12 static struct cache_entry *construct_sparse_dir_entry(
13 struct index_state *istate,
14 const char *sparse_dir,
15 struct cache_tree *tree)
16 {
17 struct cache_entry *de;
18
19 de = make_cache_entry(istate, S_IFDIR, &tree->oid, sparse_dir, 0, 0);
20
21 de->ce_flags |= CE_SKIP_WORKTREE;
22 return de;
23 }
24
25 /*
26 * Returns the number of entries "inserted" into the index.
27 */
convert_to_sparse_rec(struct index_state * istate,int num_converted,int start,int end,const char * ct_path,size_t ct_pathlen,struct cache_tree * ct)28 static int convert_to_sparse_rec(struct index_state *istate,
29 int num_converted,
30 int start, int end,
31 const char *ct_path, size_t ct_pathlen,
32 struct cache_tree *ct)
33 {
34 int i, can_convert = 1;
35 int start_converted = num_converted;
36 struct strbuf child_path = STRBUF_INIT;
37
38 /*
39 * Is the current path outside of the sparse cone?
40 * Then check if the region can be replaced by a sparse
41 * directory entry (everything is sparse and merged).
42 */
43 if (path_in_sparse_checkout(ct_path, istate))
44 can_convert = 0;
45
46 for (i = start; can_convert && i < end; i++) {
47 struct cache_entry *ce = istate->cache[i];
48
49 if (ce_stage(ce) ||
50 S_ISGITLINK(ce->ce_mode) ||
51 !(ce->ce_flags & CE_SKIP_WORKTREE))
52 can_convert = 0;
53 }
54
55 if (can_convert) {
56 struct cache_entry *se;
57 se = construct_sparse_dir_entry(istate, ct_path, ct);
58
59 istate->cache[num_converted++] = se;
60 return 1;
61 }
62
63 for (i = start; i < end; ) {
64 int count, span, pos = -1;
65 const char *base, *slash;
66 struct cache_entry *ce = istate->cache[i];
67
68 /*
69 * Detect if this is a normal entry outside of any subtree
70 * entry.
71 */
72 base = ce->name + ct_pathlen;
73 slash = strchr(base, '/');
74
75 if (slash)
76 pos = cache_tree_subtree_pos(ct, base, slash - base);
77
78 if (pos < 0) {
79 istate->cache[num_converted++] = ce;
80 i++;
81 continue;
82 }
83
84 strbuf_setlen(&child_path, 0);
85 strbuf_add(&child_path, ce->name, slash - ce->name + 1);
86
87 span = ct->down[pos]->cache_tree->entry_count;
88 count = convert_to_sparse_rec(istate,
89 num_converted, i, i + span,
90 child_path.buf, child_path.len,
91 ct->down[pos]->cache_tree);
92 num_converted += count;
93 i += span;
94 }
95
96 strbuf_release(&child_path);
97 return num_converted - start_converted;
98 }
99
set_sparse_index_config(struct repository * repo,int enable)100 int set_sparse_index_config(struct repository *repo, int enable)
101 {
102 int res;
103 char *config_path = repo_git_path(repo, "config.worktree");
104 res = git_config_set_in_file_gently(config_path,
105 "index.sparse",
106 enable ? "true" : NULL);
107 free(config_path);
108
109 prepare_repo_settings(repo);
110 repo->settings.sparse_index = enable;
111 return res;
112 }
113
index_has_unmerged_entries(struct index_state * istate)114 static int index_has_unmerged_entries(struct index_state *istate)
115 {
116 int i;
117 for (i = 0; i < istate->cache_nr; i++) {
118 if (ce_stage(istate->cache[i]))
119 return 1;
120 }
121
122 return 0;
123 }
124
convert_to_sparse(struct index_state * istate,int flags)125 int convert_to_sparse(struct index_state *istate, int flags)
126 {
127 int test_env;
128 if (istate->sparse_index || !istate->cache_nr ||
129 !core_apply_sparse_checkout || !core_sparse_checkout_cone)
130 return 0;
131
132 if (!istate->repo)
133 istate->repo = the_repository;
134
135 if (!(flags & SPARSE_INDEX_MEMORY_ONLY)) {
136 /*
137 * The sparse index is not (yet) integrated with a split index.
138 */
139 if (istate->split_index)
140 return 0;
141 /*
142 * The GIT_TEST_SPARSE_INDEX environment variable triggers the
143 * index.sparse config variable to be on.
144 */
145 test_env = git_env_bool("GIT_TEST_SPARSE_INDEX", -1);
146 if (test_env >= 0)
147 set_sparse_index_config(istate->repo, test_env);
148
149 /*
150 * Only convert to sparse if index.sparse is set.
151 */
152 prepare_repo_settings(istate->repo);
153 if (!istate->repo->settings.sparse_index)
154 return 0;
155 }
156
157 if (init_sparse_checkout_patterns(istate))
158 return 0;
159
160 /*
161 * We need cone-mode patterns to use sparse-index. If a user edits
162 * their sparse-checkout file manually, then we can detect during
163 * parsing that they are not actually using cone-mode patterns and
164 * hence we need to abort this conversion _without error_. Warnings
165 * already exist in the pattern parsing to inform the user of their
166 * bad patterns.
167 */
168 if (!istate->sparse_checkout_patterns->use_cone_patterns)
169 return 0;
170
171 /*
172 * NEEDSWORK: If we have unmerged entries, then stay full.
173 * Unmerged entries prevent the cache-tree extension from working.
174 */
175 if (index_has_unmerged_entries(istate))
176 return 0;
177
178 /* Clear and recompute the cache-tree */
179 cache_tree_free(&istate->cache_tree);
180 /*
181 * Silently return if there is a problem with the cache tree update,
182 * which might just be due to a conflict state in some entry.
183 *
184 * This might create new tree objects, so be sure to use
185 * WRITE_TREE_MISSING_OK.
186 */
187 if (cache_tree_update(istate, WRITE_TREE_MISSING_OK))
188 return 0;
189
190 remove_fsmonitor(istate);
191
192 trace2_region_enter("index", "convert_to_sparse", istate->repo);
193 istate->cache_nr = convert_to_sparse_rec(istate,
194 0, 0, istate->cache_nr,
195 "", 0, istate->cache_tree);
196
197 /* Clear and recompute the cache-tree */
198 cache_tree_free(&istate->cache_tree);
199 cache_tree_update(istate, 0);
200
201 istate->fsmonitor_has_run_once = 0;
202 FREE_AND_NULL(istate->fsmonitor_dirty);
203 FREE_AND_NULL(istate->fsmonitor_last_update);
204
205 istate->sparse_index = 1;
206 trace2_region_leave("index", "convert_to_sparse", istate->repo);
207 return 0;
208 }
209
set_index_entry(struct index_state * istate,int nr,struct cache_entry * ce)210 static void set_index_entry(struct index_state *istate, int nr, struct cache_entry *ce)
211 {
212 ALLOC_GROW(istate->cache, nr + 1, istate->cache_alloc);
213
214 istate->cache[nr] = ce;
215 add_name_hash(istate, ce);
216 }
217
add_path_to_index(const struct object_id * oid,struct strbuf * base,const char * path,unsigned int mode,void * context)218 static int add_path_to_index(const struct object_id *oid,
219 struct strbuf *base, const char *path,
220 unsigned int mode, void *context)
221 {
222 struct index_state *istate = (struct index_state *)context;
223 struct cache_entry *ce;
224 size_t len = base->len;
225
226 if (S_ISDIR(mode))
227 return READ_TREE_RECURSIVE;
228
229 strbuf_addstr(base, path);
230
231 ce = make_cache_entry(istate, mode, oid, base->buf, 0, 0);
232 ce->ce_flags |= CE_SKIP_WORKTREE | CE_EXTENDED;
233 set_index_entry(istate, istate->cache_nr++, ce);
234
235 strbuf_setlen(base, len);
236 return 0;
237 }
238
ensure_full_index(struct index_state * istate)239 void ensure_full_index(struct index_state *istate)
240 {
241 int i;
242 struct index_state *full;
243 struct strbuf base = STRBUF_INIT;
244
245 if (!istate || !istate->sparse_index)
246 return;
247
248 if (!istate->repo)
249 istate->repo = the_repository;
250
251 trace2_region_enter("index", "ensure_full_index", istate->repo);
252
253 /* initialize basics of new index */
254 full = xcalloc(1, sizeof(struct index_state));
255 memcpy(full, istate, sizeof(struct index_state));
256
257 /* then change the necessary things */
258 full->sparse_index = 0;
259 full->cache_alloc = (3 * istate->cache_alloc) / 2;
260 full->cache_nr = 0;
261 ALLOC_ARRAY(full->cache, full->cache_alloc);
262
263 for (i = 0; i < istate->cache_nr; i++) {
264 struct cache_entry *ce = istate->cache[i];
265 struct tree *tree;
266 struct pathspec ps;
267
268 if (!S_ISSPARSEDIR(ce->ce_mode)) {
269 set_index_entry(full, full->cache_nr++, ce);
270 continue;
271 }
272 if (!(ce->ce_flags & CE_SKIP_WORKTREE))
273 warning(_("index entry is a directory, but not sparse (%08x)"),
274 ce->ce_flags);
275
276 /* recursively walk into cd->name */
277 tree = lookup_tree(istate->repo, &ce->oid);
278
279 memset(&ps, 0, sizeof(ps));
280 ps.recursive = 1;
281 ps.has_wildcard = 1;
282 ps.max_depth = -1;
283
284 strbuf_setlen(&base, 0);
285 strbuf_add(&base, ce->name, strlen(ce->name));
286
287 read_tree_at(istate->repo, tree, &base, &ps,
288 add_path_to_index, full);
289
290 /* free directory entries. full entries are re-used */
291 discard_cache_entry(ce);
292 }
293
294 /* Copy back into original index. */
295 memcpy(&istate->name_hash, &full->name_hash, sizeof(full->name_hash));
296 memcpy(&istate->dir_hash, &full->dir_hash, sizeof(full->dir_hash));
297 istate->sparse_index = 0;
298 free(istate->cache);
299 istate->cache = full->cache;
300 istate->cache_nr = full->cache_nr;
301 istate->cache_alloc = full->cache_alloc;
302 istate->fsmonitor_has_run_once = 0;
303 FREE_AND_NULL(istate->fsmonitor_dirty);
304 FREE_AND_NULL(istate->fsmonitor_last_update);
305
306 strbuf_release(&base);
307 free(full);
308
309 /* Clear and recompute the cache-tree */
310 cache_tree_free(&istate->cache_tree);
311 cache_tree_update(istate, 0);
312
313 trace2_region_leave("index", "ensure_full_index", istate->repo);
314 }
315
316 /*
317 * This static global helps avoid infinite recursion between
318 * expand_to_path() and index_file_exists().
319 */
320 static int in_expand_to_path = 0;
321
expand_to_path(struct index_state * istate,const char * path,size_t pathlen,int icase)322 void expand_to_path(struct index_state *istate,
323 const char *path, size_t pathlen, int icase)
324 {
325 struct strbuf path_mutable = STRBUF_INIT;
326 size_t substr_len;
327
328 /* prevent extra recursion */
329 if (in_expand_to_path)
330 return;
331
332 if (!istate || !istate->sparse_index)
333 return;
334
335 if (!istate->repo)
336 istate->repo = the_repository;
337
338 in_expand_to_path = 1;
339
340 /*
341 * We only need to actually expand a region if the
342 * following are both true:
343 *
344 * 1. 'path' is not already in the index.
345 * 2. Some parent directory of 'path' is a sparse directory.
346 */
347
348 if (index_file_exists(istate, path, pathlen, icase))
349 goto cleanup;
350
351 strbuf_add(&path_mutable, path, pathlen);
352 strbuf_addch(&path_mutable, '/');
353
354 /* Check the name hash for all parent directories */
355 substr_len = 0;
356 while (substr_len < pathlen) {
357 char temp;
358 char *replace = strchr(path_mutable.buf + substr_len, '/');
359
360 if (!replace)
361 break;
362
363 /* replace the character _after_ the slash */
364 replace++;
365 temp = *replace;
366 *replace = '\0';
367 if (index_file_exists(istate, path_mutable.buf,
368 path_mutable.len, icase)) {
369 /*
370 * We found a parent directory in the name-hash
371 * hashtable, because only sparse directory entries
372 * have a trailing '/' character. Since "path" wasn't
373 * in the index, perhaps it exists within this
374 * sparse-directory. Expand accordingly.
375 */
376 ensure_full_index(istate);
377 break;
378 }
379
380 *replace = temp;
381 substr_len = replace - path_mutable.buf;
382 }
383
384 cleanup:
385 strbuf_release(&path_mutable);
386 in_expand_to_path = 0;
387 }
388