1/* 2 * This handles recursive filename detection with exclude 3 * files, index knowledge etc.. 4 * 5 * See Documentation/technical/api-directory-listing.txt 6 * 7 * Copyright (C) Linus Torvalds, 2005-2006 8 * Junio Hamano, 2005-2006 9 */ 10#define NO_THE_INDEX_COMPATIBILITY_MACROS 11#include "cache.h" 12#include "config.h" 13#include "dir.h" 14#include "attr.h" 15#include "refs.h" 16#include "wildmatch.h" 17#include "pathspec.h" 18#include "utf8.h" 19#include "varint.h" 20#include "ewah/ewok.h" 21#include "fsmonitor.h" 22 23/* 24 * Tells read_directory_recursive how a file or directory should be treated. 25 * Values are ordered by significance, e.g. if a directory contains both 26 * excluded and untracked files, it is listed as untracked because 27 * path_untracked > path_excluded. 28 */ 29enum path_treatment { 30 path_none = 0, 31 path_recurse, 32 path_excluded, 33 path_untracked 34}; 35 36/* 37 * Support data structure for our opendir/readdir/closedir wrappers 38 */ 39struct cached_dir { 40 DIR *fdir; 41 struct untracked_cache_dir *untracked; 42 int nr_files; 43 int nr_dirs; 44 45 struct dirent *de; 46 const char *file; 47 struct untracked_cache_dir *ucd; 48}; 49 50static enum path_treatment read_directory_recursive(struct dir_struct *dir, 51 struct index_state *istate, const char *path, int len, 52 struct untracked_cache_dir *untracked, 53 int check_only, int stop_at_first_file, const struct pathspec *pathspec); 54static int get_dtype(struct dirent *de, struct index_state *istate, 55 const char *path, int len); 56 57int count_slashes(const char *s) 58{ 59 int cnt = 0; 60 while (*s) 61 if (*s++ == '/') 62 cnt++; 63 return cnt; 64} 65 66int fspathcmp(const char *a, const char *b) 67{ 68 return ignore_case ? strcasecmp(a, b) : strcmp(a, b); 69} 70 71int fspathncmp(const char *a, const char *b, size_t count) 72{ 73 return ignore_case ? strncasecmp(a, b, count) : strncmp(a, b, count); 74} 75 76int git_fnmatch(const struct pathspec_item *item, 77 const char *pattern, const char *string, 78 int prefix) 79{ 80 if (prefix > 0) { 81 if (ps_strncmp(item, pattern, string, prefix)) 82 return WM_NOMATCH; 83 pattern += prefix; 84 string += prefix; 85 } 86 if (item->flags & PATHSPEC_ONESTAR) { 87 int pattern_len = strlen(++pattern); 88 int string_len = strlen(string); 89 return string_len < pattern_len || 90 ps_strcmp(item, pattern, 91 string + string_len - pattern_len); 92 } 93 if (item->magic & PATHSPEC_GLOB) 94 return wildmatch(pattern, string, 95 WM_PATHNAME | 96 (item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0)); 97 else 98 /* wildmatch has not learned no FNM_PATHNAME mode yet */ 99 return wildmatch(pattern, string, 100 item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0); 101} 102 103static int fnmatch_icase_mem(const char *pattern, int patternlen, 104 const char *string, int stringlen, 105 int flags) 106{ 107 int match_status; 108 struct strbuf pat_buf = STRBUF_INIT; 109 struct strbuf str_buf = STRBUF_INIT; 110 const char *use_pat = pattern; 111 const char *use_str = string; 112 113 if (pattern[patternlen]) { 114 strbuf_add(&pat_buf, pattern, patternlen); 115 use_pat = pat_buf.buf; 116 } 117 if (string[stringlen]) { 118 strbuf_add(&str_buf, string, stringlen); 119 use_str = str_buf.buf; 120 } 121 122 if (ignore_case) 123 flags |= WM_CASEFOLD; 124 match_status = wildmatch(use_pat, use_str, flags); 125 126 strbuf_release(&pat_buf); 127 strbuf_release(&str_buf); 128 129 return match_status; 130} 131 132static size_t common_prefix_len(const struct pathspec *pathspec) 133{ 134 int n; 135 size_t max = 0; 136 137 /* 138 * ":(icase)path" is treated as a pathspec full of 139 * wildcard. In other words, only prefix is considered common 140 * prefix. If the pathspec is abc/foo abc/bar, running in 141 * subdir xyz, the common prefix is still xyz, not xuz/abc as 142 * in non-:(icase). 143 */ 144 GUARD_PATHSPEC(pathspec, 145 PATHSPEC_FROMTOP | 146 PATHSPEC_MAXDEPTH | 147 PATHSPEC_LITERAL | 148 PATHSPEC_GLOB | 149 PATHSPEC_ICASE | 150 PATHSPEC_EXCLUDE | 151 PATHSPEC_ATTR); 152 153 for (n = 0; n < pathspec->nr; n++) { 154 size_t i = 0, len = 0, item_len; 155 if (pathspec->items[n].magic & PATHSPEC_EXCLUDE) 156 continue; 157 if (pathspec->items[n].magic & PATHSPEC_ICASE) 158 item_len = pathspec->items[n].prefix; 159 else 160 item_len = pathspec->items[n].nowildcard_len; 161 while (i < item_len && (n == 0 || i < max)) { 162 char c = pathspec->items[n].match[i]; 163 if (c != pathspec->items[0].match[i]) 164 break; 165 if (c == '/') 166 len = i + 1; 167 i++; 168 } 169 if (n == 0 || len < max) { 170 max = len; 171 if (!max) 172 break; 173 } 174 } 175 return max; 176} 177 178/* 179 * Returns a copy of the longest leading path common among all 180 * pathspecs. 181 */ 182char *common_prefix(const struct pathspec *pathspec) 183{ 184 unsigned long len = common_prefix_len(pathspec); 185 186 return len ? xmemdupz(pathspec->items[0].match, len) : NULL; 187} 188 189int fill_directory(struct dir_struct *dir, 190 struct index_state *istate, 191 const struct pathspec *pathspec) 192{ 193 const char *prefix; 194 size_t prefix_len; 195 196 /* 197 * Calculate common prefix for the pathspec, and 198 * use that to optimize the directory walk 199 */ 200 prefix_len = common_prefix_len(pathspec); 201 prefix = prefix_len ? pathspec->items[0].match : ""; 202 203 /* Read the directory and prune it */ 204 read_directory(dir, istate, prefix, prefix_len, pathspec); 205 206 return prefix_len; 207} 208 209int within_depth(const char *name, int namelen, 210 int depth, int max_depth) 211{ 212 const char *cp = name, *cpe = name + namelen; 213 214 while (cp < cpe) { 215 if (*cp++ != '/') 216 continue; 217 depth++; 218 if (depth > max_depth) 219 return 0; 220 } 221 return 1; 222} 223 224/* 225 * Read the contents of the blob with the given OID into a buffer. 226 * Append a trailing LF to the end if the last line doesn't have one. 227 * 228 * Returns: 229 * -1 when the OID is invalid or unknown or does not refer to a blob. 230 * 0 when the blob is empty. 231 * 1 along with { data, size } of the (possibly augmented) buffer 232 * when successful. 233 * 234 * Optionally updates the given oid_stat with the given OID (when valid). 235 */ 236static int do_read_blob(const struct object_id *oid, struct oid_stat *oid_stat, 237 size_t *size_out, char **data_out) 238{ 239 enum object_type type; 240 unsigned long sz; 241 char *data; 242 243 *size_out = 0; 244 *data_out = NULL; 245 246 data = read_sha1_file(oid->hash, &type, &sz); 247 if (!data || type != OBJ_BLOB) { 248 free(data); 249 return -1; 250 } 251 252 if (oid_stat) { 253 memset(&oid_stat->stat, 0, sizeof(oid_stat->stat)); 254 oidcpy(&oid_stat->oid, oid); 255 } 256 257 if (sz == 0) { 258 free(data); 259 return 0; 260 } 261 262 if (data[sz - 1] != '\n') { 263 data = xrealloc(data, st_add(sz, 1)); 264 data[sz++] = '\n'; 265 } 266 267 *size_out = xsize_t(sz); 268 *data_out = data; 269 270 return 1; 271} 272 273#define DO_MATCH_EXCLUDE (1<<0) 274#define DO_MATCH_DIRECTORY (1<<1) 275#define DO_MATCH_SUBMODULE (1<<2) 276 277static int match_attrs(const char *name, int namelen, 278 const struct pathspec_item *item) 279{ 280 int i; 281 282 git_check_attr(name, item->attr_check); 283 for (i = 0; i < item->attr_match_nr; i++) { 284 const char *value; 285 int matched; 286 enum attr_match_mode match_mode; 287 288 value = item->attr_check->items[i].value; 289 match_mode = item->attr_match[i].match_mode; 290 291 if (ATTR_TRUE(value)) 292 matched = (match_mode == MATCH_SET); 293 else if (ATTR_FALSE(value)) 294 matched = (match_mode == MATCH_UNSET); 295 else if (ATTR_UNSET(value)) 296 matched = (match_mode == MATCH_UNSPECIFIED); 297 else 298 matched = (match_mode == MATCH_VALUE && 299 !strcmp(item->attr_match[i].value, value)); 300 if (!matched) 301 return 0; 302 } 303 304 return 1; 305} 306 307/* 308 * Does 'match' match the given name? 309 * A match is found if 310 * 311 * (1) the 'match' string is leading directory of 'name', or 312 * (2) the 'match' string is a wildcard and matches 'name', or 313 * (3) the 'match' string is exactly the same as 'name'. 314 * 315 * and the return value tells which case it was. 316 * 317 * It returns 0 when there is no match. 318 */ 319static int match_pathspec_item(const struct pathspec_item *item, int prefix, 320 const char *name, int namelen, unsigned flags) 321{ 322 /* name/namelen has prefix cut off by caller */ 323 const char *match = item->match + prefix; 324 int matchlen = item->len - prefix; 325 326 /* 327 * The normal call pattern is: 328 * 1. prefix = common_prefix_len(ps); 329 * 2. prune something, or fill_directory 330 * 3. match_pathspec() 331 * 332 * 'prefix' at #1 may be shorter than the command's prefix and 333 * it's ok for #2 to match extra files. Those extras will be 334 * trimmed at #3. 335 * 336 * Suppose the pathspec is 'foo' and '../bar' running from 337 * subdir 'xyz'. The common prefix at #1 will be empty, thanks 338 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The 339 * user does not want XYZ/foo, only the "foo" part should be 340 * case-insensitive. We need to filter out XYZ/foo here. In 341 * other words, we do not trust the caller on comparing the 342 * prefix part when :(icase) is involved. We do exact 343 * comparison ourselves. 344 * 345 * Normally the caller (common_prefix_len() in fact) does 346 * _exact_ matching on name[-prefix+1..-1] and we do not need 347 * to check that part. Be defensive and check it anyway, in 348 * case common_prefix_len is changed, or a new caller is 349 * introduced that does not use common_prefix_len. 350 * 351 * If the penalty turns out too high when prefix is really 352 * long, maybe change it to 353 * strncmp(match, name, item->prefix - prefix) 354 */ 355 if (item->prefix && (item->magic & PATHSPEC_ICASE) && 356 strncmp(item->match, name - prefix, item->prefix)) 357 return 0; 358 359 if (item->attr_match_nr && !match_attrs(name, namelen, item)) 360 return 0; 361 362 /* If the match was just the prefix, we matched */ 363 if (!*match) 364 return MATCHED_RECURSIVELY; 365 366 if (matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) { 367 if (matchlen == namelen) 368 return MATCHED_EXACTLY; 369 370 if (match[matchlen-1] == '/' || name[matchlen] == '/') 371 return MATCHED_RECURSIVELY; 372 } else if ((flags & DO_MATCH_DIRECTORY) && 373 match[matchlen - 1] == '/' && 374 namelen == matchlen - 1 && 375 !ps_strncmp(item, match, name, namelen)) 376 return MATCHED_EXACTLY; 377 378 if (item->nowildcard_len < item->len && 379 !git_fnmatch(item, match, name, 380 item->nowildcard_len - prefix)) 381 return MATCHED_FNMATCH; 382 383 /* Perform checks to see if "name" is a super set of the pathspec */ 384 if (flags & DO_MATCH_SUBMODULE) { 385 /* name is a literal prefix of the pathspec */ 386 if ((namelen < matchlen) && 387 (match[namelen] == '/') && 388 !ps_strncmp(item, match, name, namelen)) 389 return MATCHED_RECURSIVELY; 390 391 /* name" doesn't match up to the first wild character */ 392 if (item->nowildcard_len < item->len && 393 ps_strncmp(item, match, name, 394 item->nowildcard_len - prefix)) 395 return 0; 396 397 /* 398 * Here is where we would perform a wildmatch to check if 399 * "name" can be matched as a directory (or a prefix) against 400 * the pathspec. Since wildmatch doesn't have this capability 401 * at the present we have to punt and say that it is a match, 402 * potentially returning a false positive 403 * The submodules themselves will be able to perform more 404 * accurate matching to determine if the pathspec matches. 405 */ 406 return MATCHED_RECURSIVELY; 407 } 408 409 return 0; 410} 411 412/* 413 * Given a name and a list of pathspecs, returns the nature of the 414 * closest (i.e. most specific) match of the name to any of the 415 * pathspecs. 416 * 417 * The caller typically calls this multiple times with the same 418 * pathspec and seen[] array but with different name/namelen 419 * (e.g. entries from the index) and is interested in seeing if and 420 * how each pathspec matches all the names it calls this function 421 * with. A mark is left in the seen[] array for each pathspec element 422 * indicating the closest type of match that element achieved, so if 423 * seen[n] remains zero after multiple invocations, that means the nth 424 * pathspec did not match any names, which could indicate that the 425 * user mistyped the nth pathspec. 426 */ 427static int do_match_pathspec(const struct pathspec *ps, 428 const char *name, int namelen, 429 int prefix, char *seen, 430 unsigned flags) 431{ 432 int i, retval = 0, exclude = flags & DO_MATCH_EXCLUDE; 433 434 GUARD_PATHSPEC(ps, 435 PATHSPEC_FROMTOP | 436 PATHSPEC_MAXDEPTH | 437 PATHSPEC_LITERAL | 438 PATHSPEC_GLOB | 439 PATHSPEC_ICASE | 440 PATHSPEC_EXCLUDE | 441 PATHSPEC_ATTR); 442 443 if (!ps->nr) { 444 if (!ps->recursive || 445 !(ps->magic & PATHSPEC_MAXDEPTH) || 446 ps->max_depth == -1) 447 return MATCHED_RECURSIVELY; 448 449 if (within_depth(name, namelen, 0, ps->max_depth)) 450 return MATCHED_EXACTLY; 451 else 452 return 0; 453 } 454 455 name += prefix; 456 namelen -= prefix; 457 458 for (i = ps->nr - 1; i >= 0; i--) { 459 int how; 460 461 if ((!exclude && ps->items[i].magic & PATHSPEC_EXCLUDE) || 462 ( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE))) 463 continue; 464 465 if (seen && seen[i] == MATCHED_EXACTLY) 466 continue; 467 /* 468 * Make exclude patterns optional and never report 469 * "pathspec ':(exclude)foo' matches no files" 470 */ 471 if (seen && ps->items[i].magic & PATHSPEC_EXCLUDE) 472 seen[i] = MATCHED_FNMATCH; 473 how = match_pathspec_item(ps->items+i, prefix, name, 474 namelen, flags); 475 if (ps->recursive && 476 (ps->magic & PATHSPEC_MAXDEPTH) && 477 ps->max_depth != -1 && 478 how && how != MATCHED_FNMATCH) { 479 int len = ps->items[i].len; 480 if (name[len] == '/') 481 len++; 482 if (within_depth(name+len, namelen-len, 0, ps->max_depth)) 483 how = MATCHED_EXACTLY; 484 else 485 how = 0; 486 } 487 if (how) { 488 if (retval < how) 489 retval = how; 490 if (seen && seen[i] < how) 491 seen[i] = how; 492 } 493 } 494 return retval; 495} 496 497int match_pathspec(const struct pathspec *ps, 498 const char *name, int namelen, 499 int prefix, char *seen, int is_dir) 500{ 501 int positive, negative; 502 unsigned flags = is_dir ? DO_MATCH_DIRECTORY : 0; 503 positive = do_match_pathspec(ps, name, namelen, 504 prefix, seen, flags); 505 if (!(ps->magic & PATHSPEC_EXCLUDE) || !positive) 506 return positive; 507 negative = do_match_pathspec(ps, name, namelen, 508 prefix, seen, 509 flags | DO_MATCH_EXCLUDE); 510 return negative ? 0 : positive; 511} 512 513/** 514 * Check if a submodule is a superset of the pathspec 515 */ 516int submodule_path_match(const struct pathspec *ps, 517 const char *submodule_name, 518 char *seen) 519{ 520 int matched = do_match_pathspec(ps, submodule_name, 521 strlen(submodule_name), 522 0, seen, 523 DO_MATCH_DIRECTORY | 524 DO_MATCH_SUBMODULE); 525 return matched; 526} 527 528int report_path_error(const char *ps_matched, 529 const struct pathspec *pathspec, 530 const char *prefix) 531{ 532 /* 533 * Make sure all pathspec matched; otherwise it is an error. 534 */ 535 int num, errors = 0; 536 for (num = 0; num < pathspec->nr; num++) { 537 int other, found_dup; 538 539 if (ps_matched[num]) 540 continue; 541 /* 542 * The caller might have fed identical pathspec 543 * twice. Do not barf on such a mistake. 544 * FIXME: parse_pathspec should have eliminated 545 * duplicate pathspec. 546 */ 547 for (found_dup = other = 0; 548 !found_dup && other < pathspec->nr; 549 other++) { 550 if (other == num || !ps_matched[other]) 551 continue; 552 if (!strcmp(pathspec->items[other].original, 553 pathspec->items[num].original)) 554 /* 555 * Ok, we have a match already. 556 */ 557 found_dup = 1; 558 } 559 if (found_dup) 560 continue; 561 562 error("pathspec '%s' did not match any file(s) known to git.", 563 pathspec->items[num].original); 564 errors++; 565 } 566 return errors; 567} 568 569/* 570 * Return the length of the "simple" part of a path match limiter. 571 */ 572int simple_length(const char *match) 573{ 574 int len = -1; 575 576 for (;;) { 577 unsigned char c = *match++; 578 len++; 579 if (c == '\0' || is_glob_special(c)) 580 return len; 581 } 582} 583 584int no_wildcard(const char *string) 585{ 586 return string[simple_length(string)] == '\0'; 587} 588 589void parse_exclude_pattern(const char **pattern, 590 int *patternlen, 591 unsigned *flags, 592 int *nowildcardlen) 593{ 594 const char *p = *pattern; 595 size_t i, len; 596 597 *flags = 0; 598 if (*p == '!') { 599 *flags |= EXC_FLAG_NEGATIVE; 600 p++; 601 } 602 len = strlen(p); 603 if (len && p[len - 1] == '/') { 604 len--; 605 *flags |= EXC_FLAG_MUSTBEDIR; 606 } 607 for (i = 0; i < len; i++) { 608 if (p[i] == '/') 609 break; 610 } 611 if (i == len) 612 *flags |= EXC_FLAG_NODIR; 613 *nowildcardlen = simple_length(p); 614 /* 615 * we should have excluded the trailing slash from 'p' too, 616 * but that's one more allocation. Instead just make sure 617 * nowildcardlen does not exceed real patternlen 618 */ 619 if (*nowildcardlen > len) 620 *nowildcardlen = len; 621 if (*p == '*' && no_wildcard(p + 1)) 622 *flags |= EXC_FLAG_ENDSWITH; 623 *pattern = p; 624 *patternlen = len; 625} 626 627void add_exclude(const char *string, const char *base, 628 int baselen, struct exclude_list *el, int srcpos) 629{ 630 struct exclude *x; 631 int patternlen; 632 unsigned flags; 633 int nowildcardlen; 634 635 parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 636 if (flags & EXC_FLAG_MUSTBEDIR) { 637 FLEXPTR_ALLOC_MEM(x, pattern, string, patternlen); 638 } else { 639 x = xmalloc(sizeof(*x)); 640 x->pattern = string; 641 } 642 x->patternlen = patternlen; 643 x->nowildcardlen = nowildcardlen; 644 x->base = base; 645 x->baselen = baselen; 646 x->flags = flags; 647 x->srcpos = srcpos; 648 ALLOC_GROW(el->excludes, el->nr + 1, el->alloc); 649 el->excludes[el->nr++] = x; 650 x->el = el; 651} 652 653static int read_skip_worktree_file_from_index(const struct index_state *istate, 654 const char *path, 655 size_t *size_out, char **data_out, 656 struct oid_stat *oid_stat) 657{ 658 int pos, len; 659 660 len = strlen(path); 661 pos = index_name_pos(istate, path, len); 662 if (pos < 0) 663 return -1; 664 if (!ce_skip_worktree(istate->cache[pos])) 665 return -1; 666 667 return do_read_blob(&istate->cache[pos]->oid, oid_stat, size_out, data_out); 668} 669 670/* 671 * Frees memory within el which was allocated for exclude patterns and 672 * the file buffer. Does not free el itself. 673 */ 674void clear_exclude_list(struct exclude_list *el) 675{ 676 int i; 677 678 for (i = 0; i < el->nr; i++) 679 free(el->excludes[i]); 680 free(el->excludes); 681 free(el->filebuf); 682 683 memset(el, 0, sizeof(*el)); 684} 685 686static void trim_trailing_spaces(char *buf) 687{ 688 char *p, *last_space = NULL; 689 690 for (p = buf; *p; p++) 691 switch (*p) { 692 case ' ': 693 if (!last_space) 694 last_space = p; 695 break; 696 case '\\': 697 p++; 698 if (!*p) 699 return; 700 /* fallthrough */ 701 default: 702 last_space = NULL; 703 } 704 705 if (last_space) 706 *last_space = '\0'; 707} 708 709/* 710 * Given a subdirectory name and "dir" of the current directory, 711 * search the subdir in "dir" and return it, or create a new one if it 712 * does not exist in "dir". 713 * 714 * If "name" has the trailing slash, it'll be excluded in the search. 715 */ 716static struct untracked_cache_dir *lookup_untracked(struct untracked_cache *uc, 717 struct untracked_cache_dir *dir, 718 const char *name, int len) 719{ 720 int first, last; 721 struct untracked_cache_dir *d; 722 if (!dir) 723 return NULL; 724 if (len && name[len - 1] == '/') 725 len--; 726 first = 0; 727 last = dir->dirs_nr; 728 while (last > first) { 729 int cmp, next = (last + first) >> 1; 730 d = dir->dirs[next]; 731 cmp = strncmp(name, d->name, len); 732 if (!cmp && strlen(d->name) > len) 733 cmp = -1; 734 if (!cmp) 735 return d; 736 if (cmp < 0) { 737 last = next; 738 continue; 739 } 740 first = next+1; 741 } 742 743 uc->dir_created++; 744 FLEX_ALLOC_MEM(d, name, name, len); 745 746 ALLOC_GROW(dir->dirs, dir->dirs_nr + 1, dir->dirs_alloc); 747 memmove(dir->dirs + first + 1, dir->dirs + first, 748 (dir->dirs_nr - first) * sizeof(*dir->dirs)); 749 dir->dirs_nr++; 750 dir->dirs[first] = d; 751 return d; 752} 753 754static void do_invalidate_gitignore(struct untracked_cache_dir *dir) 755{ 756 int i; 757 dir->valid = 0; 758 dir->untracked_nr = 0; 759 for (i = 0; i < dir->dirs_nr; i++) 760 do_invalidate_gitignore(dir->dirs[i]); 761} 762 763static void invalidate_gitignore(struct untracked_cache *uc, 764 struct untracked_cache_dir *dir) 765{ 766 uc->gitignore_invalidated++; 767 do_invalidate_gitignore(dir); 768} 769 770static void invalidate_directory(struct untracked_cache *uc, 771 struct untracked_cache_dir *dir) 772{ 773 int i; 774 uc->dir_invalidated++; 775 dir->valid = 0; 776 dir->untracked_nr = 0; 777 for (i = 0; i < dir->dirs_nr; i++) 778 dir->dirs[i]->recurse = 0; 779} 780 781static int add_excludes_from_buffer(char *buf, size_t size, 782 const char *base, int baselen, 783 struct exclude_list *el); 784 785/* 786 * Given a file with name "fname", read it (either from disk, or from 787 * an index if 'istate' is non-null), parse it and store the 788 * exclude rules in "el". 789 * 790 * If "ss" is not NULL, compute SHA-1 of the exclude file and fill 791 * stat data from disk (only valid if add_excludes returns zero). If 792 * ss_valid is non-zero, "ss" must contain good value as input. 793 */ 794static int add_excludes(const char *fname, const char *base, int baselen, 795 struct exclude_list *el, struct index_state *istate, 796 struct oid_stat *oid_stat) 797{ 798 struct stat st; 799 int r; 800 int fd; 801 size_t size = 0; 802 char *buf; 803 804 fd = open(fname, O_RDONLY); 805 if (fd < 0 || fstat(fd, &st) < 0) { 806 if (fd < 0) 807 warn_on_fopen_errors(fname); 808 else 809 close(fd); 810 if (!istate) 811 return -1; 812 r = read_skip_worktree_file_from_index(istate, fname, 813 &size, &buf, 814 oid_stat); 815 if (r != 1) 816 return r; 817 } else { 818 size = xsize_t(st.st_size); 819 if (size == 0) { 820 if (oid_stat) { 821 fill_stat_data(&oid_stat->stat, &st); 822 oidcpy(&oid_stat->oid, &empty_blob_oid); 823 oid_stat->valid = 1; 824 } 825 close(fd); 826 return 0; 827 } 828 buf = xmallocz(size); 829 if (read_in_full(fd, buf, size) != size) { 830 free(buf); 831 close(fd); 832 return -1; 833 } 834 buf[size++] = '\n'; 835 close(fd); 836 if (oid_stat) { 837 int pos; 838 if (oid_stat->valid && 839 !match_stat_data_racy(istate, &oid_stat->stat, &st)) 840 ; /* no content change, ss->sha1 still good */ 841 else if (istate && 842 (pos = index_name_pos(istate, fname, strlen(fname))) >= 0 && 843 !ce_stage(istate->cache[pos]) && 844 ce_uptodate(istate->cache[pos]) && 845 !would_convert_to_git(istate, fname)) 846 oidcpy(&oid_stat->oid, 847 &istate->cache[pos]->oid); 848 else 849 hash_sha1_file(buf, size, "blob", 850 oid_stat->oid.hash); 851 fill_stat_data(&oid_stat->stat, &st); 852 oid_stat->valid = 1; 853 } 854 } 855 856 add_excludes_from_buffer(buf, size, base, baselen, el); 857 return 0; 858} 859 860static int add_excludes_from_buffer(char *buf, size_t size, 861 const char *base, int baselen, 862 struct exclude_list *el) 863{ 864 int i, lineno = 1; 865 char *entry; 866 867 el->filebuf = buf; 868 869 if (skip_utf8_bom(&buf, size)) 870 size -= buf - el->filebuf; 871 872 entry = buf; 873 874 for (i = 0; i < size; i++) { 875 if (buf[i] == '\n') { 876 if (entry != buf + i && entry[0] != '#') { 877 buf[i - (i && buf[i-1] == '\r')] = 0; 878 trim_trailing_spaces(entry); 879 add_exclude(entry, base, baselen, el, lineno); 880 } 881 lineno++; 882 entry = buf + i + 1; 883 } 884 } 885 return 0; 886} 887 888int add_excludes_from_file_to_list(const char *fname, const char *base, 889 int baselen, struct exclude_list *el, 890 struct index_state *istate) 891{ 892 return add_excludes(fname, base, baselen, el, istate, NULL); 893} 894 895int add_excludes_from_blob_to_list( 896 struct object_id *oid, 897 const char *base, int baselen, 898 struct exclude_list *el) 899{ 900 char *buf; 901 size_t size; 902 int r; 903 904 r = do_read_blob(oid, NULL, &size, &buf); 905 if (r != 1) 906 return r; 907 908 add_excludes_from_buffer(buf, size, base, baselen, el); 909 return 0; 910} 911 912struct exclude_list *add_exclude_list(struct dir_struct *dir, 913 int group_type, const char *src) 914{ 915 struct exclude_list *el; 916 struct exclude_list_group *group; 917 918 group = &dir->exclude_list_group[group_type]; 919 ALLOC_GROW(group->el, group->nr + 1, group->alloc); 920 el = &group->el[group->nr++]; 921 memset(el, 0, sizeof(*el)); 922 el->src = src; 923 return el; 924} 925 926/* 927 * Used to set up core.excludesfile and .git/info/exclude lists. 928 */ 929static void add_excludes_from_file_1(struct dir_struct *dir, const char *fname, 930 struct oid_stat *oid_stat) 931{ 932 struct exclude_list *el; 933 /* 934 * catch setup_standard_excludes() that's called before 935 * dir->untracked is assigned. That function behaves 936 * differently when dir->untracked is non-NULL. 937 */ 938 if (!dir->untracked) 939 dir->unmanaged_exclude_files++; 940 el = add_exclude_list(dir, EXC_FILE, fname); 941 if (add_excludes(fname, "", 0, el, NULL, oid_stat) < 0) 942 die("cannot use %s as an exclude file", fname); 943} 944 945void add_excludes_from_file(struct dir_struct *dir, const char *fname) 946{ 947 dir->unmanaged_exclude_files++; /* see validate_untracked_cache() */ 948 add_excludes_from_file_1(dir, fname, NULL); 949} 950 951int match_basename(const char *basename, int basenamelen, 952 const char *pattern, int prefix, int patternlen, 953 unsigned flags) 954{ 955 if (prefix == patternlen) { 956 if (patternlen == basenamelen && 957 !fspathncmp(pattern, basename, basenamelen)) 958 return 1; 959 } else if (flags & EXC_FLAG_ENDSWITH) { 960 /* "*literal" matching against "fooliteral" */ 961 if (patternlen - 1 <= basenamelen && 962 !fspathncmp(pattern + 1, 963 basename + basenamelen - (patternlen - 1), 964 patternlen - 1)) 965 return 1; 966 } else { 967 if (fnmatch_icase_mem(pattern, patternlen, 968 basename, basenamelen, 969 0) == 0) 970 return 1; 971 } 972 return 0; 973} 974 975int match_pathname(const char *pathname, int pathlen, 976 const char *base, int baselen, 977 const char *pattern, int prefix, int patternlen, 978 unsigned flags) 979{ 980 const char *name; 981 int namelen; 982 983 /* 984 * match with FNM_PATHNAME; the pattern has base implicitly 985 * in front of it. 986 */ 987 if (*pattern == '/') { 988 pattern++; 989 patternlen--; 990 prefix--; 991 } 992 993 /* 994 * baselen does not count the trailing slash. base[] may or 995 * may not end with a trailing slash though. 996 */ 997 if (pathlen < baselen + 1 || 998 (baselen && pathname[baselen] != '/') || 999 fspathncmp(pathname, base, baselen))1000 return 0;10011002 namelen = baselen ? pathlen - baselen - 1 : pathlen;1003 name = pathname + pathlen - namelen;10041005 if (prefix) {1006 /*1007 * if the non-wildcard part is longer than the1008 * remaining pathname, surely it cannot match.1009 */1010 if (prefix > namelen)1011 return 0;10121013 if (fspathncmp(pattern, name, prefix))1014 return 0;1015 pattern += prefix;1016 patternlen -= prefix;1017 name += prefix;1018 namelen -= prefix;10191020 /*1021 * If the whole pattern did not have a wildcard,1022 * then our prefix match is all we need; we1023 * do not need to call fnmatch at all.1024 */1025 if (!patternlen && !namelen)1026 return 1;1027 }10281029 return fnmatch_icase_mem(pattern, patternlen,1030 name, namelen,1031 WM_PATHNAME) == 0;1032}10331034/*1035 * Scan the given exclude list in reverse to see whether pathname1036 * should be ignored. The first match (i.e. the last on the list), if1037 * any, determines the fate. Returns the exclude_list element which1038 * matched, or NULL for undecided.1039 */1040static struct exclude *last_exclude_matching_from_list(const char *pathname,1041 int pathlen,1042 const char *basename,1043 int *dtype,1044 struct exclude_list *el,1045 struct index_state *istate)1046{1047 struct exclude *exc = NULL; /* undecided */1048 int i;10491050 if (!el->nr)1051 return NULL; /* undefined */10521053 for (i = el->nr - 1; 0 <= i; i--) {1054 struct exclude *x = el->excludes[i];1055 const char *exclude = x->pattern;1056 int prefix = x->nowildcardlen;10571058 if (x->flags & EXC_FLAG_MUSTBEDIR) {1059 if (*dtype == DT_UNKNOWN)1060 *dtype = get_dtype(NULL, istate, pathname, pathlen);1061 if (*dtype != DT_DIR)1062 continue;1063 }10641065 if (x->flags & EXC_FLAG_NODIR) {1066 if (match_basename(basename,1067 pathlen - (basename - pathname),1068 exclude, prefix, x->patternlen,1069 x->flags)) {1070 exc = x;1071 break;1072 }1073 continue;1074 }10751076 assert(x->baselen == 0 || x->base[x->baselen - 1] == '/');1077 if (match_pathname(pathname, pathlen,1078 x->base, x->baselen ? x->baselen - 1 : 0,1079 exclude, prefix, x->patternlen, x->flags)) {1080 exc = x;1081 break;1082 }1083 }1084 return exc;1085}10861087/*1088 * Scan the list and let the last match determine the fate.1089 * Return 1 for exclude, 0 for include and -1 for undecided.1090 */1091int is_excluded_from_list(const char *pathname,1092 int pathlen, const char *basename, int *dtype,1093 struct exclude_list *el, struct index_state *istate)1094{1095 struct exclude *exclude;1096 exclude = last_exclude_matching_from_list(pathname, pathlen, basename,1097 dtype, el, istate);1098 if (exclude)1099 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1;1100 return -1; /* undecided */1101}11021103static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir,1104 struct index_state *istate,1105 const char *pathname, int pathlen, const char *basename,1106 int *dtype_p)1107{1108 int i, j;1109 struct exclude_list_group *group;1110 struct exclude *exclude;1111 for (i = EXC_CMDL; i <= EXC_FILE; i++) {1112 group = &dir->exclude_list_group[i];1113 for (j = group->nr - 1; j >= 0; j--) {1114 exclude = last_exclude_matching_from_list(1115 pathname, pathlen, basename, dtype_p,1116 &group->el[j], istate);1117 if (exclude)1118 return exclude;1119 }1120 }1121 return NULL;1122}11231124/*1125 * Loads the per-directory exclude list for the substring of base1126 * which has a char length of baselen.1127 */1128static void prep_exclude(struct dir_struct *dir,1129 struct index_state *istate,1130 const char *base, int baselen)1131{1132 struct exclude_list_group *group;1133 struct exclude_list *el;1134 struct exclude_stack *stk = NULL;1135 struct untracked_cache_dir *untracked;1136 int current;11371138 group = &dir->exclude_list_group[EXC_DIRS];11391140 /*1141 * Pop the exclude lists from the EXCL_DIRS exclude_list_group1142 * which originate from directories not in the prefix of the1143 * path being checked.1144 */1145 while ((stk = dir->exclude_stack) != NULL) {1146 if (stk->baselen <= baselen &&1147 !strncmp(dir->basebuf.buf, base, stk->baselen))1148 break;1149 el = &group->el[dir->exclude_stack->exclude_ix];1150 dir->exclude_stack = stk->prev;1151 dir->exclude = NULL;1152 free((char *)el->src); /* see strbuf_detach() below */1153 clear_exclude_list(el);1154 free(stk);1155 group->nr--;1156 }11571158 /* Skip traversing into sub directories if the parent is excluded */1159 if (dir->exclude)1160 return;11611162 /*1163 * Lazy initialization. All call sites currently just1164 * memset(dir, 0, sizeof(*dir)) before use. Changing all of1165 * them seems lots of work for little benefit.1166 */1167 if (!dir->basebuf.buf)1168 strbuf_init(&dir->basebuf, PATH_MAX);11691170 /* Read from the parent directories and push them down. */1171 current = stk ? stk->baselen : -1;1172 strbuf_setlen(&dir->basebuf, current < 0 ? 0 : current);1173 if (dir->untracked)1174 untracked = stk ? stk->ucd : dir->untracked->root;1175 else1176 untracked = NULL;11771178 while (current < baselen) {1179 const char *cp;1180 struct oid_stat oid_stat;11811182 stk = xcalloc(1, sizeof(*stk));1183 if (current < 0) {1184 cp = base;1185 current = 0;1186 } else {1187 cp = strchr(base + current + 1, '/');1188 if (!cp)1189 die("oops in prep_exclude");1190 cp++;1191 untracked =1192 lookup_untracked(dir->untracked, untracked,1193 base + current,1194 cp - base - current);1195 }1196 stk->prev = dir->exclude_stack;1197 stk->baselen = cp - base;1198 stk->exclude_ix = group->nr;1199 stk->ucd = untracked;1200 el = add_exclude_list(dir, EXC_DIRS, NULL);1201 strbuf_add(&dir->basebuf, base + current, stk->baselen - current);1202 assert(stk->baselen == dir->basebuf.len);12031204 /* Abort if the directory is excluded */1205 if (stk->baselen) {1206 int dt = DT_DIR;1207 dir->basebuf.buf[stk->baselen - 1] = 0;1208 dir->exclude = last_exclude_matching_from_lists(dir,1209 istate,1210 dir->basebuf.buf, stk->baselen - 1,1211 dir->basebuf.buf + current, &dt);1212 dir->basebuf.buf[stk->baselen - 1] = '/';1213 if (dir->exclude &&1214 dir->exclude->flags & EXC_FLAG_NEGATIVE)1215 dir->exclude = NULL;1216 if (dir->exclude) {1217 dir->exclude_stack = stk;1218 return;1219 }1220 }12211222 /* Try to read per-directory file */1223 oidclr(&oid_stat.oid);1224 oid_stat.valid = 0;1225 if (dir->exclude_per_dir &&1226 /*1227 * If we know that no files have been added in1228 * this directory (i.e. valid_cached_dir() has1229 * been executed and set untracked->valid) ..1230 */1231 (!untracked || !untracked->valid ||1232 /*1233 * .. and .gitignore does not exist before1234 * (i.e. null exclude_sha1). Then we can skip1235 * loading .gitignore, which would result in1236 * ENOENT anyway.1237 */1238 !is_null_sha1(untracked->exclude_sha1))) {1239 /*1240 * dir->basebuf gets reused by the traversal, but we1241 * need fname to remain unchanged to ensure the src1242 * member of each struct exclude correctly1243 * back-references its source file. Other invocations1244 * of add_exclude_list provide stable strings, so we1245 * strbuf_detach() and free() here in the caller.1246 */1247 struct strbuf sb = STRBUF_INIT;1248 strbuf_addbuf(&sb, &dir->basebuf);1249 strbuf_addstr(&sb, dir->exclude_per_dir);1250 el->src = strbuf_detach(&sb, NULL);1251 add_excludes(el->src, el->src, stk->baselen, el, istate,1252 untracked ? &oid_stat : NULL);1253 }1254 /*1255 * NEEDSWORK: when untracked cache is enabled, prep_exclude()1256 * will first be called in valid_cached_dir() then maybe many1257 * times more in last_exclude_matching(). When the cache is1258 * used, last_exclude_matching() will not be called and1259 * reading .gitignore content will be a waste.1260 *1261 * So when it's called by valid_cached_dir() and we can get1262 * .gitignore SHA-1 from the index (i.e. .gitignore is not1263 * modified on work tree), we could delay reading the1264 * .gitignore content until we absolutely need it in1265 * last_exclude_matching(). Be careful about ignore rule1266 * order, though, if you do that.1267 */1268 if (untracked &&1269 hashcmp(oid_stat.oid.hash, untracked->exclude_sha1)) {1270 invalidate_gitignore(dir->untracked, untracked);1271 hashcpy(untracked->exclude_sha1, oid_stat.oid.hash);1272 }1273 dir->exclude_stack = stk;1274 current = stk->baselen;1275 }1276 strbuf_setlen(&dir->basebuf, baselen);1277}12781279/*1280 * Loads the exclude lists for the directory containing pathname, then1281 * scans all exclude lists to determine whether pathname is excluded.1282 * Returns the exclude_list element which matched, or NULL for1283 * undecided.1284 */1285struct exclude *last_exclude_matching(struct dir_struct *dir,1286 struct index_state *istate,1287 const char *pathname,1288 int *dtype_p)1289{1290 int pathlen = strlen(pathname);1291 const char *basename = strrchr(pathname, '/');1292 basename = (basename) ? basename+1 : pathname;12931294 prep_exclude(dir, istate, pathname, basename-pathname);12951296 if (dir->exclude)1297 return dir->exclude;12981299 return last_exclude_matching_from_lists(dir, istate, pathname, pathlen,1300 basename, dtype_p);1301}13021303/*1304 * Loads the exclude lists for the directory containing pathname, then1305 * scans all exclude lists to determine whether pathname is excluded.1306 * Returns 1 if true, otherwise 0.1307 */1308int is_excluded(struct dir_struct *dir, struct index_state *istate,1309 const char *pathname, int *dtype_p)1310{1311 struct exclude *exclude =1312 last_exclude_matching(dir, istate, pathname, dtype_p);1313 if (exclude)1314 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1;1315 return 0;1316}13171318static struct dir_entry *dir_entry_new(const char *pathname, int len)1319{1320 struct dir_entry *ent;13211322 FLEX_ALLOC_MEM(ent, name, pathname, len);1323 ent->len = len;1324 return ent;1325}13261327static struct dir_entry *dir_add_name(struct dir_struct *dir,1328 struct index_state *istate,1329 const char *pathname, int len)1330{1331 if (index_file_exists(istate, pathname, len, ignore_case))1332 return NULL;13331334 ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);1335 return dir->entries[dir->nr++] = dir_entry_new(pathname, len);1336}13371338struct dir_entry *dir_add_ignored(struct dir_struct *dir,1339 struct index_state *istate,1340 const char *pathname, int len)1341{1342 if (!index_name_is_other(istate, pathname, len))1343 return NULL;13441345 ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);1346 return dir->ignored[dir->ignored_nr++] = dir_entry_new(pathname, len);1347}13481349enum exist_status {1350 index_nonexistent = 0,1351 index_directory,1352 index_gitdir1353};13541355/*1356 * Do not use the alphabetically sorted index to look up1357 * the directory name; instead, use the case insensitive1358 * directory hash.1359 */1360static enum exist_status directory_exists_in_index_icase(struct index_state *istate,1361 const char *dirname, int len)1362{1363 struct cache_entry *ce;13641365 if (index_dir_exists(istate, dirname, len))1366 return index_directory;13671368 ce = index_file_exists(istate, dirname, len, ignore_case);1369 if (ce && S_ISGITLINK(ce->ce_mode))1370 return index_gitdir;13711372 return index_nonexistent;1373}13741375/*1376 * The index sorts alphabetically by entry name, which1377 * means that a gitlink sorts as '\0' at the end, while1378 * a directory (which is defined not as an entry, but as1379 * the files it contains) will sort with the '/' at the1380 * end.1381 */1382static enum exist_status directory_exists_in_index(struct index_state *istate,1383 const char *dirname, int len)1384{1385 int pos;13861387 if (ignore_case)1388 return directory_exists_in_index_icase(istate, dirname, len);13891390 pos = index_name_pos(istate, dirname, len);1391 if (pos < 0)1392 pos = -pos-1;1393 while (pos < istate->cache_nr) {1394 const struct cache_entry *ce = istate->cache[pos++];1395 unsigned char endchar;13961397 if (strncmp(ce->name, dirname, len))1398 break;1399 endchar = ce->name[len];1400 if (endchar > '/')1401 break;1402 if (endchar == '/')1403 return index_directory;1404 if (!endchar && S_ISGITLINK(ce->ce_mode))1405 return index_gitdir;1406 }1407 return index_nonexistent;1408}14091410/*1411 * When we find a directory when traversing the filesystem, we1412 * have three distinct cases:1413 *1414 * - ignore it1415 * - see it as a directory1416 * - recurse into it1417 *1418 * and which one we choose depends on a combination of existing1419 * git index contents and the flags passed into the directory1420 * traversal routine.1421 *1422 * Case 1: If we *already* have entries in the index under that1423 * directory name, we always recurse into the directory to see1424 * all the files.1425 *1426 * Case 2: If we *already* have that directory name as a gitlink,1427 * we always continue to see it as a gitlink, regardless of whether1428 * there is an actual git directory there or not (it might not1429 * be checked out as a subproject!)1430 *1431 * Case 3: if we didn't have it in the index previously, we1432 * have a few sub-cases:1433 *1434 * (a) if "show_other_directories" is true, we show it as1435 * just a directory, unless "hide_empty_directories" is1436 * also true, in which case we need to check if it contains any1437 * untracked and / or ignored files.1438 * (b) if it looks like a git directory, and we don't have1439 * 'no_gitlinks' set we treat it as a gitlink, and show it1440 * as a directory.1441 * (c) otherwise, we recurse into it.1442 */1443static enum path_treatment treat_directory(struct dir_struct *dir,1444 struct index_state *istate,1445 struct untracked_cache_dir *untracked,1446 const char *dirname, int len, int baselen, int exclude,1447 const struct pathspec *pathspec)1448{1449 /* The "len-1" is to strip the final '/' */1450 switch (directory_exists_in_index(istate, dirname, len-1)) {1451 case index_directory:1452 return path_recurse;14531454 case index_gitdir:1455 return path_none;14561457 case index_nonexistent:1458 if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1459 break;1460 if (exclude &&1461 (dir->flags & DIR_SHOW_IGNORED_TOO) &&1462 (dir->flags & DIR_SHOW_IGNORED_TOO_MODE_MATCHING)) {14631464 /*1465 * This is an excluded directory and we are1466 * showing ignored paths that match an exclude1467 * pattern. (e.g. show directory as ignored1468 * only if it matches an exclude pattern).1469 * This path will either be 'path_excluded`1470 * (if we are showing empty directories or if1471 * the directory is not empty), or will be1472 * 'path_none' (empty directory, and we are1473 * not showing empty directories).1474 */1475 if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1476 return path_excluded;14771478 if (read_directory_recursive(dir, istate, dirname, len,1479 untracked, 1, 1, pathspec) == path_excluded)1480 return path_excluded;14811482 return path_none;1483 }1484 if (!(dir->flags & DIR_NO_GITLINKS)) {1485 struct object_id oid;1486 if (resolve_gitlink_ref(dirname, "HEAD", &oid) == 0)1487 return exclude ? path_excluded : path_untracked;1488 }1489 return path_recurse;1490 }14911492 /* This is the "show_other_directories" case */14931494 if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1495 return exclude ? path_excluded : path_untracked;14961497 untracked = lookup_untracked(dir->untracked, untracked,1498 dirname + baselen, len - baselen);14991500 /*1501 * If this is an excluded directory, then we only need to check if1502 * the directory contains any files.1503 */1504 return read_directory_recursive(dir, istate, dirname, len,1505 untracked, 1, exclude, pathspec);1506}15071508/*1509 * This is an inexact early pruning of any recursive directory1510 * reading - if the path cannot possibly be in the pathspec,1511 * return true, and we'll skip it early.1512 */1513static int simplify_away(const char *path, int pathlen,1514 const struct pathspec *pathspec)1515{1516 int i;15171518 if (!pathspec || !pathspec->nr)1519 return 0;15201521 GUARD_PATHSPEC(pathspec,1522 PATHSPEC_FROMTOP |1523 PATHSPEC_MAXDEPTH |1524 PATHSPEC_LITERAL |1525 PATHSPEC_GLOB |1526 PATHSPEC_ICASE |1527 PATHSPEC_EXCLUDE |1528 PATHSPEC_ATTR);15291530 for (i = 0; i < pathspec->nr; i++) {1531 const struct pathspec_item *item = &pathspec->items[i];1532 int len = item->nowildcard_len;15331534 if (len > pathlen)1535 len = pathlen;1536 if (!ps_strncmp(item, item->match, path, len))1537 return 0;1538 }15391540 return 1;1541}15421543/*1544 * This function tells us whether an excluded path matches a1545 * list of "interesting" pathspecs. That is, whether a path matched1546 * by any of the pathspecs could possibly be ignored by excluding1547 * the specified path. This can happen if:1548 *1549 * 1. the path is mentioned explicitly in the pathspec1550 *1551 * 2. the path is a directory prefix of some element in the1552 * pathspec1553 */1554static int exclude_matches_pathspec(const char *path, int pathlen,1555 const struct pathspec *pathspec)1556{1557 int i;15581559 if (!pathspec || !pathspec->nr)1560 return 0;15611562 GUARD_PATHSPEC(pathspec,1563 PATHSPEC_FROMTOP |1564 PATHSPEC_MAXDEPTH |1565 PATHSPEC_LITERAL |1566 PATHSPEC_GLOB |1567 PATHSPEC_ICASE |1568 PATHSPEC_EXCLUDE);15691570 for (i = 0; i < pathspec->nr; i++) {1571 const struct pathspec_item *item = &pathspec->items[i];1572 int len = item->nowildcard_len;15731574 if (len == pathlen &&1575 !ps_strncmp(item, item->match, path, pathlen))1576 return 1;1577 if (len > pathlen &&1578 item->match[pathlen] == '/' &&1579 !ps_strncmp(item, item->match, path, pathlen))1580 return 1;1581 }1582 return 0;1583}15841585static int get_index_dtype(struct index_state *istate,1586 const char *path, int len)1587{1588 int pos;1589 const struct cache_entry *ce;15901591 ce = index_file_exists(istate, path, len, 0);1592 if (ce) {1593 if (!ce_uptodate(ce))1594 return DT_UNKNOWN;1595 if (S_ISGITLINK(ce->ce_mode))1596 return DT_DIR;1597 /*1598 * Nobody actually cares about the1599 * difference between DT_LNK and DT_REG1600 */1601 return DT_REG;1602 }16031604 /* Try to look it up as a directory */1605 pos = index_name_pos(istate, path, len);1606 if (pos >= 0)1607 return DT_UNKNOWN;1608 pos = -pos-1;1609 while (pos < istate->cache_nr) {1610 ce = istate->cache[pos++];1611 if (strncmp(ce->name, path, len))1612 break;1613 if (ce->name[len] > '/')1614 break;1615 if (ce->name[len] < '/')1616 continue;1617 if (!ce_uptodate(ce))1618 break; /* continue? */1619 return DT_DIR;1620 }1621 return DT_UNKNOWN;1622}16231624static int get_dtype(struct dirent *de, struct index_state *istate,1625 const char *path, int len)1626{1627 int dtype = de ? DTYPE(de) : DT_UNKNOWN;1628 struct stat st;16291630 if (dtype != DT_UNKNOWN)1631 return dtype;1632 dtype = get_index_dtype(istate, path, len);1633 if (dtype != DT_UNKNOWN)1634 return dtype;1635 if (lstat(path, &st))1636 return dtype;1637 if (S_ISREG(st.st_mode))1638 return DT_REG;1639 if (S_ISDIR(st.st_mode))1640 return DT_DIR;1641 if (S_ISLNK(st.st_mode))1642 return DT_LNK;1643 return dtype;1644}16451646static enum path_treatment treat_one_path(struct dir_struct *dir,1647 struct untracked_cache_dir *untracked,1648 struct index_state *istate,1649 struct strbuf *path,1650 int baselen,1651 const struct pathspec *pathspec,1652 int dtype, struct dirent *de)1653{1654 int exclude;1655 int has_path_in_index = !!index_file_exists(istate, path->buf, path->len, ignore_case);1656 enum path_treatment path_treatment;16571658 if (dtype == DT_UNKNOWN)1659 dtype = get_dtype(de, istate, path->buf, path->len);16601661 /* Always exclude indexed files */1662 if (dtype != DT_DIR && has_path_in_index)1663 return path_none;16641665 /*1666 * When we are looking at a directory P in the working tree,1667 * there are three cases:1668 *1669 * (1) P exists in the index. Everything inside the directory P in1670 * the working tree needs to go when P is checked out from the1671 * index.1672 *1673 * (2) P does not exist in the index, but there is P/Q in the index.1674 * We know P will stay a directory when we check out the contents1675 * of the index, but we do not know yet if there is a directory1676 * P/Q in the working tree to be killed, so we need to recurse.1677 *1678 * (3) P does not exist in the index, and there is no P/Q in the index1679 * to require P to be a directory, either. Only in this case, we1680 * know that everything inside P will not be killed without1681 * recursing.1682 */1683 if ((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1684 (dtype == DT_DIR) &&1685 !has_path_in_index &&1686 (directory_exists_in_index(istate, path->buf, path->len) == index_nonexistent))1687 return path_none;16881689 exclude = is_excluded(dir, istate, path->buf, &dtype);16901691 /*1692 * Excluded? If we don't explicitly want to show1693 * ignored files, ignore it1694 */1695 if (exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1696 return path_excluded;16971698 switch (dtype) {1699 default:1700 return path_none;1701 case DT_DIR:1702 strbuf_addch(path, '/');1703 path_treatment = treat_directory(dir, istate, untracked,1704 path->buf, path->len,1705 baselen, exclude, pathspec);1706 /*1707 * If 1) we only want to return directories that1708 * match an exclude pattern and 2) this directory does1709 * not match an exclude pattern but all of its1710 * contents are excluded, then indicate that we should1711 * recurse into this directory (instead of marking the1712 * directory itself as an ignored path).1713 */1714 if (!exclude &&1715 path_treatment == path_excluded &&1716 (dir->flags & DIR_SHOW_IGNORED_TOO) &&1717 (dir->flags & DIR_SHOW_IGNORED_TOO_MODE_MATCHING))1718 return path_recurse;1719 return path_treatment;1720 case DT_REG:1721 case DT_LNK:1722 return exclude ? path_excluded : path_untracked;1723 }1724}17251726static enum path_treatment treat_path_fast(struct dir_struct *dir,1727 struct untracked_cache_dir *untracked,1728 struct cached_dir *cdir,1729 struct index_state *istate,1730 struct strbuf *path,1731 int baselen,1732 const struct pathspec *pathspec)1733{1734 strbuf_setlen(path, baselen);1735 if (!cdir->ucd) {1736 strbuf_addstr(path, cdir->file);1737 return path_untracked;1738 }1739 strbuf_addstr(path, cdir->ucd->name);1740 /* treat_one_path() does this before it calls treat_directory() */1741 strbuf_complete(path, '/');1742 if (cdir->ucd->check_only)1743 /*1744 * check_only is set as a result of treat_directory() getting1745 * to its bottom. Verify again the same set of directories1746 * with check_only set.1747 */1748 return read_directory_recursive(dir, istate, path->buf, path->len,1749 cdir->ucd, 1, 0, pathspec);1750 /*1751 * We get path_recurse in the first run when1752 * directory_exists_in_index() returns index_nonexistent. We1753 * are sure that new changes in the index does not impact the1754 * outcome. Return now.1755 */1756 return path_recurse;1757}17581759static enum path_treatment treat_path(struct dir_struct *dir,1760 struct untracked_cache_dir *untracked,1761 struct cached_dir *cdir,1762 struct index_state *istate,1763 struct strbuf *path,1764 int baselen,1765 const struct pathspec *pathspec)1766{1767 int dtype;1768 struct dirent *de = cdir->de;17691770 if (!de)1771 return treat_path_fast(dir, untracked, cdir, istate, path,1772 baselen, pathspec);1773 if (is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name, ".git"))1774 return path_none;1775 strbuf_setlen(path, baselen);1776 strbuf_addstr(path, de->d_name);1777 if (simplify_away(path->buf, path->len, pathspec))1778 return path_none;17791780 dtype = DTYPE(de);1781 return treat_one_path(dir, untracked, istate, path, baselen, pathspec, dtype, de);1782}17831784static void add_untracked(struct untracked_cache_dir *dir, const char *name)1785{1786 if (!dir)1787 return;1788 ALLOC_GROW(dir->untracked, dir->untracked_nr + 1,1789 dir->untracked_alloc);1790 dir->untracked[dir->untracked_nr++] = xstrdup(name);1791}17921793static int valid_cached_dir(struct dir_struct *dir,1794 struct untracked_cache_dir *untracked,1795 struct index_state *istate,1796 struct strbuf *path,1797 int check_only)1798{1799 struct stat st;18001801 if (!untracked)1802 return 0;18031804 /*1805 * With fsmonitor, we can trust the untracked cache's valid field.1806 */1807 refresh_fsmonitor(istate);1808 if (!(dir->untracked->use_fsmonitor && untracked->valid)) {1809 if (stat(path->len ? path->buf : ".", &st)) {1810 invalidate_directory(dir->untracked, untracked);1811 memset(&untracked->stat_data, 0, sizeof(untracked->stat_data));1812 return 0;1813 }1814 if (!untracked->valid ||1815 match_stat_data_racy(istate, &untracked->stat_data, &st)) {1816 if (untracked->valid)1817 invalidate_directory(dir->untracked, untracked);1818 fill_stat_data(&untracked->stat_data, &st);1819 return 0;1820 }1821 }18221823 if (untracked->check_only != !!check_only) {1824 invalidate_directory(dir->untracked, untracked);1825 return 0;1826 }18271828 /*1829 * prep_exclude will be called eventually on this directory,1830 * but it's called much later in last_exclude_matching(). We1831 * need it now to determine the validity of the cache for this1832 * path. The next calls will be nearly no-op, the way1833 * prep_exclude() is designed.1834 */1835 if (path->len && path->buf[path->len - 1] != '/') {1836 strbuf_addch(path, '/');1837 prep_exclude(dir, istate, path->buf, path->len);1838 strbuf_setlen(path, path->len - 1);1839 } else1840 prep_exclude(dir, istate, path->buf, path->len);18411842 /* hopefully prep_exclude() haven't invalidated this entry... */1843 return untracked->valid;1844}18451846static int open_cached_dir(struct cached_dir *cdir,1847 struct dir_struct *dir,1848 struct untracked_cache_dir *untracked,1849 struct index_state *istate,1850 struct strbuf *path,1851 int check_only)1852{1853 memset(cdir, 0, sizeof(*cdir));1854 cdir->untracked = untracked;1855 if (valid_cached_dir(dir, untracked, istate, path, check_only))1856 return 0;1857 cdir->fdir = opendir(path->len ? path->buf : ".");1858 if (dir->untracked)1859 dir->untracked->dir_opened++;1860 if (!cdir->fdir)1861 return -1;1862 return 0;1863}18641865static int read_cached_dir(struct cached_dir *cdir)1866{1867 if (cdir->fdir) {1868 cdir->de = readdir(cdir->fdir);1869 if (!cdir->de)1870 return -1;1871 return 0;1872 }1873 while (cdir->nr_dirs < cdir->untracked->dirs_nr) {1874 struct untracked_cache_dir *d = cdir->untracked->dirs[cdir->nr_dirs];1875 if (!d->recurse) {1876 cdir->nr_dirs++;1877 continue;1878 }1879 cdir->ucd = d;1880 cdir->nr_dirs++;1881 return 0;1882 }1883 cdir->ucd = NULL;1884 if (cdir->nr_files < cdir->untracked->untracked_nr) {1885 struct untracked_cache_dir *d = cdir->untracked;1886 cdir->file = d->untracked[cdir->nr_files++];1887 return 0;1888 }1889 return -1;1890}18911892static void close_cached_dir(struct cached_dir *cdir)1893{1894 if (cdir->fdir)1895 closedir(cdir->fdir);1896 /*1897 * We have gone through this directory and found no untracked1898 * entries. Mark it valid.1899 */1900 if (cdir->untracked) {1901 cdir->untracked->valid = 1;1902 cdir->untracked->recurse = 1;1903 }1904}19051906/*1907 * Read a directory tree. We currently ignore anything but1908 * directories, regular files and symlinks. That's because git1909 * doesn't handle them at all yet. Maybe that will change some1910 * day.1911 *1912 * Also, we ignore the name ".git" (even if it is not a directory).1913 * That likely will not change.1914 *1915 * If 'stop_at_first_file' is specified, 'path_excluded' is returned1916 * to signal that a file was found. This is the least significant value that1917 * indicates that a file was encountered that does not depend on the order of1918 * whether an untracked or exluded path was encountered first.1919 *1920 * Returns the most significant path_treatment value encountered in the scan.1921 * If 'stop_at_first_file' is specified, `path_excluded` is the most1922 * significant path_treatment value that will be returned.1923 */19241925static enum path_treatment read_directory_recursive(struct dir_struct *dir,1926 struct index_state *istate, const char *base, int baselen,1927 struct untracked_cache_dir *untracked, int check_only,1928 int stop_at_first_file, const struct pathspec *pathspec)1929{1930 struct cached_dir cdir;1931 enum path_treatment state, subdir_state, dir_state = path_none;1932 struct strbuf path = STRBUF_INIT;19331934 strbuf_add(&path, base, baselen);19351936 if (open_cached_dir(&cdir, dir, untracked, istate, &path, check_only))1937 goto out;19381939 if (untracked)1940 untracked->check_only = !!check_only;19411942 while (!read_cached_dir(&cdir)) {1943 /* check how the file or directory should be treated */1944 state = treat_path(dir, untracked, &cdir, istate, &path,1945 baselen, pathspec);19461947 if (state > dir_state)1948 dir_state = state;19491950 /* recurse into subdir if instructed by treat_path */1951 if ((state == path_recurse) ||1952 ((state == path_untracked) &&1953 (dir->flags & DIR_SHOW_IGNORED_TOO) &&1954 (get_dtype(cdir.de, istate, path.buf, path.len) == DT_DIR))) {1955 struct untracked_cache_dir *ud;1956 ud = lookup_untracked(dir->untracked, untracked,1957 path.buf + baselen,1958 path.len - baselen);1959 subdir_state =1960 read_directory_recursive(dir, istate, path.buf,1961 path.len, ud,1962 check_only, stop_at_first_file, pathspec);1963 if (subdir_state > dir_state)1964 dir_state = subdir_state;1965 }19661967 if (check_only) {1968 if (stop_at_first_file) {1969 /*1970 * If stopping at first file, then1971 * signal that a file was found by1972 * returning `path_excluded`. This is1973 * to return a consistent value1974 * regardless of whether an ignored or1975 * excluded file happened to be1976 * encountered 1st.1977 *1978 * In current usage, the1979 * `stop_at_first_file` is passed when1980 * an ancestor directory has matched1981 * an exclude pattern, so any found1982 * files will be excluded.1983 */1984 if (dir_state >= path_excluded) {1985 dir_state = path_excluded;1986 break;1987 }1988 }19891990 /* abort early if maximum state has been reached */1991 if (dir_state == path_untracked) {1992 if (cdir.fdir)1993 add_untracked(untracked, path.buf + baselen);1994 break;1995 }1996 /* skip the dir_add_* part */1997 continue;1998 }19992000 /* add the path to the appropriate result list */2001 switch (state) {2002 case path_excluded:2003 if (dir->flags & DIR_SHOW_IGNORED)2004 dir_add_name(dir, istate, path.buf, path.len);2005 else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||2006 ((dir->flags & DIR_COLLECT_IGNORED) &&2007 exclude_matches_pathspec(path.buf, path.len,2008 pathspec)))2009 dir_add_ignored(dir, istate, path.buf, path.len);2010 break;20112012 case path_untracked:2013 if (dir->flags & DIR_SHOW_IGNORED)2014 break;2015 dir_add_name(dir, istate, path.buf, path.len);2016 if (cdir.fdir)2017 add_untracked(untracked, path.buf + baselen);2018 break;20192020 default:2021 break;2022 }2023 }2024 close_cached_dir(&cdir);2025 out:2026 strbuf_release(&path);20272028 return dir_state;2029}20302031int cmp_dir_entry(const void *p1, const void *p2)2032{2033 const struct dir_entry *e1 = *(const struct dir_entry **)p1;2034 const struct dir_entry *e2 = *(const struct dir_entry **)p2;20352036 return name_compare(e1->name, e1->len, e2->name, e2->len);2037}20382039/* check if *out lexically strictly contains *in */2040int check_dir_entry_contains(const struct dir_entry *out, const struct dir_entry *in)2041{2042 return (out->len < in->len) &&2043 (out->name[out->len - 1] == '/') &&2044 !memcmp(out->name, in->name, out->len);2045}20462047static int treat_leading_path(struct dir_struct *dir,2048 struct index_state *istate,2049 const char *path, int len,2050 const struct pathspec *pathspec)2051{2052 struct strbuf sb = STRBUF_INIT;2053 int baselen, rc = 0;2054 const char *cp;2055 int old_flags = dir->flags;20562057 while (len && path[len - 1] == '/')2058 len--;2059 if (!len)2060 return 1;2061 baselen = 0;2062 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;2063 while (1) {2064 cp = path + baselen + !!baselen;2065 cp = memchr(cp, '/', path + len - cp);2066 if (!cp)2067 baselen = len;2068 else2069 baselen = cp - path;2070 strbuf_setlen(&sb, 0);2071 strbuf_add(&sb, path, baselen);2072 if (!is_directory(sb.buf))2073 break;2074 if (simplify_away(sb.buf, sb.len, pathspec))2075 break;2076 if (treat_one_path(dir, NULL, istate, &sb, baselen, pathspec,2077 DT_DIR, NULL) == path_none)2078 break; /* do not recurse into it */2079 if (len <= baselen) {2080 rc = 1;2081 break; /* finished checking */2082 }2083 }2084 strbuf_release(&sb);2085 dir->flags = old_flags;2086 return rc;2087}20882089static const char *get_ident_string(void)2090{2091 static struct strbuf sb = STRBUF_INIT;2092 struct utsname uts;20932094 if (sb.len)2095 return sb.buf;2096 if (uname(&uts) < 0)2097 die_errno(_("failed to get kernel name and information"));2098 strbuf_addf(&sb, "Location %s, system %s", get_git_work_tree(),2099 uts.sysname);2100 return sb.buf;2101}21022103static int ident_in_untracked(const struct untracked_cache *uc)2104{2105 /*2106 * Previous git versions may have saved many NUL separated2107 * strings in the "ident" field, but it is insane to manage2108 * many locations, so just take care of the first one.2109 */21102111 return !strcmp(uc->ident.buf, get_ident_string());2112}21132114static void set_untracked_ident(struct untracked_cache *uc)2115{2116 strbuf_reset(&uc->ident);2117 strbuf_addstr(&uc->ident, get_ident_string());21182119 /*2120 * This strbuf used to contain a list of NUL separated2121 * strings, so save NUL too for backward compatibility.2122 */2123 strbuf_addch(&uc->ident, 0);2124}21252126static void new_untracked_cache(struct index_state *istate)2127{2128 struct untracked_cache *uc = xcalloc(1, sizeof(*uc));2129 strbuf_init(&uc->ident, 100);2130 uc->exclude_per_dir = ".gitignore";2131 /* should be the same flags used by git-status */2132 uc->dir_flags = DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;2133 set_untracked_ident(uc);2134 istate->untracked = uc;2135 istate->cache_changed |= UNTRACKED_CHANGED;2136}21372138void add_untracked_cache(struct index_state *istate)2139{2140 if (!istate->untracked) {2141 new_untracked_cache(istate);2142 } else {2143 if (!ident_in_untracked(istate->untracked)) {2144 free_untracked_cache(istate->untracked);2145 new_untracked_cache(istate);2146 }2147 }2148}21492150void remove_untracked_cache(struct index_state *istate)2151{2152 if (istate->untracked) {2153 free_untracked_cache(istate->untracked);2154 istate->untracked = NULL;2155 istate->cache_changed |= UNTRACKED_CHANGED;2156 }2157}21582159static struct untracked_cache_dir *validate_untracked_cache(struct dir_struct *dir,2160 int base_len,2161 const struct pathspec *pathspec)2162{2163 struct untracked_cache_dir *root;21642165 if (!dir->untracked || getenv("GIT_DISABLE_UNTRACKED_CACHE"))2166 return NULL;21672168 /*2169 * We only support $GIT_DIR/info/exclude and core.excludesfile2170 * as the global ignore rule files. Any other additions2171 * (e.g. from command line) invalidate the cache. This2172 * condition also catches running setup_standard_excludes()2173 * before setting dir->untracked!2174 */2175 if (dir->unmanaged_exclude_files)2176 return NULL;21772178 /*2179 * Optimize for the main use case only: whole-tree git2180 * status. More work involved in treat_leading_path() if we2181 * use cache on just a subset of the worktree. pathspec2182 * support could make the matter even worse.2183 */2184 if (base_len || (pathspec && pathspec->nr))2185 return NULL;21862187 /* Different set of flags may produce different results */2188 if (dir->flags != dir->untracked->dir_flags ||2189 /*2190 * See treat_directory(), case index_nonexistent. Without2191 * this flag, we may need to also cache .git file content2192 * for the resolve_gitlink_ref() call, which we don't.2193 */2194 !(dir->flags & DIR_SHOW_OTHER_DIRECTORIES) ||2195 /* We don't support collecting ignore files */2196 (dir->flags & (DIR_SHOW_IGNORED | DIR_SHOW_IGNORED_TOO |2197 DIR_COLLECT_IGNORED)))2198 return NULL;21992200 /*2201 * If we use .gitignore in the cache and now you change it to2202 * .gitexclude, everything will go wrong.2203 */2204 if (dir->exclude_per_dir != dir->untracked->exclude_per_dir &&2205 strcmp(dir->exclude_per_dir, dir->untracked->exclude_per_dir))2206 return NULL;22072208 /*2209 * EXC_CMDL is not considered in the cache. If people set it,2210 * skip the cache.2211 */2212 if (dir->exclude_list_group[EXC_CMDL].nr)2213 return NULL;22142215 if (!ident_in_untracked(dir->untracked)) {2216 warning(_("Untracked cache is disabled on this system or location."));2217 return NULL;2218 }22192220 if (!dir->untracked->root) {2221 const int len = sizeof(*dir->untracked->root);2222 dir->untracked->root = xmalloc(len);2223 memset(dir->untracked->root, 0, len);2224 }22252226 /* Validate $GIT_DIR/info/exclude and core.excludesfile */2227 root = dir->untracked->root;2228 if (oidcmp(&dir->ss_info_exclude.oid,2229 &dir->untracked->ss_info_exclude.oid)) {2230 invalidate_gitignore(dir->untracked, root);2231 dir->untracked->ss_info_exclude = dir->ss_info_exclude;2232 }2233 if (oidcmp(&dir->ss_excludes_file.oid,2234 &dir->untracked->ss_excludes_file.oid)) {2235 invalidate_gitignore(dir->untracked, root);2236 dir->untracked->ss_excludes_file = dir->ss_excludes_file;2237 }22382239 /* Make sure this directory is not dropped out at saving phase */2240 root->recurse = 1;2241 return root;2242}22432244int read_directory(struct dir_struct *dir, struct index_state *istate,2245 const char *path, int len, const struct pathspec *pathspec)2246{2247 struct untracked_cache_dir *untracked;22482249 if (has_symlink_leading_path(path, len))2250 return dir->nr;22512252 untracked = validate_untracked_cache(dir, len, pathspec);2253 if (!untracked)2254 /*2255 * make sure untracked cache code path is disabled,2256 * e.g. prep_exclude()2257 */2258 dir->untracked = NULL;2259 if (!len || treat_leading_path(dir, istate, path, len, pathspec))2260 read_directory_recursive(dir, istate, path, len, untracked, 0, 0, pathspec);2261 QSORT(dir->entries, dir->nr, cmp_dir_entry);2262 QSORT(dir->ignored, dir->ignored_nr, cmp_dir_entry);22632264 /*2265 * If DIR_SHOW_IGNORED_TOO is set, read_directory_recursive() will2266 * also pick up untracked contents of untracked dirs; by default2267 * we discard these, but given DIR_KEEP_UNTRACKED_CONTENTS we do not.2268 */2269 if ((dir->flags & DIR_SHOW_IGNORED_TOO) &&2270 !(dir->flags & DIR_KEEP_UNTRACKED_CONTENTS)) {2271 int i, j;22722273 /* remove from dir->entries untracked contents of untracked dirs */2274 for (i = j = 0; j < dir->nr; j++) {2275 if (i &&2276 check_dir_entry_contains(dir->entries[i - 1], dir->entries[j])) {2277 FREE_AND_NULL(dir->entries[j]);2278 } else {2279 dir->entries[i++] = dir->entries[j];2280 }2281 }22822283 dir->nr = i;2284 }22852286 if (dir->untracked) {2287 static struct trace_key trace_untracked_stats = TRACE_KEY_INIT(UNTRACKED_STATS);2288 trace_printf_key(&trace_untracked_stats,2289 "node creation: %u\n"2290 "gitignore invalidation: %u\n"2291 "directory invalidation: %u\n"2292 "opendir: %u\n",2293 dir->untracked->dir_created,2294 dir->untracked->gitignore_invalidated,2295 dir->untracked->dir_invalidated,2296 dir->untracked->dir_opened);2297 if (dir->untracked == istate->untracked &&2298 (dir->untracked->dir_opened ||2299 dir->untracked->gitignore_invalidated ||2300 dir->untracked->dir_invalidated))2301 istate->cache_changed |= UNTRACKED_CHANGED;2302 if (dir->untracked != istate->untracked) {2303 FREE_AND_NULL(dir->untracked);2304 }2305 }2306 return dir->nr;2307}23082309int file_exists(const char *f)2310{2311 struct stat sb;2312 return lstat(f, &sb) == 0;2313}23142315static int cmp_icase(char a, char b)2316{2317 if (a == b)2318 return 0;2319 if (ignore_case)2320 return toupper(a) - toupper(b);2321 return a - b;2322}23232324/*2325 * Given two normalized paths (a trailing slash is ok), if subdir is2326 * outside dir, return -1. Otherwise return the offset in subdir that2327 * can be used as relative path to dir.2328 */2329int dir_inside_of(const char *subdir, const char *dir)2330{2331 int offset = 0;23322333 assert(dir && subdir && *dir && *subdir);23342335 while (*dir && *subdir && !cmp_icase(*dir, *subdir)) {2336 dir++;2337 subdir++;2338 offset++;2339 }23402341 /* hel[p]/me vs hel[l]/yeah */2342 if (*dir && *subdir)2343 return -1;23442345 if (!*subdir)2346 return !*dir ? offset : -1; /* same dir */23472348 /* foo/[b]ar vs foo/[] */2349 if (is_dir_sep(dir[-1]))2350 return is_dir_sep(subdir[-1]) ? offset : -1;23512352 /* foo[/]bar vs foo[] */2353 return is_dir_sep(*subdir) ? offset + 1 : -1;2354}23552356int is_inside_dir(const char *dir)2357{2358 char *cwd;2359 int rc;23602361 if (!dir)2362 return 0;23632364 cwd = xgetcwd();2365 rc = (dir_inside_of(cwd, dir) >= 0);2366 free(cwd);2367 return rc;2368}23692370int is_empty_dir(const char *path)2371{2372 DIR *dir = opendir(path);2373 struct dirent *e;2374 int ret = 1;23752376 if (!dir)2377 return 0;23782379 while ((e = readdir(dir)) != NULL)2380 if (!is_dot_or_dotdot(e->d_name)) {2381 ret = 0;2382 break;2383 }23842385 closedir(dir);2386 return ret;2387}23882389static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up)2390{2391 DIR *dir;2392 struct dirent *e;2393 int ret = 0, original_len = path->len, len, kept_down = 0;2394 int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);2395 int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);2396 struct object_id submodule_head;23972398 if ((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&2399 !resolve_gitlink_ref(path->buf, "HEAD", &submodule_head)) {2400 /* Do not descend and nuke a nested git work tree. */2401 if (kept_up)2402 *kept_up = 1;2403 return 0;2404 }24052406 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;2407 dir = opendir(path->buf);2408 if (!dir) {2409 if (errno == ENOENT)2410 return keep_toplevel ? -1 : 0;2411 else if (errno == EACCES && !keep_toplevel)2412 /*2413 * An empty dir could be removable even if it2414 * is unreadable:2415 */2416 return rmdir(path->buf);2417 else2418 return -1;2419 }2420 strbuf_complete(path, '/');24212422 len = path->len;2423 while ((e = readdir(dir)) != NULL) {2424 struct stat st;2425 if (is_dot_or_dotdot(e->d_name))2426 continue;24272428 strbuf_setlen(path, len);2429 strbuf_addstr(path, e->d_name);2430 if (lstat(path->buf, &st)) {2431 if (errno == ENOENT)2432 /*2433 * file disappeared, which is what we2434 * wanted anyway2435 */2436 continue;2437 /* fall thru */2438 } else if (S_ISDIR(st.st_mode)) {2439 if (!remove_dir_recurse(path, flag, &kept_down))2440 continue; /* happy */2441 } else if (!only_empty &&2442 (!unlink(path->buf) || errno == ENOENT)) {2443 continue; /* happy, too */2444 }24452446 /* path too long, stat fails, or non-directory still exists */2447 ret = -1;2448 break;2449 }2450 closedir(dir);24512452 strbuf_setlen(path, original_len);2453 if (!ret && !keep_toplevel && !kept_down)2454 ret = (!rmdir(path->buf) || errno == ENOENT) ? 0 : -1;2455 else if (kept_up)2456 /*2457 * report the uplevel that it is not an error that we2458 * did not rmdir() our directory.2459 */2460 *kept_up = !ret;2461 return ret;2462}24632464int remove_dir_recursively(struct strbuf *path, int flag)2465{2466 return remove_dir_recurse(path, flag, NULL);2467}24682469static GIT_PATH_FUNC(git_path_info_exclude, "info/exclude")24702471void setup_standard_excludes(struct dir_struct *dir)2472{2473 dir->exclude_per_dir = ".gitignore";24742475 /* core.excludefile defaulting to $XDG_HOME/git/ignore */2476 if (!excludes_file)2477 excludes_file = xdg_config_home("ignore");2478 if (excludes_file && !access_or_warn(excludes_file, R_OK, 0))2479 add_excludes_from_file_1(dir, excludes_file,2480 dir->untracked ? &dir->ss_excludes_file : NULL);24812482 /* per repository user preference */2483 if (startup_info->have_repository) {2484 const char *path = git_path_info_exclude();2485 if (!access_or_warn(path, R_OK, 0))2486 add_excludes_from_file_1(dir, path,2487 dir->untracked ? &dir->ss_info_exclude : NULL);2488 }2489}24902491int remove_path(const char *name)2492{2493 char *slash;24942495 if (unlink(name) && !is_missing_file_error(errno))2496 return -1;24972498 slash = strrchr(name, '/');2499 if (slash) {2500 char *dirs = xstrdup(name);2501 slash = dirs + (slash - name);2502 do {2503 *slash = '\0';2504 } while (rmdir(dirs) == 0 && (slash = strrchr(dirs, '/')));2505 free(dirs);2506 }2507 return 0;2508}25092510/*2511 * Frees memory within dir which was allocated for exclude lists and2512 * the exclude_stack. Does not free dir itself.2513 */2514void clear_directory(struct dir_struct *dir)2515{2516 int i, j;2517 struct exclude_list_group *group;2518 struct exclude_list *el;2519 struct exclude_stack *stk;25202521 for (i = EXC_CMDL; i <= EXC_FILE; i++) {2522 group = &dir->exclude_list_group[i];2523 for (j = 0; j < group->nr; j++) {2524 el = &group->el[j];2525 if (i == EXC_DIRS)2526 free((char *)el->src);2527 clear_exclude_list(el);2528 }2529 free(group->el);2530 }25312532 stk = dir->exclude_stack;2533 while (stk) {2534 struct exclude_stack *prev = stk->prev;2535 free(stk);2536 stk = prev;2537 }2538 strbuf_release(&dir->basebuf);2539}25402541struct ondisk_untracked_cache {2542 struct stat_data info_exclude_stat;2543 struct stat_data excludes_file_stat;2544 uint32_t dir_flags;2545 unsigned char info_exclude_sha1[20];2546 unsigned char excludes_file_sha1[20];2547 char exclude_per_dir[FLEX_ARRAY];2548};25492550#define ouc_offset(x) offsetof(struct ondisk_untracked_cache, x)2551#define ouc_size(len) (ouc_offset(exclude_per_dir) + len + 1)25522553struct write_data {2554 int index; /* number of written untracked_cache_dir */2555 struct ewah_bitmap *check_only; /* from untracked_cache_dir */2556 struct ewah_bitmap *valid; /* from untracked_cache_dir */2557 struct ewah_bitmap *sha1_valid; /* set if exclude_sha1 is not null */2558 struct strbuf out;2559 struct strbuf sb_stat;2560 struct strbuf sb_sha1;2561};25622563static void stat_data_to_disk(struct stat_data *to, const struct stat_data *from)2564{2565 to->sd_ctime.sec = htonl(from->sd_ctime.sec);2566 to->sd_ctime.nsec = htonl(from->sd_ctime.nsec);2567 to->sd_mtime.sec = htonl(from->sd_mtime.sec);2568 to->sd_mtime.nsec = htonl(from->sd_mtime.nsec);2569 to->sd_dev = htonl(from->sd_dev);2570 to->sd_ino = htonl(from->sd_ino);2571 to->sd_uid = htonl(from->sd_uid);2572 to->sd_gid = htonl(from->sd_gid);2573 to->sd_size = htonl(from->sd_size);2574}25752576static void write_one_dir(struct untracked_cache_dir *untracked,2577 struct write_data *wd)2578{2579 struct stat_data stat_data;2580 struct strbuf *out = &wd->out;2581 unsigned char intbuf[16];2582 unsigned int intlen, value;2583 int i = wd->index++;25842585 /*2586 * untracked_nr should be reset whenever valid is clear, but2587 * for safety..2588 */2589 if (!untracked->valid) {2590 untracked->untracked_nr = 0;2591 untracked->check_only = 0;2592 }25932594 if (untracked->check_only)2595 ewah_set(wd->check_only, i);2596 if (untracked->valid) {2597 ewah_set(wd->valid, i);2598 stat_data_to_disk(&stat_data, &untracked->stat_data);2599 strbuf_add(&wd->sb_stat, &stat_data, sizeof(stat_data));2600 }2601 if (!is_null_sha1(untracked->exclude_sha1)) {2602 ewah_set(wd->sha1_valid, i);2603 strbuf_add(&wd->sb_sha1, untracked->exclude_sha1, 20);2604 }26052606 intlen = encode_varint(untracked->untracked_nr, intbuf);2607 strbuf_add(out, intbuf, intlen);26082609 /* skip non-recurse directories */2610 for (i = 0, value = 0; i < untracked->dirs_nr; i++)2611 if (untracked->dirs[i]->recurse)2612 value++;2613 intlen = encode_varint(value, intbuf);2614 strbuf_add(out, intbuf, intlen);26152616 strbuf_add(out, untracked->name, strlen(untracked->name) + 1);26172618 for (i = 0; i < untracked->untracked_nr; i++)2619 strbuf_add(out, untracked->untracked[i],2620 strlen(untracked->untracked[i]) + 1);26212622 for (i = 0; i < untracked->dirs_nr; i++)2623 if (untracked->dirs[i]->recurse)2624 write_one_dir(untracked->dirs[i], wd);2625}26262627void write_untracked_extension(struct strbuf *out, struct untracked_cache *untracked)2628{2629 struct ondisk_untracked_cache *ouc;2630 struct write_data wd;2631 unsigned char varbuf[16];2632 int varint_len;2633 size_t len = strlen(untracked->exclude_per_dir);26342635 FLEX_ALLOC_MEM(ouc, exclude_per_dir, untracked->exclude_per_dir, len);2636 stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);2637 stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);2638 hashcpy(ouc->info_exclude_sha1, untracked->ss_info_exclude.oid.hash);2639 hashcpy(ouc->excludes_file_sha1, untracked->ss_excludes_file.oid.hash);2640 ouc->dir_flags = htonl(untracked->dir_flags);26412642 varint_len = encode_varint(untracked->ident.len, varbuf);2643 strbuf_add(out, varbuf, varint_len);2644 strbuf_addbuf(out, &untracked->ident);26452646 strbuf_add(out, ouc, ouc_size(len));2647 FREE_AND_NULL(ouc);26482649 if (!untracked->root) {2650 varint_len = encode_varint(0, varbuf);2651 strbuf_add(out, varbuf, varint_len);2652 return;2653 }26542655 wd.index = 0;2656 wd.check_only = ewah_new();2657 wd.valid = ewah_new();2658 wd.sha1_valid = ewah_new();2659 strbuf_init(&wd.out, 1024);2660 strbuf_init(&wd.sb_stat, 1024);2661 strbuf_init(&wd.sb_sha1, 1024);2662 write_one_dir(untracked->root, &wd);26632664 varint_len = encode_varint(wd.index, varbuf);2665 strbuf_add(out, varbuf, varint_len);2666 strbuf_addbuf(out, &wd.out);2667 ewah_serialize_strbuf(wd.valid, out);2668 ewah_serialize_strbuf(wd.check_only, out);2669 ewah_serialize_strbuf(wd.sha1_valid, out);2670 strbuf_addbuf(out, &wd.sb_stat);2671 strbuf_addbuf(out, &wd.sb_sha1);2672 strbuf_addch(out, '\0'); /* safe guard for string lists */26732674 ewah_free(wd.valid);2675 ewah_free(wd.check_only);2676 ewah_free(wd.sha1_valid);2677 strbuf_release(&wd.out);2678 strbuf_release(&wd.sb_stat);2679 strbuf_release(&wd.sb_sha1);2680}26812682static void free_untracked(struct untracked_cache_dir *ucd)2683{2684 int i;2685 if (!ucd)2686 return;2687 for (i = 0; i < ucd->dirs_nr; i++)2688 free_untracked(ucd->dirs[i]);2689 for (i = 0; i < ucd->untracked_nr; i++)2690 free(ucd->untracked[i]);2691 free(ucd->untracked);2692 free(ucd->dirs);2693 free(ucd);2694}26952696void free_untracked_cache(struct untracked_cache *uc)2697{2698 if (uc)2699 free_untracked(uc->root);2700 free(uc);2701}27022703struct read_data {2704 int index;2705 struct untracked_cache_dir **ucd;2706 struct ewah_bitmap *check_only;2707 struct ewah_bitmap *valid;2708 struct ewah_bitmap *sha1_valid;2709 const unsigned char *data;2710 const unsigned char *end;2711};27122713static void stat_data_from_disk(struct stat_data *to, const unsigned char *data)2714{2715 memcpy(to, data, sizeof(*to));2716 to->sd_ctime.sec = ntohl(to->sd_ctime.sec);2717 to->sd_ctime.nsec = ntohl(to->sd_ctime.nsec);2718 to->sd_mtime.sec = ntohl(to->sd_mtime.sec);2719 to->sd_mtime.nsec = ntohl(to->sd_mtime.nsec);2720 to->sd_dev = ntohl(to->sd_dev);2721 to->sd_ino = ntohl(to->sd_ino);2722 to->sd_uid = ntohl(to->sd_uid);2723 to->sd_gid = ntohl(to->sd_gid);2724 to->sd_size = ntohl(to->sd_size);2725}27262727static int read_one_dir(struct untracked_cache_dir **untracked_,2728 struct read_data *rd)2729{2730 struct untracked_cache_dir ud, *untracked;2731 const unsigned char *next, *data = rd->data, *end = rd->end;2732 unsigned int value;2733 int i, len;27342735 memset(&ud, 0, sizeof(ud));27362737 next = data;2738 value = decode_varint(&next);2739 if (next > end)2740 return -1;2741 ud.recurse = 1;2742 ud.untracked_alloc = value;2743 ud.untracked_nr = value;2744 if (ud.untracked_nr)2745 ALLOC_ARRAY(ud.untracked, ud.untracked_nr);2746 data = next;27472748 next = data;2749 ud.dirs_alloc = ud.dirs_nr = decode_varint(&next);2750 if (next > end)2751 return -1;2752 ALLOC_ARRAY(ud.dirs, ud.dirs_nr);2753 data = next;27542755 len = strlen((const char *)data);2756 next = data + len + 1;2757 if (next > rd->end)2758 return -1;2759 *untracked_ = untracked = xmalloc(st_add(sizeof(*untracked), len));2760 memcpy(untracked, &ud, sizeof(ud));2761 memcpy(untracked->name, data, len + 1);2762 data = next;27632764 for (i = 0; i < untracked->untracked_nr; i++) {2765 len = strlen((const char *)data);2766 next = data + len + 1;2767 if (next > rd->end)2768 return -1;2769 untracked->untracked[i] = xstrdup((const char*)data);2770 data = next;2771 }27722773 rd->ucd[rd->index++] = untracked;2774 rd->data = data;27752776 for (i = 0; i < untracked->dirs_nr; i++) {2777 len = read_one_dir(untracked->dirs + i, rd);2778 if (len < 0)2779 return -1;2780 }2781 return 0;2782}27832784static void set_check_only(size_t pos, void *cb)2785{2786 struct read_data *rd = cb;2787 struct untracked_cache_dir *ud = rd->ucd[pos];2788 ud->check_only = 1;2789}27902791static void read_stat(size_t pos, void *cb)2792{2793 struct read_data *rd = cb;2794 struct untracked_cache_dir *ud = rd->ucd[pos];2795 if (rd->data + sizeof(struct stat_data) > rd->end) {2796 rd->data = rd->end + 1;2797 return;2798 }2799 stat_data_from_disk(&ud->stat_data, rd->data);2800 rd->data += sizeof(struct stat_data);2801 ud->valid = 1;2802}28032804static void read_sha1(size_t pos, void *cb)2805{2806 struct read_data *rd = cb;2807 struct untracked_cache_dir *ud = rd->ucd[pos];2808 if (rd->data + 20 > rd->end) {2809 rd->data = rd->end + 1;2810 return;2811 }2812 hashcpy(ud->exclude_sha1, rd->data);2813 rd->data += 20;2814}28152816static void load_oid_stat(struct oid_stat *oid_stat, const unsigned char *data,2817 const unsigned char *sha1)2818{2819 stat_data_from_disk(&oid_stat->stat, data);2820 hashcpy(oid_stat->oid.hash, sha1);2821 oid_stat->valid = 1;2822}28232824struct untracked_cache *read_untracked_extension(const void *data, unsigned long sz)2825{2826 struct untracked_cache *uc;2827 struct read_data rd;2828 const unsigned char *next = data, *end = (const unsigned char *)data + sz;2829 const char *ident;2830 int ident_len, len;2831 const char *exclude_per_dir;28322833 if (sz <= 1 || end[-1] != '\0')2834 return NULL;2835 end--;28362837 ident_len = decode_varint(&next);2838 if (next + ident_len > end)2839 return NULL;2840 ident = (const char *)next;2841 next += ident_len;28422843 if (next + ouc_size(0) > end)2844 return NULL;28452846 uc = xcalloc(1, sizeof(*uc));2847 strbuf_init(&uc->ident, ident_len);2848 strbuf_add(&uc->ident, ident, ident_len);2849 load_oid_stat(&uc->ss_info_exclude,2850 next + ouc_offset(info_exclude_stat),2851 next + ouc_offset(info_exclude_sha1));2852 load_oid_stat(&uc->ss_excludes_file,2853 next + ouc_offset(excludes_file_stat),2854 next + ouc_offset(excludes_file_sha1));2855 uc->dir_flags = get_be32(next + ouc_offset(dir_flags));2856 exclude_per_dir = (const char *)next + ouc_offset(exclude_per_dir);2857 uc->exclude_per_dir = xstrdup(exclude_per_dir);2858 /* NUL after exclude_per_dir is covered by sizeof(*ouc) */2859 next += ouc_size(strlen(exclude_per_dir));2860 if (next >= end)2861 goto done2;28622863 len = decode_varint(&next);2864 if (next > end || len == 0)2865 goto done2;28662867 rd.valid = ewah_new();2868 rd.check_only = ewah_new();2869 rd.sha1_valid = ewah_new();2870 rd.data = next;2871 rd.end = end;2872 rd.index = 0;2873 ALLOC_ARRAY(rd.ucd, len);28742875 if (read_one_dir(&uc->root, &rd) || rd.index != len)2876 goto done;28772878 next = rd.data;2879 len = ewah_read_mmap(rd.valid, next, end - next);2880 if (len < 0)2881 goto done;28822883 next += len;2884 len = ewah_read_mmap(rd.check_only, next, end - next);2885 if (len < 0)2886 goto done;28872888 next += len;2889 len = ewah_read_mmap(rd.sha1_valid, next, end - next);2890 if (len < 0)2891 goto done;28922893 ewah_each_bit(rd.check_only, set_check_only, &rd);2894 rd.data = next + len;2895 ewah_each_bit(rd.valid, read_stat, &rd);2896 ewah_each_bit(rd.sha1_valid, read_sha1, &rd);2897 next = rd.data;28982899done:2900 free(rd.ucd);2901 ewah_free(rd.valid);2902 ewah_free(rd.check_only);2903 ewah_free(rd.sha1_valid);2904done2:2905 if (next != end) {2906 free_untracked_cache(uc);2907 uc = NULL;2908 }2909 return uc;2910}29112912static void invalidate_one_directory(struct untracked_cache *uc,2913 struct untracked_cache_dir *ucd)2914{2915 uc->dir_invalidated++;2916 ucd->valid = 0;2917 ucd->untracked_nr = 0;2918}29192920/*2921 * Normally when an entry is added or removed from a directory,2922 * invalidating that directory is enough. No need to touch its2923 * ancestors. When a directory is shown as "foo/bar/" in git-status2924 * however, deleting or adding an entry may have cascading effect.2925 *2926 * Say the "foo/bar/file" has become untracked, we need to tell the2927 * untracked_cache_dir of "foo" that "bar/" is not an untracked2928 * directory any more (because "bar" is managed by foo as an untracked2929 * "file").2930 *2931 * Similarly, if "foo/bar/file" moves from untracked to tracked and it2932 * was the last untracked entry in the entire "foo", we should show2933 * "foo/" instead. Which means we have to invalidate past "bar" up to2934 * "foo".2935 *2936 * This function traverses all directories from root to leaf. If there2937 * is a chance of one of the above cases happening, we invalidate back2938 * to root. Otherwise we just invalidate the leaf. There may be a more2939 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to2940 * detect these cases and avoid unnecessary invalidation, for example,2941 * checking for the untracked entry named "bar/" in "foo", but for now2942 * stick to something safe and simple.2943 */2944static int invalidate_one_component(struct untracked_cache *uc,2945 struct untracked_cache_dir *dir,2946 const char *path, int len)2947{2948 const char *rest = strchr(path, '/');29492950 if (rest) {2951 int component_len = rest - path;2952 struct untracked_cache_dir *d =2953 lookup_untracked(uc, dir, path, component_len);2954 int ret =2955 invalidate_one_component(uc, d, rest + 1,2956 len - (component_len + 1));2957 if (ret)2958 invalidate_one_directory(uc, dir);2959 return ret;2960 }29612962 invalidate_one_directory(uc, dir);2963 return uc->dir_flags & DIR_SHOW_OTHER_DIRECTORIES;2964}29652966void untracked_cache_invalidate_path(struct index_state *istate,2967 const char *path)2968{2969 if (!istate->untracked || !istate->untracked->root)2970 return;2971 invalidate_one_component(istate->untracked, istate->untracked->root,2972 path, strlen(path));2973}29742975void untracked_cache_remove_from_index(struct index_state *istate,2976 const char *path)2977{2978 untracked_cache_invalidate_path(istate, path);2979}29802981void untracked_cache_add_to_index(struct index_state *istate,2982 const char *path)2983{2984 untracked_cache_invalidate_path(istate, path);2985}29862987/* Update gitfile and core.worktree setting to connect work tree and git dir */2988void connect_work_tree_and_git_dir(const char *work_tree_, const char *git_dir_)2989{2990 struct strbuf gitfile_sb = STRBUF_INIT;2991 struct strbuf cfg_sb = STRBUF_INIT;2992 struct strbuf rel_path = STRBUF_INIT;2993 char *git_dir, *work_tree;29942995 /* Prepare .git file */2996 strbuf_addf(&gitfile_sb, "%s/.git", work_tree_);2997 if (safe_create_leading_directories_const(gitfile_sb.buf))2998 die(_("could not create directories for %s"), gitfile_sb.buf);29993000 /* Prepare config file */3001 strbuf_addf(&cfg_sb, "%s/config", git_dir_);3002 if (safe_create_leading_directories_const(cfg_sb.buf))3003 die(_("could not create directories for %s"), cfg_sb.buf);30043005 git_dir = real_pathdup(git_dir_, 1);3006 work_tree = real_pathdup(work_tree_, 1);30073008 /* Write .git file */3009 write_file(gitfile_sb.buf, "gitdir: %s",3010 relative_path(git_dir, work_tree, &rel_path));3011 /* Update core.worktree setting */3012 git_config_set_in_file(cfg_sb.buf, "core.worktree",3013 relative_path(work_tree, git_dir, &rel_path));30143015 strbuf_release(&gitfile_sb);3016 strbuf_release(&cfg_sb);3017 strbuf_release(&rel_path);3018 free(work_tree);3019 free(git_dir);3020}30213022/*3023 * Migrate the git directory of the given path from old_git_dir to new_git_dir.3024 */3025void relocate_gitdir(const char *path, const char *old_git_dir, const char *new_git_dir)3026{3027 if (rename(old_git_dir, new_git_dir) < 0)3028 die_errno(_("could not migrate git directory from '%s' to '%s'"),3029 old_git_dir, new_git_dir);30303031 connect_work_tree_and_git_dir(path, new_git_dir);3032}