1 #include "git-compat-util.h"
2 #include "object-store-ll.h"
4 #include "environment.h"
8 #include "sparse-index.h"
10 #include "submodule.h"
13 #include "fsmonitor.h"
15 #include "parallel-checkout.h"
17 static void create_directories(const char *path
, int path_len
,
18 const struct checkout
*state
)
20 char *buf
= xmallocz(path_len
);
23 while (len
< path_len
) {
27 } while (len
< path_len
&& path
[len
] != '/');
33 * For 'checkout-index --prefix=<dir>', <dir> is
34 * allowed to be a symlink to an existing directory,
35 * and we set 'state->base_dir_len' below, such that
36 * we test the path components of the prefix with the
37 * stat() function instead of the lstat() function.
39 if (has_dirs_only_path(buf
, len
, state
->base_dir_len
))
40 continue; /* ok, it is already a directory. */
43 * If this mkdir() would fail, it could be that there
44 * is already a symlink or something else exists
45 * there, therefore we then try to unlink it and try
46 * one more time to create the directory.
48 if (mkdir(buf
, 0777)) {
49 if (errno
== EEXIST
&& state
->force
&&
50 !unlink_or_warn(buf
) && !mkdir(buf
, 0777))
52 die_errno("cannot create directory at '%s'", buf
);
58 static void remove_subtree(struct strbuf
*path
)
60 DIR *dir
= opendir(path
->buf
);
62 int origlen
= path
->len
;
65 die_errno("cannot opendir '%s'", path
->buf
);
66 while ((de
= readdir_skip_dot_and_dotdot(dir
)) != NULL
) {
69 strbuf_addch(path
, '/');
70 strbuf_addstr(path
, de
->d_name
);
71 if (lstat(path
->buf
, &st
))
72 die_errno("cannot lstat '%s'", path
->buf
);
73 if (S_ISDIR(st
.st_mode
))
75 else if (unlink(path
->buf
))
76 die_errno("cannot unlink '%s'", path
->buf
);
77 strbuf_setlen(path
, origlen
);
81 die_errno("cannot rmdir '%s'", path
->buf
);
84 static int create_file(const char *path
, unsigned int mode
)
86 mode
= (mode
& 0100) ? 0777 : 0666;
87 return open(path
, O_WRONLY
| O_CREAT
| O_EXCL
, mode
);
90 void *read_blob_entry(const struct cache_entry
*ce
, size_t *size
)
92 enum object_type type
;
94 void *blob_data
= repo_read_object_file(the_repository
, &ce
->oid
,
106 static int open_output_fd(char *path
, const struct cache_entry
*ce
, int to_tempfile
)
108 int symlink
= (ce
->ce_mode
& S_IFMT
) != S_IFREG
;
110 xsnprintf(path
, TEMPORARY_FILENAME_LENGTH
, "%s",
111 symlink
? ".merge_link_XXXXXX" : ".merge_file_XXXXXX");
112 return mkstemp(path
);
114 return create_file(path
, !symlink
? ce
->ce_mode
: 0666);
118 int fstat_checkout_output(int fd
, const struct checkout
*state
, struct stat
*st
)
120 /* use fstat() only when path == ce->name */
121 if (fstat_is_reliable() &&
122 state
->refresh_cache
&& !state
->base_dir_len
) {
123 return !fstat(fd
, st
);
128 static int streaming_write_entry(const struct cache_entry
*ce
, char *path
,
129 struct stream_filter
*filter
,
130 const struct checkout
*state
, int to_tempfile
,
131 int *fstat_done
, struct stat
*statbuf
)
136 fd
= open_output_fd(path
, ce
, to_tempfile
);
140 result
|= stream_blob_to_fd(fd
, &ce
->oid
, filter
, 1);
141 *fstat_done
= fstat_checkout_output(fd
, state
, statbuf
);
149 void enable_delayed_checkout(struct checkout
*state
)
151 if (!state
->delayed_checkout
) {
152 state
->delayed_checkout
= xmalloc(sizeof(*state
->delayed_checkout
));
153 state
->delayed_checkout
->state
= CE_CAN_DELAY
;
154 string_list_init_nodup(&state
->delayed_checkout
->filters
);
155 string_list_init_nodup(&state
->delayed_checkout
->paths
);
159 static int remove_available_paths(struct string_list_item
*item
, void *cb_data
)
161 struct string_list
*available_paths
= cb_data
;
162 struct string_list_item
*available
;
164 available
= string_list_lookup(available_paths
, item
->string
);
166 available
->util
= item
->util
;
170 static int string_is_not_null(struct string_list_item
*item
, void *data UNUSED
)
172 return !!item
->string
;
175 int finish_delayed_checkout(struct checkout
*state
, int show_progress
)
178 unsigned processed_paths
= 0;
179 off_t filtered_bytes
= 0;
180 struct string_list_item
*filter
, *path
;
181 struct progress
*progress
= NULL
;
182 struct delayed_checkout
*dco
= state
->delayed_checkout
;
184 if (!state
->delayed_checkout
)
187 dco
->state
= CE_RETRY
;
189 progress
= start_delayed_progress(_("Filtering content"), dco
->paths
.nr
);
190 while (dco
->filters
.nr
> 0) {
191 for_each_string_list_item(filter
, &dco
->filters
) {
192 struct string_list available_paths
= STRING_LIST_INIT_NODUP
;
194 if (!async_query_available_blobs(filter
->string
, &available_paths
)) {
195 /* Filter reported an error */
197 filter
->string
= NULL
;
200 if (available_paths
.nr
<= 0) {
202 * Filter responded with no entries. That means
203 * the filter is done and we can remove the
204 * filter from the list (see
205 * "string_list_remove_empty_items" call below).
207 filter
->string
= NULL
;
212 * In dco->paths we store a list of all delayed paths.
213 * The filter just send us a list of available paths.
214 * Remove them from the list.
216 filter_string_list(&dco
->paths
, 0,
217 &remove_available_paths
, &available_paths
);
219 for_each_string_list_item(path
, &available_paths
) {
220 struct cache_entry
* ce
;
223 error("external filter '%s' signaled that '%s' "
224 "is now available although it has not been "
226 filter
->string
, path
->string
);
230 * Do not ask the filter for available blobs,
231 * again, as the filter is likely buggy.
233 filter
->string
= NULL
;
236 ce
= index_file_exists(state
->istate
, path
->string
,
237 strlen(path
->string
), 0);
239 display_progress(progress
, ++processed_paths
);
240 errs
|= checkout_entry(ce
, state
, NULL
, path
->util
);
241 filtered_bytes
+= ce
->ce_stat_data
.sd_size
;
242 display_throughput(progress
, filtered_bytes
);
248 filter_string_list(&dco
->filters
, 0, string_is_not_null
, NULL
);
250 stop_progress(&progress
);
251 string_list_clear(&dco
->filters
, 0);
253 /* At this point we should not have any delayed paths anymore. */
254 errs
|= dco
->paths
.nr
;
255 for_each_string_list_item(path
, &dco
->paths
) {
256 error("'%s' was not filtered properly", path
->string
);
258 string_list_clear(&dco
->paths
, 0);
261 state
->delayed_checkout
= NULL
;
266 void update_ce_after_write(const struct checkout
*state
, struct cache_entry
*ce
,
269 if (state
->refresh_cache
) {
270 assert(state
->istate
);
271 fill_stat_cache_info(state
->istate
, ce
, st
);
272 ce
->ce_flags
|= CE_UPDATE_IN_BASE
;
273 mark_fsmonitor_invalid(state
->istate
, ce
);
274 state
->istate
->cache_changed
|= CE_ENTRY_CHANGED
;
278 /* Note: ca is used (and required) iff the entry refers to a regular file. */
279 static int write_entry(struct cache_entry
*ce
, char *path
, struct conv_attrs
*ca
,
280 const struct checkout
*state
, int to_tempfile
,
283 unsigned int ce_mode_s_ifmt
= ce
->ce_mode
& S_IFMT
;
284 struct delayed_checkout
*dco
= state
->delayed_checkout
;
285 int fd
, ret
, fstat_done
= 0;
287 struct strbuf buf
= STRBUF_INIT
;
292 const struct submodule
*sub
;
293 struct checkout_metadata meta
;
294 static int scratch_nr_checkouts
;
296 clone_checkout_metadata(&meta
, &state
->meta
, &ce
->oid
);
298 if (ce_mode_s_ifmt
== S_IFREG
) {
299 struct stream_filter
*filter
= get_stream_filter_ca(ca
, &ce
->oid
);
301 !streaming_write_entry(ce
, path
, filter
,
307 switch (ce_mode_s_ifmt
) {
309 new_blob
= read_blob_entry(ce
, &size
);
311 return error("unable to read sha1 file of %s (%s)",
312 ce
->name
, oid_to_hex(&ce
->oid
));
315 * We can't make a real symlink; write out a regular file entry
316 * with the symlink destination as its contents.
318 if (!has_symlinks
|| to_tempfile
)
319 goto write_file_entry
;
321 ret
= symlink(new_blob
, path
);
324 return error_errno("unable to create symlink %s", path
);
329 * We do not send the blob in case of a retry, so do not
330 * bother reading it at all.
332 if (dco
&& dco
->state
== CE_RETRY
) {
336 new_blob
= read_blob_entry(ce
, &size
);
338 return error("unable to read sha1 file of %s (%s)",
339 ce
->name
, oid_to_hex(&ce
->oid
));
343 * Convert from git internal format to working tree format
345 if (dco
&& dco
->state
!= CE_NO_DELAY
) {
346 ret
= async_convert_to_working_tree_ca(ca
, ce
->name
,
350 struct string_list_item
*item
=
351 string_list_lookup(&dco
->paths
, ce
->name
);
353 item
->util
= nr_checkouts
? nr_checkouts
354 : &scratch_nr_checkouts
;
360 ret
= convert_to_working_tree_ca(ca
, ce
->name
, new_blob
,
366 new_blob
= strbuf_detach(&buf
, &newsize
);
370 * No "else" here as errors from convert are OK at this
371 * point. If the error would have been fatal (e.g.
372 * filter is required), then we would have died already.
376 fd
= open_output_fd(path
, ce
, to_tempfile
);
379 return error_errno("unable to create file %s", path
);
382 wrote
= write_in_full(fd
, new_blob
, size
);
384 fstat_done
= fstat_checkout_output(fd
, state
, &st
);
388 return error("unable to write file %s", path
);
393 return error("cannot create temporary submodule %s", ce
->name
);
394 if (mkdir(path
, 0777) < 0)
395 return error("cannot create submodule directory %s", path
);
396 sub
= submodule_from_ce(ce
);
398 return submodule_move_head(ce
->name
, state
->super_prefix
,
399 NULL
, oid_to_hex(&ce
->oid
),
400 state
->force
? SUBMODULE_MOVE_HEAD_FORCE
: 0);
404 return error("unknown file mode for %s in index", ce
->name
);
408 if (state
->refresh_cache
) {
409 if (!fstat_done
&& lstat(ce
->name
, &st
) < 0)
410 return error_errno("unable to stat just-written file %s",
412 update_ce_after_write(state
, ce
, &st
);
421 * This is like 'lstat()', except it refuses to follow symlinks
422 * in the path, after skipping "skiplen".
424 static int check_path(const char *path
, int len
, struct stat
*st
, int skiplen
)
426 const char *slash
= path
+ len
;
428 while (path
< slash
&& *slash
!= '/')
430 if (!has_dirs_only_path(path
, slash
- path
, skiplen
)) {
434 return lstat(path
, st
);
437 static void mark_colliding_entries(const struct checkout
*state
,
438 struct cache_entry
*ce
, struct stat
*st
)
440 int i
, trust_ino
= check_stat
;
442 #if defined(GIT_WINDOWS_NATIVE) || defined(__CYGWIN__)
446 ce
->ce_flags
|= CE_MATCHED
;
448 /* TODO: audit for interaction with sparse-index. */
449 ensure_full_index(state
->istate
);
450 for (i
= 0; i
< state
->istate
->cache_nr
; i
++) {
451 struct cache_entry
*dup
= state
->istate
->cache
[i
];
455 * Parallel checkout doesn't create the files in index
456 * order. So the other side of the collision may appear
457 * after the given cache_entry in the array.
459 if (parallel_checkout_status() == PC_RUNNING
)
465 if (dup
->ce_flags
& (CE_MATCHED
| CE_VALID
| CE_SKIP_WORKTREE
))
468 if ((trust_ino
&& !match_stat_data(&dup
->ce_stat_data
, st
)) ||
469 paths_collide(ce
->name
, dup
->name
)) {
470 dup
->ce_flags
|= CE_MATCHED
;
476 int checkout_entry_ca(struct cache_entry
*ce
, struct conv_attrs
*ca
,
477 const struct checkout
*state
, char *topath
,
480 static struct strbuf path
= STRBUF_INIT
;
482 struct conv_attrs ca_buf
;
484 if (ce
->ce_flags
& CE_WT_REMOVE
) {
487 * No content and thus no path to create, so we have
488 * no pathname to return.
490 BUG("Can't remove entry to a path");
491 unlink_entry(ce
, state
->super_prefix
);
496 if (S_ISREG(ce
->ce_mode
) && !ca
) {
497 convert_attrs(state
->istate
, &ca_buf
, ce
->name
);
500 return write_entry(ce
, topath
, ca
, state
, 1, nr_checkouts
);
504 strbuf_add(&path
, state
->base_dir
, state
->base_dir_len
);
505 strbuf_add(&path
, ce
->name
, ce_namelen(ce
));
507 if (!check_path(path
.buf
, path
.len
, &st
, state
->base_dir_len
)) {
508 const struct submodule
*sub
;
509 unsigned changed
= ie_match_stat(state
->istate
, ce
, &st
,
510 CE_MATCH_IGNORE_VALID
| CE_MATCH_IGNORE_SKIP_WORKTREE
);
512 * Needs to be checked before !changed returns early,
513 * as the possibly empty directory was not changed
515 sub
= submodule_from_ce(ce
);
518 if (!is_submodule_populated_gently(ce
->name
, &err
)) {
520 if (lstat(ce
->name
, &sb
))
521 die(_("could not stat file '%s'"), ce
->name
);
522 if (!(st
.st_mode
& S_IFDIR
))
523 unlink_or_warn(ce
->name
);
525 return submodule_move_head(ce
->name
, state
->super_prefix
,
526 NULL
, oid_to_hex(&ce
->oid
), 0);
528 return submodule_move_head(ce
->name
, state
->super_prefix
,
529 "HEAD", oid_to_hex(&ce
->oid
),
530 state
->force
? SUBMODULE_MOVE_HEAD_FORCE
: 0);
538 "%s already exists, no checkout\n",
544 mark_colliding_entries(state
, ce
, &st
);
547 * We unlink the old file, to get the new one with the
548 * right permissions (including umask, which is nasty
549 * to emulate by hand - much easier to let the system
550 * just do the right thing)
552 if (S_ISDIR(st
.st_mode
)) {
553 /* If it is a gitlink, leave it alone! */
554 if (S_ISGITLINK(ce
->ce_mode
))
557 * We must avoid replacing submodules' leading
558 * directories with symbolic links, lest recursive
559 * clones can write into arbitrary locations.
561 * Technically, this logic is not limited
562 * to recursive clones, or for that matter to
563 * submodules' paths colliding with symbolic links'
564 * paths. Yet it strikes a balance in favor of
565 * simplicity, and if paths are colliding, we might
566 * just as well keep the directories during a clone.
568 if (state
->clone
&& S_ISLNK(ce
->ce_mode
))
570 remove_subtree(&path
);
571 } else if (unlink(path
.buf
))
572 return error_errno("unable to unlink old '%s'", path
.buf
);
573 } else if (state
->not_new
)
576 create_directories(path
.buf
, path
.len
, state
);
578 if (S_ISREG(ce
->ce_mode
) && !ca
) {
579 convert_attrs(state
->istate
, &ca_buf
, ce
->name
);
583 if (!enqueue_checkout(ce
, ca
, nr_checkouts
))
586 return write_entry(ce
, path
.buf
, ca
, state
, 0, nr_checkouts
);
589 void unlink_entry(const struct cache_entry
*ce
, const char *super_prefix
)
591 const struct submodule
*sub
= submodule_from_ce(ce
);
593 /* state.force is set at the caller. */
594 submodule_move_head(ce
->name
, super_prefix
, "HEAD", NULL
,
595 SUBMODULE_MOVE_HEAD_FORCE
);
597 if (check_leading_path(ce
->name
, ce_namelen(ce
), 1) >= 0)
599 if (remove_or_warn(ce
->ce_mode
, ce
->name
))
601 schedule_dir_for_removal(ce
->name
, ce_namelen(ce
));
604 int remove_or_warn(unsigned int mode
, const char *file
)
606 return S_ISGITLINK(mode
) ? rmdir_or_warn(file
) : unlink_or_warn(file
);