]> git.ipfire.org Git - thirdparty/git.git/blame - entry.c
reftable: read reftable files
[thirdparty/git.git] / entry.c
CommitLineData
12dccc16 1#include "cache.h"
8e440259 2#include "blob.h"
cbd53a21 3#include "object-store.h"
8ca12c0d 4#include "dir.h"
dd8e9121 5#include "streaming.h"
6d14eac3 6#include "submodule.h"
52f1d62e 7#include "progress.h"
883e248b 8#include "fsmonitor.h"
d052cc03 9#include "entry.h"
04155bda 10#include "parallel-checkout.h"
12dccc16 11
81a9aa60
KB
12static void create_directories(const char *path, int path_len,
13 const struct checkout *state)
12dccc16 14{
3733e694 15 char *buf = xmallocz(path_len);
81a9aa60
KB
16 int len = 0;
17
18 while (len < path_len) {
19 do {
20 buf[len] = path[len];
21 len++;
22 } while (len < path_len && path[len] != '/');
23 if (len >= path_len)
24 break;
12dccc16 25 buf[len] = 0;
fa2e71c9 26
bad4a54f
KB
27 /*
28 * For 'checkout-index --prefix=<dir>', <dir> is
29 * allowed to be a symlink to an existing directory,
30 * and we set 'state->base_dir_len' below, such that
31 * we test the path components of the prefix with the
32 * stat() function instead of the lstat() function.
33 */
57199892 34 if (has_dirs_only_path(buf, len, state->base_dir_len))
fa2e71c9
JH
35 continue; /* ok, it is already a directory. */
36
37 /*
bad4a54f
KB
38 * If this mkdir() would fail, it could be that there
39 * is already a symlink or something else exists
40 * there, therefore we then try to unlink it and try
41 * one more time to create the directory.
fa2e71c9 42 */
f312de01 43 if (mkdir(buf, 0777)) {
fa2e71c9 44 if (errno == EEXIST && state->force &&
691f1a28 45 !unlink_or_warn(buf) && !mkdir(buf, 0777))
fa2e71c9 46 continue;
0721c314 47 die_errno("cannot create directory at '%s'", buf);
12dccc16
LT
48 }
49 }
50 free(buf);
51}
52
2f29e0c6 53static void remove_subtree(struct strbuf *path)
12dccc16 54{
2f29e0c6 55 DIR *dir = opendir(path->buf);
12dccc16 56 struct dirent *de;
2f29e0c6 57 int origlen = path->len;
a6080a0a 58
12dccc16 59 if (!dir)
2f29e0c6 60 die_errno("cannot opendir '%s'", path->buf);
b548f0f1 61 while ((de = readdir_skip_dot_and_dotdot(dir)) != NULL) {
12dccc16 62 struct stat st;
2f29e0c6 63
2f29e0c6
MH
64 strbuf_addch(path, '/');
65 strbuf_addstr(path, de->d_name);
66 if (lstat(path->buf, &st))
67 die_errno("cannot lstat '%s'", path->buf);
12dccc16 68 if (S_ISDIR(st.st_mode))
2f29e0c6
MH
69 remove_subtree(path);
70 else if (unlink(path->buf))
71 die_errno("cannot unlink '%s'", path->buf);
72 strbuf_setlen(path, origlen);
12dccc16
LT
73 }
74 closedir(dir);
2f29e0c6
MH
75 if (rmdir(path->buf))
76 die_errno("cannot rmdir '%s'", path->buf);
12dccc16
LT
77}
78
d48a72f3 79static int create_file(const char *path, unsigned int mode)
12dccc16 80{
12dccc16 81 mode = (mode & 0100) ? 0777 : 0666;
781411ed 82 return open(path, O_WRONLY | O_CREAT | O_EXCL, mode);
12dccc16
LT
83}
84
49cfd903 85void *read_blob_entry(const struct cache_entry *ce, unsigned long *size)
f0807e62
LT
86{
87 enum object_type type;
b4f5aca4 88 void *blob_data = read_object_file(&ce->oid, &type, size);
f0807e62 89
d8f71807 90 if (blob_data) {
f0807e62 91 if (type == OBJ_BLOB)
d8f71807
BW
92 return blob_data;
93 free(blob_data);
f0807e62
LT
94 }
95 return NULL;
96}
97
9c5e6c80 98static int open_output_fd(char *path, const struct cache_entry *ce, int to_tempfile)
fd5db55d
JH
99{
100 int symlink = (ce->ce_mode & S_IFMT) != S_IFREG;
101 if (to_tempfile) {
330c8e26
JK
102 xsnprintf(path, TEMPORARY_FILENAME_LENGTH, "%s",
103 symlink ? ".merge_link_XXXXXX" : ".merge_file_XXXXXX");
fd5db55d
JH
104 return mkstemp(path);
105 } else {
106 return create_file(path, !symlink ? ce->ce_mode : 0666);
107 }
108}
109
49cfd903 110int fstat_checkout_output(int fd, const struct checkout *state, struct stat *st)
fd5db55d
JH
111{
112 /* use fstat() only when path == ce->name */
113 if (fstat_is_reliable() &&
114 state->refresh_cache && !state->base_dir_len) {
35e6e212 115 return !fstat(fd, st);
fd5db55d
JH
116 }
117 return 0;
118}
119
9c5e6c80 120static int streaming_write_entry(const struct cache_entry *ce, char *path,
b6691092 121 struct stream_filter *filter,
dd8e9121
JH
122 const struct checkout *state, int to_tempfile,
123 int *fstat_done, struct stat *statbuf)
124{
d9c31e14 125 int result = 0;
47a02ff2 126 int fd;
dd8e9121
JH
127
128 fd = open_output_fd(path, ce, to_tempfile);
d9c31e14
JK
129 if (fd < 0)
130 return -1;
131
7eda0e4f 132 result |= stream_blob_to_fd(fd, &ce->oid, filter, 1);
49cfd903 133 *fstat_done = fstat_checkout_output(fd, state, statbuf);
d9c31e14
JK
134 result |= close(fd);
135
136 if (result)
dd8e9121
JH
137 unlink(path);
138 return result;
139}
140
2841e8f8
LS
141void enable_delayed_checkout(struct checkout *state)
142{
143 if (!state->delayed_checkout) {
144 state->delayed_checkout = xmalloc(sizeof(*state->delayed_checkout));
145 state->delayed_checkout->state = CE_CAN_DELAY;
bc40dfb1
ÆAB
146 string_list_init_nodup(&state->delayed_checkout->filters);
147 string_list_init_nodup(&state->delayed_checkout->paths);
2841e8f8
LS
148 }
149}
150
151static int remove_available_paths(struct string_list_item *item, void *cb_data)
152{
153 struct string_list *available_paths = cb_data;
154 struct string_list_item *available;
155
156 available = string_list_lookup(available_paths, item->string);
157 if (available)
158 available->util = (void *)item->string;
159 return !available;
160}
161
0f086e6d 162int finish_delayed_checkout(struct checkout *state, int *nr_checkouts)
2841e8f8
LS
163{
164 int errs = 0;
52f1d62e
LS
165 unsigned delayed_object_count;
166 off_t filtered_bytes = 0;
2841e8f8 167 struct string_list_item *filter, *path;
52f1d62e 168 struct progress *progress;
2841e8f8
LS
169 struct delayed_checkout *dco = state->delayed_checkout;
170
171 if (!state->delayed_checkout)
172 return errs;
173
174 dco->state = CE_RETRY;
52f1d62e 175 delayed_object_count = dco->paths.nr;
7fbbd3ec 176 progress = start_delayed_progress(_("Filtering content"), delayed_object_count);
2841e8f8
LS
177 while (dco->filters.nr > 0) {
178 for_each_string_list_item(filter, &dco->filters) {
179 struct string_list available_paths = STRING_LIST_INIT_NODUP;
52f1d62e 180 display_progress(progress, delayed_object_count - dco->paths.nr);
2841e8f8
LS
181
182 if (!async_query_available_blobs(filter->string, &available_paths)) {
183 /* Filter reported an error */
184 errs = 1;
185 filter->string = "";
186 continue;
187 }
188 if (available_paths.nr <= 0) {
189 /*
190 * Filter responded with no entries. That means
191 * the filter is done and we can remove the
192 * filter from the list (see
193 * "string_list_remove_empty_items" call below).
194 */
195 filter->string = "";
196 continue;
197 }
198
199 /*
200 * In dco->paths we store a list of all delayed paths.
201 * The filter just send us a list of available paths.
202 * Remove them from the list.
203 */
204 filter_string_list(&dco->paths, 0,
205 &remove_available_paths, &available_paths);
206
207 for_each_string_list_item(path, &available_paths) {
208 struct cache_entry* ce;
209
210 if (!path->util) {
211 error("external filter '%s' signaled that '%s' "
212 "is now available although it has not been "
213 "delayed earlier",
214 filter->string, path->string);
215 errs |= 1;
216
217 /*
218 * Do not ask the filter for available blobs,
219 * again, as the filter is likely buggy.
220 */
221 filter->string = "";
222 continue;
223 }
224 ce = index_file_exists(state->istate, path->string,
225 strlen(path->string), 0);
52f1d62e 226 if (ce) {
0f086e6d 227 errs |= checkout_entry(ce, state, NULL, nr_checkouts);
52f1d62e
LS
228 filtered_bytes += ce->ce_stat_data.sd_size;
229 display_throughput(progress, filtered_bytes);
230 } else
231 errs = 1;
2841e8f8
LS
232 }
233 }
234 string_list_remove_empty_items(&dco->filters, 0);
235 }
52f1d62e 236 stop_progress(&progress);
2841e8f8
LS
237 string_list_clear(&dco->filters, 0);
238
239 /* At this point we should not have any delayed paths anymore. */
240 errs |= dco->paths.nr;
241 for_each_string_list_item(path, &dco->paths) {
242 error("'%s' was not filtered properly", path->string);
243 }
244 string_list_clear(&dco->paths, 0);
245
246 free(dco);
247 state->delayed_checkout = NULL;
248
249 return errs;
250}
251
584a0d13
MT
252void update_ce_after_write(const struct checkout *state, struct cache_entry *ce,
253 struct stat *st)
254{
255 if (state->refresh_cache) {
256 assert(state->istate);
257 fill_stat_cache_info(state->istate, ce, st);
258 ce->ce_flags |= CE_UPDATE_IN_BASE;
259 mark_fsmonitor_invalid(state->istate, ce);
260 state->istate->cache_changed |= CE_ENTRY_CHANGED;
261 }
262}
263
30419e7e
MT
264/* Note: ca is used (and required) iff the entry refers to a regular file. */
265static int write_entry(struct cache_entry *ce, char *path, struct conv_attrs *ca,
266 const struct checkout *state, int to_tempfile)
12dccc16 267{
4857c761 268 unsigned int ce_mode_s_ifmt = ce->ce_mode & S_IFMT;
c602d3a9 269 struct delayed_checkout *dco = state->delayed_checkout;
e4c72923 270 int fd, ret, fstat_done = 0;
d8f71807 271 char *new_blob;
4857c761
KB
272 struct strbuf buf = STRBUF_INIT;
273 unsigned long size;
564bde9a
JK
274 ssize_t wrote;
275 size_t newsize = 0;
e4c72923 276 struct stat st;
6d14eac3 277 const struct submodule *sub;
c397aac0 278 struct checkout_metadata meta;
279
280 clone_checkout_metadata(&meta, &state->meta, &ce->oid);
4857c761 281
b6691092 282 if (ce_mode_s_ifmt == S_IFREG) {
30419e7e 283 struct stream_filter *filter = get_stream_filter_ca(ca, &ce->oid);
b6691092
JH
284 if (filter &&
285 !streaming_write_entry(ce, path, filter,
286 state, to_tempfile,
287 &fstat_done, &st))
288 goto finish;
289 }
dd8e9121 290
4857c761 291 switch (ce_mode_s_ifmt) {
4857c761 292 case S_IFLNK:
d8f71807
BW
293 new_blob = read_blob_entry(ce, &size);
294 if (!new_blob)
d43e9073 295 return error("unable to read sha1 file of %s (%s)",
9334ea8e 296 ce->name, oid_to_hex(&ce->oid));
1a9d7e9b 297
7cbbf9d6
JK
298 /*
299 * We can't make a real symlink; write out a regular file entry
300 * with the symlink destination as its contents.
301 */
302 if (!has_symlinks || to_tempfile)
303 goto write_file_entry;
304
d8f71807
BW
305 ret = symlink(new_blob, path);
306 free(new_blob);
7cbbf9d6
JK
307 if (ret)
308 return error_errno("unable to create symlink %s", path);
309 break;
310
311 case S_IFREG:
c602d3a9
JK
312 /*
313 * We do not send the blob in case of a retry, so do not
314 * bother reading it at all.
315 */
7cbbf9d6 316 if (dco && dco->state == CE_RETRY) {
d8f71807 317 new_blob = NULL;
c602d3a9
JK
318 size = 0;
319 } else {
d8f71807
BW
320 new_blob = read_blob_entry(ce, &size);
321 if (!new_blob)
c602d3a9 322 return error("unable to read sha1 file of %s (%s)",
9334ea8e 323 ce->name, oid_to_hex(&ce->oid));
4857c761
KB
324 }
325
1a9d7e9b
JH
326 /*
327 * Convert from git internal format to working tree format
328 */
7cbbf9d6 329 if (dco && dco->state != CE_NO_DELAY) {
30419e7e
MT
330 ret = async_convert_to_working_tree_ca(ca, ce->name,
331 new_blob, size,
332 &buf, &meta, dco);
7cbbf9d6 333 if (ret && string_list_has_string(&dco->paths, ce->name)) {
d8f71807 334 free(new_blob);
7cbbf9d6 335 goto delayed;
2841e8f8 336 }
30419e7e
MT
337 } else {
338 ret = convert_to_working_tree_ca(ca, ce->name, new_blob,
339 size, &buf, &meta);
340 }
7cbbf9d6
JK
341
342 if (ret) {
d8f71807
BW
343 free(new_blob);
344 new_blob = strbuf_detach(&buf, &newsize);
7cbbf9d6 345 size = newsize;
1a9d7e9b 346 }
7cbbf9d6
JK
347 /*
348 * No "else" here as errors from convert are OK at this
349 * point. If the error would have been fatal (e.g.
350 * filter is required), then we would have died already.
351 */
1a9d7e9b 352
7cbbf9d6 353 write_file_entry:
fd5db55d 354 fd = open_output_fd(path, ce, to_tempfile);
12dccc16 355 if (fd < 0) {
d8f71807 356 free(new_blob);
e1ebb3c2 357 return error_errno("unable to create file %s", path);
12dccc16 358 }
6c510bee 359
d8f71807 360 wrote = write_in_full(fd, new_blob, size);
fd5db55d 361 if (!to_tempfile)
49cfd903 362 fstat_done = fstat_checkout_output(fd, state, &st);
12dccc16 363 close(fd);
d8f71807 364 free(new_blob);
564bde9a 365 if (wrote < 0)
d43e9073 366 return error("unable to write file %s", path);
12dccc16 367 break;
7cbbf9d6 368
302b9282 369 case S_IFGITLINK:
f0807e62 370 if (to_tempfile)
9334ea8e 371 return error("cannot create temporary submodule %s", ce->name);
f0807e62 372 if (mkdir(path, 0777) < 0)
42063f95 373 return error("cannot create submodule directory %s", path);
6d14eac3
SB
374 sub = submodule_from_ce(ce);
375 if (sub)
376 return submodule_move_head(ce->name,
cd279e2e
SB
377 NULL, oid_to_hex(&ce->oid),
378 state->force ? SUBMODULE_MOVE_HEAD_FORCE : 0);
f0807e62 379 break;
7cbbf9d6 380
12dccc16 381 default:
9334ea8e 382 return error("unknown file mode for %s in index", ce->name);
12dccc16
LT
383 }
384
dd8e9121 385finish:
6ee67f26 386 if (state->refresh_cache) {
584a0d13
MT
387 if (!fstat_done && lstat(ce->name, &st) < 0)
388 return error_errno("unable to stat just-written file %s",
389 ce->name);
390 update_ce_after_write(state, ce , &st);
12dccc16 391 }
03b95333 392delayed:
12dccc16
LT
393 return 0;
394}
395
b6986d8a
LT
396/*
397 * This is like 'lstat()', except it refuses to follow symlinks
da02ca50 398 * in the path, after skipping "skiplen".
b6986d8a 399 */
61b97df7 400static int check_path(const char *path, int len, struct stat *st, int skiplen)
b6986d8a 401{
da02ca50
JH
402 const char *slash = path + len;
403
404 while (path < slash && *slash != '/')
405 slash--;
406 if (!has_dirs_only_path(path, slash - path, skiplen)) {
b6986d8a
LT
407 errno = ENOENT;
408 return -1;
409 }
410 return lstat(path, st);
411}
412
b878579a
NTND
413static void mark_colliding_entries(const struct checkout *state,
414 struct cache_entry *ce, struct stat *st)
415{
416 int i, trust_ino = check_stat;
417
e66ceca9 418#if defined(GIT_WINDOWS_NATIVE) || defined(__CYGWIN__)
b878579a
NTND
419 trust_ino = 0;
420#endif
421
422 ce->ce_flags |= CE_MATCHED;
423
3450a304
DS
424 /* TODO: audit for interaction with sparse-index. */
425 ensure_full_index(state->istate);
b878579a
NTND
426 for (i = 0; i < state->istate->cache_nr; i++) {
427 struct cache_entry *dup = state->istate->cache[i];
428
04155bda
MT
429 if (dup == ce) {
430 /*
431 * Parallel checkout doesn't create the files in index
432 * order. So the other side of the collision may appear
433 * after the given cache_entry in the array.
434 */
435 if (parallel_checkout_status() == PC_RUNNING)
436 continue;
437 else
438 break;
439 }
b878579a
NTND
440
441 if (dup->ce_flags & (CE_MATCHED | CE_VALID | CE_SKIP_WORKTREE))
442 continue;
443
e66ceca9 444 if ((trust_ino && !match_stat_data(&dup->ce_stat_data, st)) ||
b878579a
NTND
445 (!trust_ino && !fspathcmp(ce->name, dup->name))) {
446 dup->ce_flags |= CE_MATCHED;
447 break;
448 }
449 }
450}
451
ae22751f
MT
452int checkout_entry_ca(struct cache_entry *ce, struct conv_attrs *ca,
453 const struct checkout *state, char *topath,
454 int *nr_checkouts)
12dccc16 455{
f63272a3 456 static struct strbuf path = STRBUF_INIT;
de84f99c 457 struct stat st;
ae22751f 458 struct conv_attrs ca_buf;
12dccc16 459
536ec183
TG
460 if (ce->ce_flags & CE_WT_REMOVE) {
461 if (topath)
462 /*
463 * No content and thus no path to create, so we have
464 * no pathname to return.
465 */
466 BUG("Can't remove entry to a path");
467 unlink_entry(ce);
468 return 0;
469 }
470
30419e7e 471 if (topath) {
ae22751f 472 if (S_ISREG(ce->ce_mode) && !ca) {
30419e7e
MT
473 convert_attrs(state->istate, &ca_buf, ce->name);
474 ca = &ca_buf;
475 }
476 return write_entry(ce, topath, ca, state, 1);
477 }
de84f99c 478
f63272a3
MH
479 strbuf_reset(&path);
480 strbuf_add(&path, state->base_dir, state->base_dir_len);
481 strbuf_add(&path, ce->name, ce_namelen(ce));
12dccc16 482
f63272a3 483 if (!check_path(path.buf, path.len, &st, state->base_dir_len)) {
6d14eac3 484 const struct submodule *sub;
74cfc0ee
NTND
485 unsigned changed = ie_match_stat(state->istate, ce, &st,
486 CE_MATCH_IGNORE_VALID | CE_MATCH_IGNORE_SKIP_WORKTREE);
6d14eac3
SB
487 /*
488 * Needs to be checked before !changed returns early,
489 * as the possibly empty directory was not changed
490 */
491 sub = submodule_from_ce(ce);
492 if (sub) {
493 int err;
494 if (!is_submodule_populated_gently(ce->name, &err)) {
495 struct stat sb;
496 if (lstat(ce->name, &sb))
497 die(_("could not stat file '%s'"), ce->name);
498 if (!(st.st_mode & S_IFDIR))
499 unlink_or_warn(ce->name);
500
501 return submodule_move_head(ce->name,
cd279e2e 502 NULL, oid_to_hex(&ce->oid), 0);
6d14eac3
SB
503 } else
504 return submodule_move_head(ce->name,
505 "HEAD", oid_to_hex(&ce->oid),
cd279e2e 506 state->force ? SUBMODULE_MOVE_HEAD_FORCE : 0);
6d14eac3
SB
507 }
508
12dccc16
LT
509 if (!changed)
510 return 0;
511 if (!state->force) {
512 if (!state->quiet)
f63272a3
MH
513 fprintf(stderr,
514 "%s already exists, no checkout\n",
515 path.buf);
4b12dae6 516 return -1;
12dccc16
LT
517 }
518
b878579a
NTND
519 if (state->clone)
520 mark_colliding_entries(state, ce, &st);
521
12dccc16
LT
522 /*
523 * We unlink the old file, to get the new one with the
524 * right permissions (including umask, which is nasty
525 * to emulate by hand - much easier to let the system
526 * just do the right thing)
527 */
d48a72f3 528 if (S_ISDIR(st.st_mode)) {
f0807e62 529 /* If it is a gitlink, leave it alone! */
7a51ed66 530 if (S_ISGITLINK(ce->ce_mode))
f0807e62 531 return 0;
2f29e0c6 532 remove_subtree(&path);
f63272a3 533 } else if (unlink(path.buf))
e1ebb3c2 534 return error_errno("unable to unlink old '%s'", path.buf);
de84f99c 535 } else if (state->not_new)
12dccc16 536 return 0;
f63272a3
MH
537
538 create_directories(path.buf, path.len, state);
30419e7e 539
0f086e6d
NTND
540 if (nr_checkouts)
541 (*nr_checkouts)++;
30419e7e 542
ae22751f 543 if (S_ISREG(ce->ce_mode) && !ca) {
30419e7e
MT
544 convert_attrs(state->istate, &ca_buf, ce->name);
545 ca = &ca_buf;
546 }
547
04155bda
MT
548 if (!enqueue_checkout(ce, ca))
549 return 0;
550
30419e7e 551 return write_entry(ce, path.buf, ca, state, 0);
12dccc16 552}
b702dd12
TG
553
554void unlink_entry(const struct cache_entry *ce)
555{
556 const struct submodule *sub = submodule_from_ce(ce);
557 if (sub) {
558 /* state.force is set at the caller. */
559 submodule_move_head(ce->name, "HEAD", NULL,
560 SUBMODULE_MOVE_HEAD_FORCE);
561 }
fab78a0c 562 if (check_leading_path(ce->name, ce_namelen(ce), 1) >= 0)
b702dd12
TG
563 return;
564 if (remove_or_warn(ce->ce_mode, ce->name))
565 return;
566 schedule_dir_for_removal(ce->name, ce_namelen(ce));
567}