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
;
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 static int set_index_sparse_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
= 1;
119 int set_sparse_index_config(struct repository
*repo
, int enable
)
121 int res
= set_index_sparse_config(repo
, enable
);
123 prepare_repo_settings(repo
);
124 repo
->settings
.sparse_index
= enable
;
128 int convert_to_sparse(struct index_state
*istate
)
131 if (istate
->split_index
|| istate
->sparse_index
||
132 !core_apply_sparse_checkout
|| !core_sparse_checkout_cone
)
136 istate
->repo
= the_repository
;
139 * The GIT_TEST_SPARSE_INDEX environment variable triggers the
140 * index.sparse config variable to be on.
142 test_env
= git_env_bool("GIT_TEST_SPARSE_INDEX", -1);
144 set_sparse_index_config(istate
->repo
, test_env
);
147 * Only convert to sparse if index.sparse is set.
149 prepare_repo_settings(istate
->repo
);
150 if (!istate
->repo
->settings
.sparse_index
)
153 if (!istate
->sparse_checkout_patterns
) {
154 istate
->sparse_checkout_patterns
= xcalloc(1, sizeof(struct pattern_list
));
155 if (get_sparse_checkout_patterns(istate
->sparse_checkout_patterns
) < 0)
159 if (!istate
->sparse_checkout_patterns
->use_cone_patterns
) {
160 warning(_("attempting to use sparse-index without cone mode"));
164 if (cache_tree_update(istate
, 0)) {
165 warning(_("unable to update cache-tree, staying full"));
169 remove_fsmonitor(istate
);
171 trace2_region_enter("index", "convert_to_sparse", istate
->repo
);
172 istate
->cache_nr
= convert_to_sparse_rec(istate
,
173 0, 0, istate
->cache_nr
,
174 "", 0, istate
->cache_tree
);
175 istate
->drop_cache_tree
= 1;
176 istate
->sparse_index
= 1;
177 trace2_region_leave("index", "convert_to_sparse", istate
->repo
);
181 static void set_index_entry(struct index_state
*istate
, int nr
, struct cache_entry
*ce
)
183 ALLOC_GROW(istate
->cache
, nr
+ 1, istate
->cache_alloc
);
185 istate
->cache
[nr
] = ce
;
186 add_name_hash(istate
, ce
);
189 static int add_path_to_index(const struct object_id
*oid
,
190 struct strbuf
*base
, const char *path
,
191 unsigned int mode
, void *context
)
193 struct index_state
*istate
= (struct index_state
*)context
;
194 struct cache_entry
*ce
;
195 size_t len
= base
->len
;
198 return READ_TREE_RECURSIVE
;
200 strbuf_addstr(base
, path
);
202 ce
= make_cache_entry(istate
, mode
, oid
, base
->buf
, 0, 0);
203 ce
->ce_flags
|= CE_SKIP_WORKTREE
;
204 set_index_entry(istate
, istate
->cache_nr
++, ce
);
206 strbuf_setlen(base
, len
);
210 void ensure_full_index(struct index_state
*istate
)
213 struct index_state
*full
;
214 struct strbuf base
= STRBUF_INIT
;
216 if (!istate
|| !istate
->sparse_index
)
220 istate
->repo
= the_repository
;
222 trace2_region_enter("index", "ensure_full_index", istate
->repo
);
224 /* initialize basics of new index */
225 full
= xcalloc(1, sizeof(struct index_state
));
226 memcpy(full
, istate
, sizeof(struct index_state
));
228 /* then change the necessary things */
229 full
->sparse_index
= 0;
230 full
->cache_alloc
= (3 * istate
->cache_alloc
) / 2;
232 ALLOC_ARRAY(full
->cache
, full
->cache_alloc
);
234 for (i
= 0; i
< istate
->cache_nr
; i
++) {
235 struct cache_entry
*ce
= istate
->cache
[i
];
239 if (!S_ISSPARSEDIR(ce
->ce_mode
)) {
240 set_index_entry(full
, full
->cache_nr
++, ce
);
243 if (!(ce
->ce_flags
& CE_SKIP_WORKTREE
))
244 warning(_("index entry is a directory, but not sparse (%08x)"),
247 /* recursively walk into cd->name */
248 tree
= lookup_tree(istate
->repo
, &ce
->oid
);
250 memset(&ps
, 0, sizeof(ps
));
255 strbuf_setlen(&base
, 0);
256 strbuf_add(&base
, ce
->name
, strlen(ce
->name
));
258 read_tree_at(istate
->repo
, tree
, &base
, &ps
,
259 add_path_to_index
, full
);
261 /* free directory entries. full entries are re-used */
262 discard_cache_entry(ce
);
265 /* Copy back into original index. */
266 memcpy(&istate
->name_hash
, &full
->name_hash
, sizeof(full
->name_hash
));
267 istate
->sparse_index
= 0;
269 istate
->cache
= full
->cache
;
270 istate
->cache_nr
= full
->cache_nr
;
271 istate
->cache_alloc
= full
->cache_alloc
;
273 strbuf_release(&base
);
276 trace2_region_leave("index", "ensure_full_index", istate
->repo
);