blob: f918a3a78e8154fb62de1fb2378d100f9c47e9ca [file] [log] [blame]
Elijah Newrenbc5c5ec2023-05-16 06:33:57 +00001#include "git-compat-util.h"
Elijah Newrena034e912023-05-16 06:34:06 +00002#include "object-store-ll.h"
Alexander Potashev8ca12c02009-01-10 15:07:50 +03003#include "dir.h"
Elijah Newren32a8f512023-03-21 06:26:03 +00004#include "environment.h"
Elijah Newrenf394e092023-03-21 06:25:54 +00005#include "gettext.h"
Elijah Newren41771fa2023-02-24 00:09:27 +00006#include "hex.h"
Elijah Newrenf5653852023-05-16 06:33:50 +00007#include "name-hash.h"
Elijah Newrenbaf889c2023-05-16 06:33:51 +00008#include "sparse-index.h"
Junio C Hamanodd8e9122011-05-12 14:31:08 -07009#include "streaming.h"
Stefan Beller6d14eac2017-03-14 14:46:40 -070010#include "submodule.h"
Elijah Newrencb2a5132023-04-22 20:17:09 +000011#include "symlinks.h"
Lars Schneider52f1d622017-08-20 17:47:20 +020012#include "progress.h"
Ben Peart883e2482017-09-22 12:35:40 -040013#include "fsmonitor.h"
Matheus Tavaresd052cc02021-03-23 11:19:32 -030014#include "entry.h"
Matheus Tavares04155bd2021-04-18 21:14:53 -030015#include "parallel-checkout.h"
Linus Torvalds12dccc12005-06-05 21:59:54 -070016
Kjetil Barvik81a9aa62009-02-09 21:54:08 +010017static void create_directories(const char *path, int path_len,
18 const struct checkout *state)
Linus Torvalds12dccc12005-06-05 21:59:54 -070019{
Jeff King3733e692016-02-22 17:44:28 -050020 char *buf = xmallocz(path_len);
Kjetil Barvik81a9aa62009-02-09 21:54:08 +010021 int len = 0;
Linus Torvalds12dccc12005-06-05 21:59:54 -070022
Kjetil Barvik81a9aa62009-02-09 21:54:08 +010023 while (len < path_len) {
24 do {
25 buf[len] = path[len];
26 len++;
27 } while (len < path_len && path[len] != '/');
28 if (len >= path_len)
29 break;
Linus Torvalds12dccc12005-06-05 21:59:54 -070030 buf[len] = 0;
Junio C Hamanofa2e71c2007-07-17 22:58:28 -070031
Kjetil Barvikbad4a542009-01-18 16:14:52 +010032 /*
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.
38 */
Kjetil Barvik57199892009-02-09 21:54:06 +010039 if (has_dirs_only_path(buf, len, state->base_dir_len))
Junio C Hamanofa2e71c2007-07-17 22:58:28 -070040 continue; /* ok, it is already a directory. */
41
42 /*
Kjetil Barvikbad4a542009-01-18 16:14:52 +010043 * 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.
Junio C Hamanofa2e71c2007-07-17 22:58:28 -070047 */
Junio C Hamanof312de02005-07-06 01:21:46 -070048 if (mkdir(buf, 0777)) {
Junio C Hamanofa2e71c2007-07-17 22:58:28 -070049 if (errno == EEXIST && state->force &&
Alex Riesen691f1a22009-04-29 23:22:56 +020050 !unlink_or_warn(buf) && !mkdir(buf, 0777))
Junio C Hamanofa2e71c2007-07-17 22:58:28 -070051 continue;
Thomas Rast0721c312009-06-27 17:58:47 +020052 die_errno("cannot create directory at '%s'", buf);
Linus Torvalds12dccc12005-06-05 21:59:54 -070053 }
54 }
55 free(buf);
56}
57
Michael Haggerty2f29e0c2014-03-13 10:19:08 +010058static void remove_subtree(struct strbuf *path)
Linus Torvalds12dccc12005-06-05 21:59:54 -070059{
Michael Haggerty2f29e0c2014-03-13 10:19:08 +010060 DIR *dir = opendir(path->buf);
Linus Torvalds12dccc12005-06-05 21:59:54 -070061 struct dirent *de;
Michael Haggerty2f29e0c2014-03-13 10:19:08 +010062 int origlen = path->len;
Junio C Hamanoa6080a02007-06-07 00:04:01 -070063
Linus Torvalds12dccc12005-06-05 21:59:54 -070064 if (!dir)
Michael Haggerty2f29e0c2014-03-13 10:19:08 +010065 die_errno("cannot opendir '%s'", path->buf);
Elijah Newrenb548f0f2021-05-12 17:28:22 +000066 while ((de = readdir_skip_dot_and_dotdot(dir)) != NULL) {
Linus Torvalds12dccc12005-06-05 21:59:54 -070067 struct stat st;
Michael Haggerty2f29e0c2014-03-13 10:19:08 +010068
Michael Haggerty2f29e0c2014-03-13 10:19:08 +010069 strbuf_addch(path, '/');
70 strbuf_addstr(path, de->d_name);
71 if (lstat(path->buf, &st))
72 die_errno("cannot lstat '%s'", path->buf);
Linus Torvalds12dccc12005-06-05 21:59:54 -070073 if (S_ISDIR(st.st_mode))
Michael Haggerty2f29e0c2014-03-13 10:19:08 +010074 remove_subtree(path);
75 else if (unlink(path->buf))
76 die_errno("cannot unlink '%s'", path->buf);
77 strbuf_setlen(path, origlen);
Linus Torvalds12dccc12005-06-05 21:59:54 -070078 }
79 closedir(dir);
Michael Haggerty2f29e0c2014-03-13 10:19:08 +010080 if (rmdir(path->buf))
81 die_errno("cannot rmdir '%s'", path->buf);
Linus Torvalds12dccc12005-06-05 21:59:54 -070082}
83
Linus Torvaldsd48a72f2005-07-14 09:58:45 -070084static int create_file(const char *path, unsigned int mode)
Linus Torvalds12dccc12005-06-05 21:59:54 -070085{
Linus Torvalds12dccc12005-06-05 21:59:54 -070086 mode = (mode & 0100) ? 0777 : 0666;
Alex Riesen781411e2006-01-05 09:58:06 +010087 return open(path, O_WRONLY | O_CREAT | O_EXCL, mode);
Linus Torvalds12dccc12005-06-05 21:59:54 -070088}
89
Matt Coopere9aa7622021-11-02 15:46:08 +000090void *read_blob_entry(const struct cache_entry *ce, size_t *size)
Linus Torvaldsf0807e62007-04-13 09:26:04 -070091{
92 enum object_type type;
Matt Coopere9aa7622021-11-02 15:46:08 +000093 unsigned long ul;
Ævar Arnfjörð Bjarmasonbc726bd2023-03-28 15:58:50 +020094 void *blob_data = repo_read_object_file(the_repository, &ce->oid,
95 &type, &ul);
Linus Torvaldsf0807e62007-04-13 09:26:04 -070096
Matt Coopere9aa7622021-11-02 15:46:08 +000097 *size = ul;
Brandon Williamsd8f71802018-02-14 10:59:41 -080098 if (blob_data) {
Linus Torvaldsf0807e62007-04-13 09:26:04 -070099 if (type == OBJ_BLOB)
Brandon Williamsd8f71802018-02-14 10:59:41 -0800100 return blob_data;
101 free(blob_data);
Linus Torvaldsf0807e62007-04-13 09:26:04 -0700102 }
103 return NULL;
104}
105
Nguyễn Thái Ngọc Duy9c5e6c82013-07-09 22:29:00 +0700106static int open_output_fd(char *path, const struct cache_entry *ce, int to_tempfile)
Junio C Hamanofd5db552011-05-12 21:36:42 -0700107{
108 int symlink = (ce->ce_mode & S_IFMT) != S_IFREG;
109 if (to_tempfile) {
Jeff King330c8e22015-09-24 17:06:53 -0400110 xsnprintf(path, TEMPORARY_FILENAME_LENGTH, "%s",
111 symlink ? ".merge_link_XXXXXX" : ".merge_file_XXXXXX");
Junio C Hamanofd5db552011-05-12 21:36:42 -0700112 return mkstemp(path);
113 } else {
114 return create_file(path, !symlink ? ce->ce_mode : 0666);
115 }
116}
117
Matheus Tavares49cfd902021-03-23 11:19:33 -0300118int fstat_checkout_output(int fd, const struct checkout *state, struct stat *st)
Junio C Hamanofd5db552011-05-12 21:36:42 -0700119{
120 /* use fstat() only when path == ce->name */
121 if (fstat_is_reliable() &&
122 state->refresh_cache && !state->base_dir_len) {
Matheus Tavares35e6e212020-07-08 23:10:39 -0300123 return !fstat(fd, st);
Junio C Hamanofd5db552011-05-12 21:36:42 -0700124 }
125 return 0;
126}
127
Nguyễn Thái Ngọc Duy9c5e6c82013-07-09 22:29:00 +0700128static int streaming_write_entry(const struct cache_entry *ce, char *path,
Junio C Hamanob6691092011-05-20 14:33:31 -0700129 struct stream_filter *filter,
Junio C Hamanodd8e9122011-05-12 14:31:08 -0700130 const struct checkout *state, int to_tempfile,
131 int *fstat_done, struct stat *statbuf)
132{
Jeff Kingd9c31e12013-03-25 17:49:36 -0400133 int result = 0;
Junio C Hamano47a02ff2012-03-07 17:54:15 +0700134 int fd;
Junio C Hamanodd8e9122011-05-12 14:31:08 -0700135
136 fd = open_output_fd(path, ce, to_tempfile);
Jeff Kingd9c31e12013-03-25 17:49:36 -0400137 if (fd < 0)
138 return -1;
139
brian m. carlson7eda0e42016-09-05 20:07:59 +0000140 result |= stream_blob_to_fd(fd, &ce->oid, filter, 1);
Matheus Tavares49cfd902021-03-23 11:19:33 -0300141 *fstat_done = fstat_checkout_output(fd, state, statbuf);
Jeff Kingd9c31e12013-03-25 17:49:36 -0400142 result |= close(fd);
143
144 if (result)
Junio C Hamanodd8e9122011-05-12 14:31:08 -0700145 unlink(path);
146 return result;
147}
148
Lars Schneider2841e8f2017-06-30 22:41:28 +0200149void enable_delayed_checkout(struct checkout *state)
150{
151 if (!state->delayed_checkout) {
152 state->delayed_checkout = xmalloc(sizeof(*state->delayed_checkout));
153 state->delayed_checkout->state = CE_CAN_DELAY;
Ævar Arnfjörð Bjarmasonbc40dfb2021-07-01 12:51:29 +0200154 string_list_init_nodup(&state->delayed_checkout->filters);
155 string_list_init_nodup(&state->delayed_checkout->paths);
Lars Schneider2841e8f2017-06-30 22:41:28 +0200156 }
157}
158
159static int remove_available_paths(struct string_list_item *item, void *cb_data)
160{
161 struct string_list *available_paths = cb_data;
162 struct string_list_item *available;
163
164 available = string_list_lookup(available_paths, item->string);
165 if (available)
Matheus Tavares611c7782022-07-14 08:49:12 -0300166 available->util = item->util;
Lars Schneider2841e8f2017-06-30 22:41:28 +0200167 return !available;
168}
169
Matheus Tavares611c7782022-07-14 08:49:12 -0300170int finish_delayed_checkout(struct checkout *state, int show_progress)
Lars Schneider2841e8f2017-06-30 22:41:28 +0200171{
172 int errs = 0;
SZEDER Gáborbf6d8192021-09-09 03:10:12 +0200173 unsigned processed_paths = 0;
Lars Schneider52f1d622017-08-20 17:47:20 +0200174 off_t filtered_bytes = 0;
Lars Schneider2841e8f2017-06-30 22:41:28 +0200175 struct string_list_item *filter, *path;
SZEDER Gáborbf6d8192021-09-09 03:10:12 +0200176 struct progress *progress = NULL;
Lars Schneider2841e8f2017-06-30 22:41:28 +0200177 struct delayed_checkout *dco = state->delayed_checkout;
178
179 if (!state->delayed_checkout)
180 return errs;
181
182 dco->state = CE_RETRY;
SZEDER Gáborbf6d8192021-09-09 03:10:12 +0200183 if (show_progress)
184 progress = start_delayed_progress(_("Filtering content"), dco->paths.nr);
Lars Schneider2841e8f2017-06-30 22:41:28 +0200185 while (dco->filters.nr > 0) {
186 for_each_string_list_item(filter, &dco->filters) {
187 struct string_list available_paths = STRING_LIST_INIT_NODUP;
188
189 if (!async_query_available_blobs(filter->string, &available_paths)) {
190 /* Filter reported an error */
191 errs = 1;
192 filter->string = "";
193 continue;
194 }
195 if (available_paths.nr <= 0) {
196 /*
197 * Filter responded with no entries. That means
198 * the filter is done and we can remove the
199 * filter from the list (see
200 * "string_list_remove_empty_items" call below).
201 */
202 filter->string = "";
203 continue;
204 }
205
206 /*
207 * In dco->paths we store a list of all delayed paths.
208 * The filter just send us a list of available paths.
209 * Remove them from the list.
210 */
211 filter_string_list(&dco->paths, 0,
212 &remove_available_paths, &available_paths);
213
214 for_each_string_list_item(path, &available_paths) {
215 struct cache_entry* ce;
216
217 if (!path->util) {
218 error("external filter '%s' signaled that '%s' "
219 "is now available although it has not been "
220 "delayed earlier",
221 filter->string, path->string);
222 errs |= 1;
223
224 /*
225 * Do not ask the filter for available blobs,
226 * again, as the filter is likely buggy.
227 */
228 filter->string = "";
229 continue;
230 }
231 ce = index_file_exists(state->istate, path->string,
232 strlen(path->string), 0);
Lars Schneider52f1d622017-08-20 17:47:20 +0200233 if (ce) {
SZEDER Gáborbf6d8192021-09-09 03:10:12 +0200234 display_progress(progress, ++processed_paths);
Matheus Tavares611c7782022-07-14 08:49:12 -0300235 errs |= checkout_entry(ce, state, NULL, path->util);
Lars Schneider52f1d622017-08-20 17:47:20 +0200236 filtered_bytes += ce->ce_stat_data.sd_size;
237 display_throughput(progress, filtered_bytes);
238 } else
239 errs = 1;
Lars Schneider2841e8f2017-06-30 22:41:28 +0200240 }
241 }
242 string_list_remove_empty_items(&dco->filters, 0);
243 }
Lars Schneider52f1d622017-08-20 17:47:20 +0200244 stop_progress(&progress);
Lars Schneider2841e8f2017-06-30 22:41:28 +0200245 string_list_clear(&dco->filters, 0);
246
247 /* At this point we should not have any delayed paths anymore. */
248 errs |= dco->paths.nr;
249 for_each_string_list_item(path, &dco->paths) {
250 error("'%s' was not filtered properly", path->string);
251 }
252 string_list_clear(&dco->paths, 0);
253
254 free(dco);
255 state->delayed_checkout = NULL;
256
257 return errs;
258}
259
Matheus Tavares584a0d12021-03-23 11:19:34 -0300260void update_ce_after_write(const struct checkout *state, struct cache_entry *ce,
261 struct stat *st)
262{
263 if (state->refresh_cache) {
264 assert(state->istate);
265 fill_stat_cache_info(state->istate, ce, st);
266 ce->ce_flags |= CE_UPDATE_IN_BASE;
267 mark_fsmonitor_invalid(state->istate, ce);
268 state->istate->cache_changed |= CE_ENTRY_CHANGED;
269 }
270}
271
Matheus Tavares30419e72021-03-23 11:19:35 -0300272/* Note: ca is used (and required) iff the entry refers to a regular file. */
273static int write_entry(struct cache_entry *ce, char *path, struct conv_attrs *ca,
Matheus Tavares611c7782022-07-14 08:49:12 -0300274 const struct checkout *state, int to_tempfile,
275 int *nr_checkouts)
Linus Torvalds12dccc12005-06-05 21:59:54 -0700276{
Kjetil Barvik4857c762009-02-09 21:54:50 +0100277 unsigned int ce_mode_s_ifmt = ce->ce_mode & S_IFMT;
Jeff Kingc602d3a2017-10-09 13:48:52 -0400278 struct delayed_checkout *dco = state->delayed_checkout;
Kjetil Barvike4c72922009-02-09 21:54:51 +0100279 int fd, ret, fstat_done = 0;
Brandon Williamsd8f71802018-02-14 10:59:41 -0800280 char *new_blob;
Kjetil Barvik4857c762009-02-09 21:54:50 +0100281 struct strbuf buf = STRBUF_INIT;
Matt Coopere9aa7622021-11-02 15:46:08 +0000282 size_t size;
Jeff King564bde92017-09-13 13:16:28 -0400283 ssize_t wrote;
284 size_t newsize = 0;
Kjetil Barvike4c72922009-02-09 21:54:51 +0100285 struct stat st;
Stefan Beller6d14eac2017-03-14 14:46:40 -0700286 const struct submodule *sub;
brian m. carlsonc397aac2020-03-16 18:05:03 +0000287 struct checkout_metadata meta;
Matheus Tavares611c7782022-07-14 08:49:12 -0300288 static int scratch_nr_checkouts;
brian m. carlsonc397aac2020-03-16 18:05:03 +0000289
290 clone_checkout_metadata(&meta, &state->meta, &ce->oid);
Linus Torvalds12dccc12005-06-05 21:59:54 -0700291
Junio C Hamanob6691092011-05-20 14:33:31 -0700292 if (ce_mode_s_ifmt == S_IFREG) {
Matheus Tavares30419e72021-03-23 11:19:35 -0300293 struct stream_filter *filter = get_stream_filter_ca(ca, &ce->oid);
Junio C Hamanob6691092011-05-20 14:33:31 -0700294 if (filter &&
295 !streaming_write_entry(ce, path, filter,
296 state, to_tempfile,
297 &fstat_done, &st))
298 goto finish;
299 }
Junio C Hamanodd8e9122011-05-12 14:31:08 -0700300
Kjetil Barvik4857c762009-02-09 21:54:50 +0100301 switch (ce_mode_s_ifmt) {
Kjetil Barvik4857c762009-02-09 21:54:50 +0100302 case S_IFLNK:
Brandon Williamsd8f71802018-02-14 10:59:41 -0800303 new_blob = read_blob_entry(ce, &size);
304 if (!new_blob)
Nguyễn Thái Ngọc Duyd43e9072010-11-28 11:36:38 +0700305 return error("unable to read sha1 file of %s (%s)",
Matheus Tavares9334ea82021-02-16 11:06:51 -0300306 ce->name, oid_to_hex(&ce->oid));
Junio C Hamano1a9d7e92007-08-14 01:41:02 -0700307
Jeff King7cbbf9d2017-10-09 13:50:05 -0400308 /*
309 * We can't make a real symlink; write out a regular file entry
310 * with the symlink destination as its contents.
311 */
312 if (!has_symlinks || to_tempfile)
313 goto write_file_entry;
314
Brandon Williamsd8f71802018-02-14 10:59:41 -0800315 ret = symlink(new_blob, path);
316 free(new_blob);
Jeff King7cbbf9d2017-10-09 13:50:05 -0400317 if (ret)
318 return error_errno("unable to create symlink %s", path);
319 break;
320
321 case S_IFREG:
Jeff Kingc602d3a2017-10-09 13:48:52 -0400322 /*
323 * We do not send the blob in case of a retry, so do not
324 * bother reading it at all.
325 */
Jeff King7cbbf9d2017-10-09 13:50:05 -0400326 if (dco && dco->state == CE_RETRY) {
Brandon Williamsd8f71802018-02-14 10:59:41 -0800327 new_blob = NULL;
Jeff Kingc602d3a2017-10-09 13:48:52 -0400328 size = 0;
329 } else {
Brandon Williamsd8f71802018-02-14 10:59:41 -0800330 new_blob = read_blob_entry(ce, &size);
331 if (!new_blob)
Jeff Kingc602d3a2017-10-09 13:48:52 -0400332 return error("unable to read sha1 file of %s (%s)",
Matheus Tavares9334ea82021-02-16 11:06:51 -0300333 ce->name, oid_to_hex(&ce->oid));
Kjetil Barvik4857c762009-02-09 21:54:50 +0100334 }
335
Junio C Hamano1a9d7e92007-08-14 01:41:02 -0700336 /*
337 * Convert from git internal format to working tree format
338 */
Jeff King7cbbf9d2017-10-09 13:50:05 -0400339 if (dco && dco->state != CE_NO_DELAY) {
Matheus Tavares30419e72021-03-23 11:19:35 -0300340 ret = async_convert_to_working_tree_ca(ca, ce->name,
341 new_blob, size,
342 &buf, &meta, dco);
Matheus Tavares611c7782022-07-14 08:49:12 -0300343 if (ret) {
344 struct string_list_item *item =
345 string_list_lookup(&dco->paths, ce->name);
346 if (item) {
347 item->util = nr_checkouts ? nr_checkouts
348 : &scratch_nr_checkouts;
349 free(new_blob);
350 goto delayed;
351 }
Lars Schneider2841e8f2017-06-30 22:41:28 +0200352 }
Matheus Tavares30419e72021-03-23 11:19:35 -0300353 } else {
354 ret = convert_to_working_tree_ca(ca, ce->name, new_blob,
355 size, &buf, &meta);
356 }
Junio C Hamano1a9d7e92007-08-14 01:41:02 -0700357
Jeff King7cbbf9d2017-10-09 13:50:05 -0400358 if (ret) {
Brandon Williamsd8f71802018-02-14 10:59:41 -0800359 free(new_blob);
360 new_blob = strbuf_detach(&buf, &newsize);
Jeff King7cbbf9d2017-10-09 13:50:05 -0400361 size = newsize;
362 }
363 /*
364 * No "else" here as errors from convert are OK at this
365 * point. If the error would have been fatal (e.g.
366 * filter is required), then we would have died already.
367 */
368
369 write_file_entry:
Junio C Hamanofd5db552011-05-12 21:36:42 -0700370 fd = open_output_fd(path, ce, to_tempfile);
Linus Torvalds12dccc12005-06-05 21:59:54 -0700371 if (fd < 0) {
Brandon Williamsd8f71802018-02-14 10:59:41 -0800372 free(new_blob);
Nguyễn Thái Ngọc Duye1ebb3c2016-05-08 16:47:44 +0700373 return error_errno("unable to create file %s", path);
Linus Torvalds12dccc12005-06-05 21:59:54 -0700374 }
Linus Torvalds6c510be2007-02-13 11:07:23 -0800375
Brandon Williamsd8f71802018-02-14 10:59:41 -0800376 wrote = write_in_full(fd, new_blob, size);
Junio C Hamanofd5db552011-05-12 21:36:42 -0700377 if (!to_tempfile)
Matheus Tavares49cfd902021-03-23 11:19:33 -0300378 fstat_done = fstat_checkout_output(fd, state, &st);
Linus Torvalds12dccc12005-06-05 21:59:54 -0700379 close(fd);
Brandon Williamsd8f71802018-02-14 10:59:41 -0800380 free(new_blob);
Jeff King564bde92017-09-13 13:16:28 -0400381 if (wrote < 0)
Nguyễn Thái Ngọc Duyd43e9072010-11-28 11:36:38 +0700382 return error("unable to write file %s", path);
Linus Torvalds12dccc12005-06-05 21:59:54 -0700383 break;
Jeff King7cbbf9d2017-10-09 13:50:05 -0400384
Martin Waitz302b9282007-05-21 22:08:28 +0200385 case S_IFGITLINK:
Linus Torvaldsf0807e62007-04-13 09:26:04 -0700386 if (to_tempfile)
Matheus Tavares9334ea82021-02-16 11:06:51 -0300387 return error("cannot create temporary submodule %s", ce->name);
Linus Torvaldsf0807e62007-04-13 09:26:04 -0700388 if (mkdir(path, 0777) < 0)
Thomas Rast42063f92013-07-18 14:26:55 +0200389 return error("cannot create submodule directory %s", path);
Stefan Beller6d14eac2017-03-14 14:46:40 -0700390 sub = submodule_from_ce(ce);
391 if (sub)
Ævar Arnfjörð Bjarmason4002ec32022-12-20 13:39:56 +0100392 return submodule_move_head(ce->name, state->super_prefix,
Stefan Bellercd279e22017-04-18 14:37:22 -0700393 NULL, oid_to_hex(&ce->oid),
394 state->force ? SUBMODULE_MOVE_HEAD_FORCE : 0);
Linus Torvaldsf0807e62007-04-13 09:26:04 -0700395 break;
Jeff King7cbbf9d2017-10-09 13:50:05 -0400396
Linus Torvalds12dccc12005-06-05 21:59:54 -0700397 default:
Matheus Tavares9334ea82021-02-16 11:06:51 -0300398 return error("unknown file mode for %s in index", ce->name);
Linus Torvalds12dccc12005-06-05 21:59:54 -0700399 }
400
Junio C Hamanodd8e9122011-05-12 14:31:08 -0700401finish:
Linus Torvalds6ee67f22005-06-05 23:15:40 -0700402 if (state->refresh_cache) {
Matheus Tavares584a0d12021-03-23 11:19:34 -0300403 if (!fstat_done && lstat(ce->name, &st) < 0)
404 return error_errno("unable to stat just-written file %s",
405 ce->name);
406 update_ce_after_write(state, ce , &st);
Linus Torvalds12dccc12005-06-05 21:59:54 -0700407 }
Matheus Tavares611c7782022-07-14 08:49:12 -0300408 if (nr_checkouts)
409 (*nr_checkouts)++;
Lars Schneider03b95332017-10-05 12:44:06 +0200410delayed:
Linus Torvalds12dccc12005-06-05 21:59:54 -0700411 return 0;
412}
413
Linus Torvaldsb6986d82009-07-29 20:22:25 -0700414/*
415 * This is like 'lstat()', except it refuses to follow symlinks
Junio C Hamanoda02ca52009-08-16 23:53:12 -0700416 * in the path, after skipping "skiplen".
Linus Torvaldsb6986d82009-07-29 20:22:25 -0700417 */
Junio C Hamano61b97df2010-01-11 22:27:31 -0800418static int check_path(const char *path, int len, struct stat *st, int skiplen)
Linus Torvaldsb6986d82009-07-29 20:22:25 -0700419{
Junio C Hamanoda02ca52009-08-16 23:53:12 -0700420 const char *slash = path + len;
421
422 while (path < slash && *slash != '/')
423 slash--;
424 if (!has_dirs_only_path(path, slash - path, skiplen)) {
Linus Torvaldsb6986d82009-07-29 20:22:25 -0700425 errno = ENOENT;
426 return -1;
427 }
428 return lstat(path, st);
429}
430
Duy Nguyenb8785792018-08-17 20:00:39 +0200431static void mark_colliding_entries(const struct checkout *state,
432 struct cache_entry *ce, struct stat *st)
433{
434 int i, trust_ino = check_stat;
435
Nguyễn Thái Ngọc Duye66ceca2018-11-20 17:28:53 +0100436#if defined(GIT_WINDOWS_NATIVE) || defined(__CYGWIN__)
Duy Nguyenb8785792018-08-17 20:00:39 +0200437 trust_ino = 0;
438#endif
439
440 ce->ce_flags |= CE_MATCHED;
441
Derrick Stolee3450a302021-04-01 01:49:55 +0000442 /* TODO: audit for interaction with sparse-index. */
443 ensure_full_index(state->istate);
Duy Nguyenb8785792018-08-17 20:00:39 +0200444 for (i = 0; i < state->istate->cache_nr; i++) {
445 struct cache_entry *dup = state->istate->cache[i];
446
Matheus Tavares04155bd2021-04-18 21:14:53 -0300447 if (dup == ce) {
448 /*
449 * Parallel checkout doesn't create the files in index
450 * order. So the other side of the collision may appear
451 * after the given cache_entry in the array.
452 */
453 if (parallel_checkout_status() == PC_RUNNING)
454 continue;
455 else
456 break;
457 }
Duy Nguyenb8785792018-08-17 20:00:39 +0200458
459 if (dup->ce_flags & (CE_MATCHED | CE_VALID | CE_SKIP_WORKTREE))
460 continue;
461
Nguyễn Thái Ngọc Duye66ceca2018-11-20 17:28:53 +0100462 if ((trust_ino && !match_stat_data(&dup->ce_stat_data, st)) ||
Duy Nguyenb8785792018-08-17 20:00:39 +0200463 (!trust_ino && !fspathcmp(ce->name, dup->name))) {
464 dup->ce_flags |= CE_MATCHED;
465 break;
466 }
467 }
468}
469
Matheus Tavaresae227512021-03-23 11:19:36 -0300470int checkout_entry_ca(struct cache_entry *ce, struct conv_attrs *ca,
471 const struct checkout *state, char *topath,
472 int *nr_checkouts)
Linus Torvalds12dccc12005-06-05 21:59:54 -0700473{
Michael Haggertyf63272a2014-03-13 10:19:07 +0100474 static struct strbuf path = STRBUF_INIT;
Shawn Pearcede84f992006-03-05 03:24:15 -0500475 struct stat st;
Matheus Tavaresae227512021-03-23 11:19:36 -0300476 struct conv_attrs ca_buf;
Linus Torvalds12dccc12005-06-05 21:59:54 -0700477
Thomas Gummerer536ec182018-12-20 13:48:15 +0000478 if (ce->ce_flags & CE_WT_REMOVE) {
479 if (topath)
480 /*
481 * No content and thus no path to create, so we have
482 * no pathname to return.
483 */
484 BUG("Can't remove entry to a path");
Ævar Arnfjörð Bjarmason4002ec32022-12-20 13:39:56 +0100485 unlink_entry(ce, state->super_prefix);
Thomas Gummerer536ec182018-12-20 13:48:15 +0000486 return 0;
487 }
488
Matheus Tavares30419e72021-03-23 11:19:35 -0300489 if (topath) {
Matheus Tavaresae227512021-03-23 11:19:36 -0300490 if (S_ISREG(ce->ce_mode) && !ca) {
Matheus Tavares30419e72021-03-23 11:19:35 -0300491 convert_attrs(state->istate, &ca_buf, ce->name);
492 ca = &ca_buf;
493 }
Matheus Tavares611c7782022-07-14 08:49:12 -0300494 return write_entry(ce, topath, ca, state, 1, nr_checkouts);
Matheus Tavares30419e72021-03-23 11:19:35 -0300495 }
Shawn Pearcede84f992006-03-05 03:24:15 -0500496
Michael Haggertyf63272a2014-03-13 10:19:07 +0100497 strbuf_reset(&path);
498 strbuf_add(&path, state->base_dir, state->base_dir_len);
499 strbuf_add(&path, ce->name, ce_namelen(ce));
Linus Torvalds12dccc12005-06-05 21:59:54 -0700500
Michael Haggertyf63272a2014-03-13 10:19:07 +0100501 if (!check_path(path.buf, path.len, &st, state->base_dir_len)) {
Stefan Beller6d14eac2017-03-14 14:46:40 -0700502 const struct submodule *sub;
Nguyễn Thái Ngọc Duy74cfc0e2018-08-13 18:14:32 +0200503 unsigned changed = ie_match_stat(state->istate, ce, &st,
504 CE_MATCH_IGNORE_VALID | CE_MATCH_IGNORE_SKIP_WORKTREE);
Stefan Beller6d14eac2017-03-14 14:46:40 -0700505 /*
506 * Needs to be checked before !changed returns early,
507 * as the possibly empty directory was not changed
508 */
509 sub = submodule_from_ce(ce);
510 if (sub) {
511 int err;
512 if (!is_submodule_populated_gently(ce->name, &err)) {
513 struct stat sb;
514 if (lstat(ce->name, &sb))
515 die(_("could not stat file '%s'"), ce->name);
516 if (!(st.st_mode & S_IFDIR))
517 unlink_or_warn(ce->name);
518
Ævar Arnfjörð Bjarmason4002ec32022-12-20 13:39:56 +0100519 return submodule_move_head(ce->name, state->super_prefix,
Stefan Bellercd279e22017-04-18 14:37:22 -0700520 NULL, oid_to_hex(&ce->oid), 0);
Stefan Beller6d14eac2017-03-14 14:46:40 -0700521 } else
Ævar Arnfjörð Bjarmason4002ec32022-12-20 13:39:56 +0100522 return submodule_move_head(ce->name, state->super_prefix,
Stefan Beller6d14eac2017-03-14 14:46:40 -0700523 "HEAD", oid_to_hex(&ce->oid),
Stefan Bellercd279e22017-04-18 14:37:22 -0700524 state->force ? SUBMODULE_MOVE_HEAD_FORCE : 0);
Stefan Beller6d14eac2017-03-14 14:46:40 -0700525 }
526
Linus Torvalds12dccc12005-06-05 21:59:54 -0700527 if (!changed)
528 return 0;
529 if (!state->force) {
530 if (!state->quiet)
Michael Haggertyf63272a2014-03-13 10:19:07 +0100531 fprintf(stderr,
532 "%s already exists, no checkout\n",
533 path.buf);
Junio C Hamano4b12dae2005-10-03 12:44:48 -0700534 return -1;
Linus Torvalds12dccc12005-06-05 21:59:54 -0700535 }
536
Duy Nguyenb8785792018-08-17 20:00:39 +0200537 if (state->clone)
538 mark_colliding_entries(state, ce, &st);
539
Linus Torvalds12dccc12005-06-05 21:59:54 -0700540 /*
541 * We unlink the old file, to get the new one with the
542 * right permissions (including umask, which is nasty
543 * to emulate by hand - much easier to let the system
544 * just do the right thing)
545 */
Linus Torvaldsd48a72f2005-07-14 09:58:45 -0700546 if (S_ISDIR(st.st_mode)) {
Linus Torvaldsf0807e62007-04-13 09:26:04 -0700547 /* If it is a gitlink, leave it alone! */
Linus Torvalds7a51ed62008-01-14 16:03:17 -0800548 if (S_ISGITLINK(ce->ce_mode))
Linus Torvaldsf0807e62007-04-13 09:26:04 -0700549 return 0;
Michael Haggerty2f29e0c2014-03-13 10:19:08 +0100550 remove_subtree(&path);
Michael Haggertyf63272a2014-03-13 10:19:07 +0100551 } else if (unlink(path.buf))
Nguyễn Thái Ngọc Duye1ebb3c2016-05-08 16:47:44 +0700552 return error_errno("unable to unlink old '%s'", path.buf);
Shawn Pearcede84f992006-03-05 03:24:15 -0500553 } else if (state->not_new)
Linus Torvalds12dccc12005-06-05 21:59:54 -0700554 return 0;
Michael Haggertyf63272a2014-03-13 10:19:07 +0100555
556 create_directories(path.buf, path.len, state);
Matheus Tavares30419e72021-03-23 11:19:35 -0300557
Matheus Tavaresae227512021-03-23 11:19:36 -0300558 if (S_ISREG(ce->ce_mode) && !ca) {
Matheus Tavares30419e72021-03-23 11:19:35 -0300559 convert_attrs(state->istate, &ca_buf, ce->name);
560 ca = &ca_buf;
561 }
562
Matheus Tavares611c7782022-07-14 08:49:12 -0300563 if (!enqueue_checkout(ce, ca, nr_checkouts))
Matheus Tavares04155bd2021-04-18 21:14:53 -0300564 return 0;
565
Matheus Tavares611c7782022-07-14 08:49:12 -0300566 return write_entry(ce, path.buf, ca, state, 0, nr_checkouts);
Linus Torvalds12dccc12005-06-05 21:59:54 -0700567}
Thomas Gummererb702dd12018-12-20 13:48:14 +0000568
Ævar Arnfjörð Bjarmason4002ec32022-12-20 13:39:56 +0100569void unlink_entry(const struct cache_entry *ce, const char *super_prefix)
Thomas Gummererb702dd12018-12-20 13:48:14 +0000570{
571 const struct submodule *sub = submodule_from_ce(ce);
572 if (sub) {
573 /* state.force is set at the caller. */
Ævar Arnfjörð Bjarmason4002ec32022-12-20 13:39:56 +0100574 submodule_move_head(ce->name, super_prefix, "HEAD", NULL,
Thomas Gummererb702dd12018-12-20 13:48:14 +0000575 SUBMODULE_MOVE_HEAD_FORCE);
576 }
Matheus Tavaresfab78a02021-03-18 15:43:47 -0300577 if (check_leading_path(ce->name, ce_namelen(ce), 1) >= 0)
Thomas Gummererb702dd12018-12-20 13:48:14 +0000578 return;
579 if (remove_or_warn(ce->ce_mode, ce->name))
580 return;
581 schedule_dir_for_removal(ce->name, ce_namelen(ce));
582}
Calvin Wanafd2a1d2023-09-29 14:20:49 -0700583
584int remove_or_warn(unsigned int mode, const char *file)
585{
586 return S_ISGITLINK(mode) ? rmdir_or_warn(file) : unlink_or_warn(file);
587}