2 * This handles recursive filename detection with exclude
3 * files, index knowledge etc..
5 * Copyright (C) Linus Torvalds, 2005-2006
6 * Junio Hamano, 2005-2006
11 #include "object-store.h"
14 #include "wildmatch.h"
18 #include "ewah/ewok.h"
19 #include "fsmonitor.h"
20 #include "submodule-config.h"
23 * Tells read_directory_recursive how a file or directory should be treated.
24 * Values are ordered by significance, e.g. if a directory contains both
25 * excluded and untracked files, it is listed as untracked because
26 * path_untracked > path_excluded.
36 * Support data structure for our opendir/readdir/closedir wrappers
40 struct untracked_cache_dir
*untracked
;
47 struct untracked_cache_dir
*ucd
;
50 static 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
);
54 static int resolve_dtype(int dtype
, struct index_state
*istate
,
55 const char *path
, int len
);
57 int count_slashes(const char *s
)
66 int fspathcmp(const char *a
, const char *b
)
68 return ignore_case
? strcasecmp(a
, b
) : strcmp(a
, b
);
71 int fspathncmp(const char *a
, const char *b
, size_t count
)
73 return ignore_case
? strncasecmp(a
, b
, count
) : strncmp(a
, b
, count
);
76 int git_fnmatch(const struct pathspec_item
*item
,
77 const char *pattern
, const char *string
,
81 if (ps_strncmp(item
, pattern
, string
, prefix
))
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
);
93 if (item
->magic
& PATHSPEC_GLOB
)
94 return wildmatch(pattern
, string
,
96 (item
->magic
& PATHSPEC_ICASE
? WM_CASEFOLD
: 0));
98 /* wildmatch has not learned no FNM_PATHNAME mode yet */
99 return wildmatch(pattern
, string
,
100 item
->magic
& PATHSPEC_ICASE
? WM_CASEFOLD
: 0);
103 static int fnmatch_icase_mem(const char *pattern
, int patternlen
,
104 const char *string
, int stringlen
,
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
;
113 if (pattern
[patternlen
]) {
114 strbuf_add(&pat_buf
, pattern
, patternlen
);
115 use_pat
= pat_buf
.buf
;
117 if (string
[stringlen
]) {
118 strbuf_add(&str_buf
, string
, stringlen
);
119 use_str
= str_buf
.buf
;
123 flags
|= WM_CASEFOLD
;
124 match_status
= wildmatch(use_pat
, use_str
, flags
);
126 strbuf_release(&pat_buf
);
127 strbuf_release(&str_buf
);
132 static size_t common_prefix_len(const struct pathspec
*pathspec
)
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 xyz/abc as
144 GUARD_PATHSPEC(pathspec
,
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
)
157 if (pathspec
->items
[n
].magic
& PATHSPEC_ICASE
)
158 item_len
= pathspec
->items
[n
].prefix
;
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
])
169 if (n
== 0 || len
< max
) {
179 * Returns a copy of the longest leading path common among all
182 char *common_prefix(const struct pathspec
*pathspec
)
184 unsigned long len
= common_prefix_len(pathspec
);
186 return len
? xmemdupz(pathspec
->items
[0].match
, len
) : NULL
;
189 int fill_directory(struct dir_struct
*dir
,
190 struct index_state
*istate
,
191 const struct pathspec
*pathspec
)
196 unsigned exclusive_flags
= DIR_SHOW_IGNORED
| DIR_SHOW_IGNORED_TOO
;
197 if ((dir
->flags
& exclusive_flags
) == exclusive_flags
)
198 BUG("DIR_SHOW_IGNORED and DIR_SHOW_IGNORED_TOO are exclusive");
201 * Calculate common prefix for the pathspec, and
202 * use that to optimize the directory walk
204 prefix_len
= common_prefix_len(pathspec
);
205 prefix
= prefix_len
? pathspec
->items
[0].match
: "";
207 /* Read the directory and prune it */
208 read_directory(dir
, istate
, prefix
, prefix_len
, pathspec
);
213 int within_depth(const char *name
, int namelen
,
214 int depth
, int max_depth
)
216 const char *cp
= name
, *cpe
= name
+ namelen
;
222 if (depth
> max_depth
)
229 * Read the contents of the blob with the given OID into a buffer.
230 * Append a trailing LF to the end if the last line doesn't have one.
233 * -1 when the OID is invalid or unknown or does not refer to a blob.
234 * 0 when the blob is empty.
235 * 1 along with { data, size } of the (possibly augmented) buffer
238 * Optionally updates the given oid_stat with the given OID (when valid).
240 static int do_read_blob(const struct object_id
*oid
, struct oid_stat
*oid_stat
,
241 size_t *size_out
, char **data_out
)
243 enum object_type type
;
250 data
= read_object_file(oid
, &type
, &sz
);
251 if (!data
|| type
!= OBJ_BLOB
) {
257 memset(&oid_stat
->stat
, 0, sizeof(oid_stat
->stat
));
258 oidcpy(&oid_stat
->oid
, oid
);
266 if (data
[sz
- 1] != '\n') {
267 data
= xrealloc(data
, st_add(sz
, 1));
271 *size_out
= xsize_t(sz
);
277 #define DO_MATCH_EXCLUDE (1<<0)
278 #define DO_MATCH_DIRECTORY (1<<1)
279 #define DO_MATCH_LEADING_PATHSPEC (1<<2)
282 * Does the given pathspec match the given name? A match is found if
284 * (1) the pathspec string is leading directory of 'name' ("RECURSIVELY"), or
285 * (2) the pathspec string has a leading part matching 'name' ("LEADING"), or
286 * (3) the pathspec string is a wildcard and matches 'name' ("WILDCARD"), or
287 * (4) the pathspec string is exactly the same as 'name' ("EXACT").
289 * Return value tells which case it was (1-4), or 0 when there is no match.
291 * It may be instructive to look at a small table of concrete examples
292 * to understand the differences between 1, 2, and 4:
295 * | a/b | a/b/ | a/b/c
296 * ------+-----------+-----------+------------
297 * a/b | EXACT | EXACT[1] | LEADING[2]
298 * Names a/b/ | RECURSIVE | EXACT | LEADING[2]
299 * a/b/c | RECURSIVE | RECURSIVE | EXACT
301 * [1] Only if DO_MATCH_DIRECTORY is passed; otherwise, this is NOT a match.
302 * [2] Only if DO_MATCH_LEADING_PATHSPEC is passed; otherwise, not a match.
304 static int match_pathspec_item(const struct index_state
*istate
,
305 const struct pathspec_item
*item
, int prefix
,
306 const char *name
, int namelen
, unsigned flags
)
308 /* name/namelen has prefix cut off by caller */
309 const char *match
= item
->match
+ prefix
;
310 int matchlen
= item
->len
- prefix
;
313 * The normal call pattern is:
314 * 1. prefix = common_prefix_len(ps);
315 * 2. prune something, or fill_directory
316 * 3. match_pathspec()
318 * 'prefix' at #1 may be shorter than the command's prefix and
319 * it's ok for #2 to match extra files. Those extras will be
322 * Suppose the pathspec is 'foo' and '../bar' running from
323 * subdir 'xyz'. The common prefix at #1 will be empty, thanks
324 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The
325 * user does not want XYZ/foo, only the "foo" part should be
326 * case-insensitive. We need to filter out XYZ/foo here. In
327 * other words, we do not trust the caller on comparing the
328 * prefix part when :(icase) is involved. We do exact
329 * comparison ourselves.
331 * Normally the caller (common_prefix_len() in fact) does
332 * _exact_ matching on name[-prefix+1..-1] and we do not need
333 * to check that part. Be defensive and check it anyway, in
334 * case common_prefix_len is changed, or a new caller is
335 * introduced that does not use common_prefix_len.
337 * If the penalty turns out too high when prefix is really
338 * long, maybe change it to
339 * strncmp(match, name, item->prefix - prefix)
341 if (item
->prefix
&& (item
->magic
& PATHSPEC_ICASE
) &&
342 strncmp(item
->match
, name
- prefix
, item
->prefix
))
345 if (item
->attr_match_nr
&&
346 !match_pathspec_attrs(istate
, name
, namelen
, item
))
349 /* If the match was just the prefix, we matched */
351 return MATCHED_RECURSIVELY
;
353 if (matchlen
<= namelen
&& !ps_strncmp(item
, match
, name
, matchlen
)) {
354 if (matchlen
== namelen
)
355 return MATCHED_EXACTLY
;
357 if (match
[matchlen
-1] == '/' || name
[matchlen
] == '/')
358 return MATCHED_RECURSIVELY
;
359 } else if ((flags
& DO_MATCH_DIRECTORY
) &&
360 match
[matchlen
- 1] == '/' &&
361 namelen
== matchlen
- 1 &&
362 !ps_strncmp(item
, match
, name
, namelen
))
363 return MATCHED_EXACTLY
;
365 if (item
->nowildcard_len
< item
->len
&&
366 !git_fnmatch(item
, match
, name
,
367 item
->nowildcard_len
- prefix
))
368 return MATCHED_FNMATCH
;
370 /* Perform checks to see if "name" is a leading string of the pathspec */
371 if ( (flags
& DO_MATCH_LEADING_PATHSPEC
) &&
372 !(flags
& DO_MATCH_EXCLUDE
)) {
373 /* name is a literal prefix of the pathspec */
374 int offset
= name
[namelen
-1] == '/' ? 1 : 0;
375 if ((namelen
< matchlen
) &&
376 (match
[namelen
-offset
] == '/') &&
377 !ps_strncmp(item
, match
, name
, namelen
))
378 return MATCHED_RECURSIVELY_LEADING_PATHSPEC
;
380 /* name doesn't match up to the first wild character */
381 if (item
->nowildcard_len
< item
->len
&&
382 ps_strncmp(item
, match
, name
,
383 item
->nowildcard_len
- prefix
))
387 * name has no wildcard, and it didn't match as a leading
388 * pathspec so return.
390 if (item
->nowildcard_len
== item
->len
)
394 * Here is where we would perform a wildmatch to check if
395 * "name" can be matched as a directory (or a prefix) against
396 * the pathspec. Since wildmatch doesn't have this capability
397 * at the present we have to punt and say that it is a match,
398 * potentially returning a false positive
399 * The submodules themselves will be able to perform more
400 * accurate matching to determine if the pathspec matches.
402 return MATCHED_RECURSIVELY_LEADING_PATHSPEC
;
409 * do_match_pathspec() is meant to ONLY be called by
410 * match_pathspec_with_flags(); calling it directly risks pathspecs
411 * like ':!unwanted_path' being ignored.
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
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.
427 static int do_match_pathspec(const struct index_state
*istate
,
428 const struct pathspec
*ps
,
429 const char *name
, int namelen
,
430 int prefix
, char *seen
,
433 int i
, retval
= 0, exclude
= flags
& DO_MATCH_EXCLUDE
;
445 if (!ps
->recursive
||
446 !(ps
->magic
& PATHSPEC_MAXDEPTH
) ||
448 return MATCHED_RECURSIVELY
;
450 if (within_depth(name
, namelen
, 0, ps
->max_depth
))
451 return MATCHED_EXACTLY
;
459 for (i
= ps
->nr
- 1; i
>= 0; i
--) {
462 if ((!exclude
&& ps
->items
[i
].magic
& PATHSPEC_EXCLUDE
) ||
463 ( exclude
&& !(ps
->items
[i
].magic
& PATHSPEC_EXCLUDE
)))
466 if (seen
&& seen
[i
] == MATCHED_EXACTLY
)
469 * Make exclude patterns optional and never report
470 * "pathspec ':(exclude)foo' matches no files"
472 if (seen
&& ps
->items
[i
].magic
& PATHSPEC_EXCLUDE
)
473 seen
[i
] = MATCHED_FNMATCH
;
474 how
= match_pathspec_item(istate
, ps
->items
+i
, prefix
, name
,
477 (ps
->magic
& PATHSPEC_MAXDEPTH
) &&
478 ps
->max_depth
!= -1 &&
479 how
&& how
!= MATCHED_FNMATCH
) {
480 int len
= ps
->items
[i
].len
;
481 if (name
[len
] == '/')
483 if (within_depth(name
+len
, namelen
-len
, 0, ps
->max_depth
))
484 how
= MATCHED_EXACTLY
;
491 if (seen
&& seen
[i
] < how
)
498 static int match_pathspec_with_flags(const struct index_state
*istate
,
499 const struct pathspec
*ps
,
500 const char *name
, int namelen
,
501 int prefix
, char *seen
, unsigned flags
)
503 int positive
, negative
;
504 positive
= do_match_pathspec(istate
, ps
, name
, namelen
,
505 prefix
, seen
, flags
);
506 if (!(ps
->magic
& PATHSPEC_EXCLUDE
) || !positive
)
508 negative
= do_match_pathspec(istate
, ps
, name
, namelen
,
510 flags
| DO_MATCH_EXCLUDE
);
511 return negative
? 0 : positive
;
514 int match_pathspec(const struct index_state
*istate
,
515 const struct pathspec
*ps
,
516 const char *name
, int namelen
,
517 int prefix
, char *seen
, int is_dir
)
519 unsigned flags
= is_dir
? DO_MATCH_DIRECTORY
: 0;
520 return match_pathspec_with_flags(istate
, ps
, name
, namelen
,
521 prefix
, seen
, flags
);
525 * Check if a submodule is a superset of the pathspec
527 int submodule_path_match(const struct index_state
*istate
,
528 const struct pathspec
*ps
,
529 const char *submodule_name
,
532 int matched
= match_pathspec_with_flags(istate
, ps
, submodule_name
,
533 strlen(submodule_name
),
536 DO_MATCH_LEADING_PATHSPEC
);
540 int report_path_error(const char *ps_matched
,
541 const struct pathspec
*pathspec
)
544 * Make sure all pathspec matched; otherwise it is an error.
547 for (num
= 0; num
< pathspec
->nr
; num
++) {
548 int other
, found_dup
;
553 * The caller might have fed identical pathspec
554 * twice. Do not barf on such a mistake.
555 * FIXME: parse_pathspec should have eliminated
556 * duplicate pathspec.
558 for (found_dup
= other
= 0;
559 !found_dup
&& other
< pathspec
->nr
;
561 if (other
== num
|| !ps_matched
[other
])
563 if (!strcmp(pathspec
->items
[other
].original
,
564 pathspec
->items
[num
].original
))
566 * Ok, we have a match already.
573 error(_("pathspec '%s' did not match any file(s) known to git"),
574 pathspec
->items
[num
].original
);
581 * Return the length of the "simple" part of a path match limiter.
583 int simple_length(const char *match
)
588 unsigned char c
= *match
++;
590 if (c
== '\0' || is_glob_special(c
))
595 int no_wildcard(const char *string
)
597 return string
[simple_length(string
)] == '\0';
600 void parse_path_pattern(const char **pattern
,
605 const char *p
= *pattern
;
610 *flags
|= PATTERN_FLAG_NEGATIVE
;
614 if (len
&& p
[len
- 1] == '/') {
616 *flags
|= PATTERN_FLAG_MUSTBEDIR
;
618 for (i
= 0; i
< len
; i
++) {
623 *flags
|= PATTERN_FLAG_NODIR
;
624 *nowildcardlen
= simple_length(p
);
626 * we should have excluded the trailing slash from 'p' too,
627 * but that's one more allocation. Instead just make sure
628 * nowildcardlen does not exceed real patternlen
630 if (*nowildcardlen
> len
)
631 *nowildcardlen
= len
;
632 if (*p
== '*' && no_wildcard(p
+ 1))
633 *flags
|= PATTERN_FLAG_ENDSWITH
;
638 int pl_hashmap_cmp(const void *unused_cmp_data
,
639 const struct hashmap_entry
*a
,
640 const struct hashmap_entry
*b
,
643 const struct pattern_entry
*ee1
=
644 container_of(a
, struct pattern_entry
, ent
);
645 const struct pattern_entry
*ee2
=
646 container_of(b
, struct pattern_entry
, ent
);
648 size_t min_len
= ee1
->patternlen
<= ee2
->patternlen
653 return strncasecmp(ee1
->pattern
, ee2
->pattern
, min_len
);
654 return strncmp(ee1
->pattern
, ee2
->pattern
, min_len
);
657 static char *dup_and_filter_pattern(const char *pattern
)
661 char *result
= xstrdup(pattern
);
667 /* skip escape characters (once) */
687 static void add_pattern_to_hashsets(struct pattern_list
*pl
, struct path_pattern
*given
)
689 struct pattern_entry
*translated
;
692 const char *prev
, *cur
, *next
;
694 if (!pl
->use_cone_patterns
)
697 if (given
->flags
& PATTERN_FLAG_NEGATIVE
&&
698 given
->flags
& PATTERN_FLAG_MUSTBEDIR
&&
699 !strcmp(given
->pattern
, "/*")) {
704 if (!given
->flags
&& !strcmp(given
->pattern
, "/*")) {
709 if (given
->patternlen
< 2 ||
710 *given
->pattern
== '*' ||
711 strstr(given
->pattern
, "**")) {
712 /* Not a cone pattern. */
713 warning(_("unrecognized pattern: '%s'"), given
->pattern
);
717 prev
= given
->pattern
;
718 cur
= given
->pattern
+ 1;
719 next
= given
->pattern
+ 2;
722 /* Watch for glob characters '*', '\', '[', '?' */
723 if (!is_glob_special(*cur
))
726 /* But only if *prev != '\\' */
730 /* But allow the initial '\' */
732 is_glob_special(*next
))
735 /* But a trailing '/' then '*' is fine */
741 /* Not a cone pattern. */
742 warning(_("unrecognized pattern: '%s'"), given
->pattern
);
751 if (given
->patternlen
> 2 &&
752 !strcmp(given
->pattern
+ given
->patternlen
- 2, "/*")) {
753 if (!(given
->flags
& PATTERN_FLAG_NEGATIVE
)) {
754 /* Not a cone pattern. */
755 warning(_("unrecognized pattern: '%s'"), given
->pattern
);
759 truncated
= dup_and_filter_pattern(given
->pattern
);
761 translated
= xmalloc(sizeof(struct pattern_entry
));
762 translated
->pattern
= truncated
;
763 translated
->patternlen
= given
->patternlen
- 2;
764 hashmap_entry_init(&translated
->ent
,
766 strihash(translated
->pattern
) :
767 strhash(translated
->pattern
));
769 if (!hashmap_get_entry(&pl
->recursive_hashmap
,
770 translated
, ent
, NULL
)) {
771 /* We did not see the "parent" included */
772 warning(_("unrecognized negative pattern: '%s'"),
779 hashmap_add(&pl
->parent_hashmap
, &translated
->ent
);
780 hashmap_remove(&pl
->recursive_hashmap
, &translated
->ent
, &data
);
785 if (given
->flags
& PATTERN_FLAG_NEGATIVE
) {
786 warning(_("unrecognized negative pattern: '%s'"),
791 translated
= xmalloc(sizeof(struct pattern_entry
));
793 translated
->pattern
= dup_and_filter_pattern(given
->pattern
);
794 translated
->patternlen
= given
->patternlen
;
795 hashmap_entry_init(&translated
->ent
,
797 strihash(translated
->pattern
) :
798 strhash(translated
->pattern
));
800 hashmap_add(&pl
->recursive_hashmap
, &translated
->ent
);
802 if (hashmap_get_entry(&pl
->parent_hashmap
, translated
, ent
, NULL
)) {
803 /* we already included this at the parent level */
804 warning(_("your sparse-checkout file may have issues: pattern '%s' is repeated"),
806 hashmap_remove(&pl
->parent_hashmap
, &translated
->ent
, &data
);
814 warning(_("disabling cone pattern matching"));
815 hashmap_free_entries(&pl
->parent_hashmap
, struct pattern_entry
, ent
);
816 hashmap_free_entries(&pl
->recursive_hashmap
, struct pattern_entry
, ent
);
817 pl
->use_cone_patterns
= 0;
820 static int hashmap_contains_path(struct hashmap
*map
,
821 struct strbuf
*pattern
)
823 struct pattern_entry p
;
825 /* Check straight mapping */
826 p
.pattern
= pattern
->buf
;
827 p
.patternlen
= pattern
->len
;
828 hashmap_entry_init(&p
.ent
,
830 strihash(p
.pattern
) :
832 return !!hashmap_get_entry(map
, &p
, ent
, NULL
);
835 int hashmap_contains_parent(struct hashmap
*map
,
837 struct strbuf
*buffer
)
841 strbuf_setlen(buffer
, 0);
844 strbuf_addch(buffer
, '/');
846 strbuf_addstr(buffer
, path
);
848 slash_pos
= strrchr(buffer
->buf
, '/');
850 while (slash_pos
> buffer
->buf
) {
851 strbuf_setlen(buffer
, slash_pos
- buffer
->buf
);
853 if (hashmap_contains_path(map
, buffer
))
856 slash_pos
= strrchr(buffer
->buf
, '/');
862 void add_pattern(const char *string
, const char *base
,
863 int baselen
, struct pattern_list
*pl
, int srcpos
)
865 struct path_pattern
*pattern
;
870 parse_path_pattern(&string
, &patternlen
, &flags
, &nowildcardlen
);
871 if (flags
& PATTERN_FLAG_MUSTBEDIR
) {
872 FLEXPTR_ALLOC_MEM(pattern
, pattern
, string
, patternlen
);
874 pattern
= xmalloc(sizeof(*pattern
));
875 pattern
->pattern
= string
;
877 pattern
->patternlen
= patternlen
;
878 pattern
->nowildcardlen
= nowildcardlen
;
879 pattern
->base
= base
;
880 pattern
->baselen
= baselen
;
881 pattern
->flags
= flags
;
882 pattern
->srcpos
= srcpos
;
883 ALLOC_GROW(pl
->patterns
, pl
->nr
+ 1, pl
->alloc
);
884 pl
->patterns
[pl
->nr
++] = pattern
;
887 add_pattern_to_hashsets(pl
, pattern
);
890 static int read_skip_worktree_file_from_index(const struct index_state
*istate
,
892 size_t *size_out
, char **data_out
,
893 struct oid_stat
*oid_stat
)
898 pos
= index_name_pos(istate
, path
, len
);
901 if (!ce_skip_worktree(istate
->cache
[pos
]))
904 return do_read_blob(&istate
->cache
[pos
]->oid
, oid_stat
, size_out
, data_out
);
908 * Frees memory within pl which was allocated for exclude patterns and
909 * the file buffer. Does not free pl itself.
911 void clear_pattern_list(struct pattern_list
*pl
)
915 for (i
= 0; i
< pl
->nr
; i
++)
916 free(pl
->patterns
[i
]);
919 hashmap_free_entries(&pl
->recursive_hashmap
, struct pattern_entry
, ent
);
920 hashmap_free_entries(&pl
->parent_hashmap
, struct pattern_entry
, ent
);
922 memset(pl
, 0, sizeof(*pl
));
925 static void trim_trailing_spaces(char *buf
)
927 char *p
, *last_space
= NULL
;
929 for (p
= buf
; *p
; p
++)
949 * Given a subdirectory name and "dir" of the current directory,
950 * search the subdir in "dir" and return it, or create a new one if it
951 * does not exist in "dir".
953 * If "name" has the trailing slash, it'll be excluded in the search.
955 static struct untracked_cache_dir
*lookup_untracked(struct untracked_cache
*uc
,
956 struct untracked_cache_dir
*dir
,
957 const char *name
, int len
)
960 struct untracked_cache_dir
*d
;
963 if (len
&& name
[len
- 1] == '/')
967 while (last
> first
) {
968 int cmp
, next
= first
+ ((last
- first
) >> 1);
970 cmp
= strncmp(name
, d
->name
, len
);
971 if (!cmp
&& strlen(d
->name
) > len
)
983 FLEX_ALLOC_MEM(d
, name
, name
, len
);
985 ALLOC_GROW(dir
->dirs
, dir
->dirs_nr
+ 1, dir
->dirs_alloc
);
986 MOVE_ARRAY(dir
->dirs
+ first
+ 1, dir
->dirs
+ first
,
987 dir
->dirs_nr
- first
);
989 dir
->dirs
[first
] = d
;
993 static void do_invalidate_gitignore(struct untracked_cache_dir
*dir
)
997 dir
->untracked_nr
= 0;
998 for (i
= 0; i
< dir
->dirs_nr
; i
++)
999 do_invalidate_gitignore(dir
->dirs
[i
]);
1002 static void invalidate_gitignore(struct untracked_cache
*uc
,
1003 struct untracked_cache_dir
*dir
)
1005 uc
->gitignore_invalidated
++;
1006 do_invalidate_gitignore(dir
);
1009 static void invalidate_directory(struct untracked_cache
*uc
,
1010 struct untracked_cache_dir
*dir
)
1015 * Invalidation increment here is just roughly correct. If
1016 * untracked_nr or any of dirs[].recurse is non-zero, we
1017 * should increment dir_invalidated too. But that's more
1021 uc
->dir_invalidated
++;
1024 dir
->untracked_nr
= 0;
1025 for (i
= 0; i
< dir
->dirs_nr
; i
++)
1026 dir
->dirs
[i
]->recurse
= 0;
1029 static int add_patterns_from_buffer(char *buf
, size_t size
,
1030 const char *base
, int baselen
,
1031 struct pattern_list
*pl
);
1034 * Given a file with name "fname", read it (either from disk, or from
1035 * an index if 'istate' is non-null), parse it and store the
1036 * exclude rules in "pl".
1038 * If "ss" is not NULL, compute SHA-1 of the exclude file and fill
1039 * stat data from disk (only valid if add_patterns returns zero). If
1040 * ss_valid is non-zero, "ss" must contain good value as input.
1042 static int add_patterns(const char *fname
, const char *base
, int baselen
,
1043 struct pattern_list
*pl
, struct index_state
*istate
,
1044 struct oid_stat
*oid_stat
)
1052 fd
= open(fname
, O_RDONLY
);
1053 if (fd
< 0 || fstat(fd
, &st
) < 0) {
1055 warn_on_fopen_errors(fname
);
1060 r
= read_skip_worktree_file_from_index(istate
, fname
,
1066 size
= xsize_t(st
.st_size
);
1069 fill_stat_data(&oid_stat
->stat
, &st
);
1070 oidcpy(&oid_stat
->oid
, the_hash_algo
->empty_blob
);
1071 oid_stat
->valid
= 1;
1076 buf
= xmallocz(size
);
1077 if (read_in_full(fd
, buf
, size
) != size
) {
1086 if (oid_stat
->valid
&&
1087 !match_stat_data_racy(istate
, &oid_stat
->stat
, &st
))
1088 ; /* no content change, ss->sha1 still good */
1090 (pos
= index_name_pos(istate
, fname
, strlen(fname
))) >= 0 &&
1091 !ce_stage(istate
->cache
[pos
]) &&
1092 ce_uptodate(istate
->cache
[pos
]) &&
1093 !would_convert_to_git(istate
, fname
))
1094 oidcpy(&oid_stat
->oid
,
1095 &istate
->cache
[pos
]->oid
);
1097 hash_object_file(the_hash_algo
, buf
, size
,
1098 "blob", &oid_stat
->oid
);
1099 fill_stat_data(&oid_stat
->stat
, &st
);
1100 oid_stat
->valid
= 1;
1104 add_patterns_from_buffer(buf
, size
, base
, baselen
, pl
);
1108 static int add_patterns_from_buffer(char *buf
, size_t size
,
1109 const char *base
, int baselen
,
1110 struct pattern_list
*pl
)
1115 hashmap_init(&pl
->recursive_hashmap
, pl_hashmap_cmp
, NULL
, 0);
1116 hashmap_init(&pl
->parent_hashmap
, pl_hashmap_cmp
, NULL
, 0);
1120 if (skip_utf8_bom(&buf
, size
))
1121 size
-= buf
- pl
->filebuf
;
1125 for (i
= 0; i
< size
; i
++) {
1126 if (buf
[i
] == '\n') {
1127 if (entry
!= buf
+ i
&& entry
[0] != '#') {
1128 buf
[i
- (i
&& buf
[i
-1] == '\r')] = 0;
1129 trim_trailing_spaces(entry
);
1130 add_pattern(entry
, base
, baselen
, pl
, lineno
);
1133 entry
= buf
+ i
+ 1;
1139 int add_patterns_from_file_to_list(const char *fname
, const char *base
,
1140 int baselen
, struct pattern_list
*pl
,
1141 struct index_state
*istate
)
1143 return add_patterns(fname
, base
, baselen
, pl
, istate
, NULL
);
1146 int add_patterns_from_blob_to_list(
1147 struct object_id
*oid
,
1148 const char *base
, int baselen
,
1149 struct pattern_list
*pl
)
1155 r
= do_read_blob(oid
, NULL
, &size
, &buf
);
1159 add_patterns_from_buffer(buf
, size
, base
, baselen
, pl
);
1163 struct pattern_list
*add_pattern_list(struct dir_struct
*dir
,
1164 int group_type
, const char *src
)
1166 struct pattern_list
*pl
;
1167 struct exclude_list_group
*group
;
1169 group
= &dir
->exclude_list_group
[group_type
];
1170 ALLOC_GROW(group
->pl
, group
->nr
+ 1, group
->alloc
);
1171 pl
= &group
->pl
[group
->nr
++];
1172 memset(pl
, 0, sizeof(*pl
));
1178 * Used to set up core.excludesfile and .git/info/exclude lists.
1180 static void add_patterns_from_file_1(struct dir_struct
*dir
, const char *fname
,
1181 struct oid_stat
*oid_stat
)
1183 struct pattern_list
*pl
;
1185 * catch setup_standard_excludes() that's called before
1186 * dir->untracked is assigned. That function behaves
1187 * differently when dir->untracked is non-NULL.
1189 if (!dir
->untracked
)
1190 dir
->unmanaged_exclude_files
++;
1191 pl
= add_pattern_list(dir
, EXC_FILE
, fname
);
1192 if (add_patterns(fname
, "", 0, pl
, NULL
, oid_stat
) < 0)
1193 die(_("cannot use %s as an exclude file"), fname
);
1196 void add_patterns_from_file(struct dir_struct
*dir
, const char *fname
)
1198 dir
->unmanaged_exclude_files
++; /* see validate_untracked_cache() */
1199 add_patterns_from_file_1(dir
, fname
, NULL
);
1202 int match_basename(const char *basename
, int basenamelen
,
1203 const char *pattern
, int prefix
, int patternlen
,
1206 if (prefix
== patternlen
) {
1207 if (patternlen
== basenamelen
&&
1208 !fspathncmp(pattern
, basename
, basenamelen
))
1210 } else if (flags
& PATTERN_FLAG_ENDSWITH
) {
1211 /* "*literal" matching against "fooliteral" */
1212 if (patternlen
- 1 <= basenamelen
&&
1213 !fspathncmp(pattern
+ 1,
1214 basename
+ basenamelen
- (patternlen
- 1),
1218 if (fnmatch_icase_mem(pattern
, patternlen
,
1219 basename
, basenamelen
,
1226 int match_pathname(const char *pathname
, int pathlen
,
1227 const char *base
, int baselen
,
1228 const char *pattern
, int prefix
, int patternlen
,
1235 * match with FNM_PATHNAME; the pattern has base implicitly
1238 if (*pattern
== '/') {
1245 * baselen does not count the trailing slash. base[] may or
1246 * may not end with a trailing slash though.
1248 if (pathlen
< baselen
+ 1 ||
1249 (baselen
&& pathname
[baselen
] != '/') ||
1250 fspathncmp(pathname
, base
, baselen
))
1253 namelen
= baselen
? pathlen
- baselen
- 1 : pathlen
;
1254 name
= pathname
+ pathlen
- namelen
;
1258 * if the non-wildcard part is longer than the
1259 * remaining pathname, surely it cannot match.
1261 if (prefix
> namelen
)
1264 if (fspathncmp(pattern
, name
, prefix
))
1267 patternlen
-= prefix
;
1272 * If the whole pattern did not have a wildcard,
1273 * then our prefix match is all we need; we
1274 * do not need to call fnmatch at all.
1276 if (!patternlen
&& !namelen
)
1280 return fnmatch_icase_mem(pattern
, patternlen
,
1286 * Scan the given exclude list in reverse to see whether pathname
1287 * should be ignored. The first match (i.e. the last on the list), if
1288 * any, determines the fate. Returns the exclude_list element which
1289 * matched, or NULL for undecided.
1291 static struct path_pattern
*last_matching_pattern_from_list(const char *pathname
,
1293 const char *basename
,
1295 struct pattern_list
*pl
,
1296 struct index_state
*istate
)
1298 struct path_pattern
*res
= NULL
; /* undecided */
1302 return NULL
; /* undefined */
1304 for (i
= pl
->nr
- 1; 0 <= i
; i
--) {
1305 struct path_pattern
*pattern
= pl
->patterns
[i
];
1306 const char *exclude
= pattern
->pattern
;
1307 int prefix
= pattern
->nowildcardlen
;
1309 if (pattern
->flags
& PATTERN_FLAG_MUSTBEDIR
) {
1310 *dtype
= resolve_dtype(*dtype
, istate
, pathname
, pathlen
);
1311 if (*dtype
!= DT_DIR
)
1315 if (pattern
->flags
& PATTERN_FLAG_NODIR
) {
1316 if (match_basename(basename
,
1317 pathlen
- (basename
- pathname
),
1318 exclude
, prefix
, pattern
->patternlen
,
1326 assert(pattern
->baselen
== 0 ||
1327 pattern
->base
[pattern
->baselen
- 1] == '/');
1328 if (match_pathname(pathname
, pathlen
,
1330 pattern
->baselen
? pattern
->baselen
- 1 : 0,
1331 exclude
, prefix
, pattern
->patternlen
,
1341 * Scan the list of patterns to determine if the ordered list
1342 * of patterns matches on 'pathname'.
1344 * Return 1 for a match, 0 for not matched and -1 for undecided.
1346 enum pattern_match_result
path_matches_pattern_list(
1347 const char *pathname
, int pathlen
,
1348 const char *basename
, int *dtype
,
1349 struct pattern_list
*pl
,
1350 struct index_state
*istate
)
1352 struct path_pattern
*pattern
;
1353 struct strbuf parent_pathname
= STRBUF_INIT
;
1354 int result
= NOT_MATCHED
;
1355 const char *slash_pos
;
1357 if (!pl
->use_cone_patterns
) {
1358 pattern
= last_matching_pattern_from_list(pathname
, pathlen
, basename
,
1361 if (pattern
->flags
& PATTERN_FLAG_NEGATIVE
)
1373 strbuf_addch(&parent_pathname
, '/');
1374 strbuf_add(&parent_pathname
, pathname
, pathlen
);
1376 if (hashmap_contains_path(&pl
->recursive_hashmap
,
1377 &parent_pathname
)) {
1378 result
= MATCHED_RECURSIVE
;
1382 slash_pos
= strrchr(parent_pathname
.buf
, '/');
1384 if (slash_pos
== parent_pathname
.buf
) {
1385 /* include every file in root */
1390 strbuf_setlen(&parent_pathname
, slash_pos
- parent_pathname
.buf
);
1392 if (hashmap_contains_path(&pl
->parent_hashmap
, &parent_pathname
)) {
1397 if (hashmap_contains_parent(&pl
->recursive_hashmap
,
1400 result
= MATCHED_RECURSIVE
;
1403 strbuf_release(&parent_pathname
);
1407 static struct path_pattern
*last_matching_pattern_from_lists(
1408 struct dir_struct
*dir
, struct index_state
*istate
,
1409 const char *pathname
, int pathlen
,
1410 const char *basename
, int *dtype_p
)
1413 struct exclude_list_group
*group
;
1414 struct path_pattern
*pattern
;
1415 for (i
= EXC_CMDL
; i
<= EXC_FILE
; i
++) {
1416 group
= &dir
->exclude_list_group
[i
];
1417 for (j
= group
->nr
- 1; j
>= 0; j
--) {
1418 pattern
= last_matching_pattern_from_list(
1419 pathname
, pathlen
, basename
, dtype_p
,
1420 &group
->pl
[j
], istate
);
1429 * Loads the per-directory exclude list for the substring of base
1430 * which has a char length of baselen.
1432 static void prep_exclude(struct dir_struct
*dir
,
1433 struct index_state
*istate
,
1434 const char *base
, int baselen
)
1436 struct exclude_list_group
*group
;
1437 struct pattern_list
*pl
;
1438 struct exclude_stack
*stk
= NULL
;
1439 struct untracked_cache_dir
*untracked
;
1442 group
= &dir
->exclude_list_group
[EXC_DIRS
];
1445 * Pop the exclude lists from the EXCL_DIRS exclude_list_group
1446 * which originate from directories not in the prefix of the
1447 * path being checked.
1449 while ((stk
= dir
->exclude_stack
) != NULL
) {
1450 if (stk
->baselen
<= baselen
&&
1451 !strncmp(dir
->basebuf
.buf
, base
, stk
->baselen
))
1453 pl
= &group
->pl
[dir
->exclude_stack
->exclude_ix
];
1454 dir
->exclude_stack
= stk
->prev
;
1455 dir
->pattern
= NULL
;
1456 free((char *)pl
->src
); /* see strbuf_detach() below */
1457 clear_pattern_list(pl
);
1462 /* Skip traversing into sub directories if the parent is excluded */
1467 * Lazy initialization. All call sites currently just
1468 * memset(dir, 0, sizeof(*dir)) before use. Changing all of
1469 * them seems lots of work for little benefit.
1471 if (!dir
->basebuf
.buf
)
1472 strbuf_init(&dir
->basebuf
, PATH_MAX
);
1474 /* Read from the parent directories and push them down. */
1475 current
= stk
? stk
->baselen
: -1;
1476 strbuf_setlen(&dir
->basebuf
, current
< 0 ? 0 : current
);
1478 untracked
= stk
? stk
->ucd
: dir
->untracked
->root
;
1482 while (current
< baselen
) {
1484 struct oid_stat oid_stat
;
1486 stk
= xcalloc(1, sizeof(*stk
));
1491 cp
= strchr(base
+ current
+ 1, '/');
1493 die("oops in prep_exclude");
1496 lookup_untracked(dir
->untracked
, untracked
,
1498 cp
- base
- current
);
1500 stk
->prev
= dir
->exclude_stack
;
1501 stk
->baselen
= cp
- base
;
1502 stk
->exclude_ix
= group
->nr
;
1503 stk
->ucd
= untracked
;
1504 pl
= add_pattern_list(dir
, EXC_DIRS
, NULL
);
1505 strbuf_add(&dir
->basebuf
, base
+ current
, stk
->baselen
- current
);
1506 assert(stk
->baselen
== dir
->basebuf
.len
);
1508 /* Abort if the directory is excluded */
1511 dir
->basebuf
.buf
[stk
->baselen
- 1] = 0;
1512 dir
->pattern
= last_matching_pattern_from_lists(dir
,
1514 dir
->basebuf
.buf
, stk
->baselen
- 1,
1515 dir
->basebuf
.buf
+ current
, &dt
);
1516 dir
->basebuf
.buf
[stk
->baselen
- 1] = '/';
1518 dir
->pattern
->flags
& PATTERN_FLAG_NEGATIVE
)
1519 dir
->pattern
= NULL
;
1521 dir
->exclude_stack
= stk
;
1526 /* Try to read per-directory file */
1527 oidclr(&oid_stat
.oid
);
1529 if (dir
->exclude_per_dir
&&
1531 * If we know that no files have been added in
1532 * this directory (i.e. valid_cached_dir() has
1533 * been executed and set untracked->valid) ..
1535 (!untracked
|| !untracked
->valid
||
1537 * .. and .gitignore does not exist before
1538 * (i.e. null exclude_oid). Then we can skip
1539 * loading .gitignore, which would result in
1542 !is_null_oid(&untracked
->exclude_oid
))) {
1544 * dir->basebuf gets reused by the traversal, but we
1545 * need fname to remain unchanged to ensure the src
1546 * member of each struct path_pattern correctly
1547 * back-references its source file. Other invocations
1548 * of add_pattern_list provide stable strings, so we
1549 * strbuf_detach() and free() here in the caller.
1551 struct strbuf sb
= STRBUF_INIT
;
1552 strbuf_addbuf(&sb
, &dir
->basebuf
);
1553 strbuf_addstr(&sb
, dir
->exclude_per_dir
);
1554 pl
->src
= strbuf_detach(&sb
, NULL
);
1555 add_patterns(pl
->src
, pl
->src
, stk
->baselen
, pl
, istate
,
1556 untracked
? &oid_stat
: NULL
);
1559 * NEEDSWORK: when untracked cache is enabled, prep_exclude()
1560 * will first be called in valid_cached_dir() then maybe many
1561 * times more in last_matching_pattern(). When the cache is
1562 * used, last_matching_pattern() will not be called and
1563 * reading .gitignore content will be a waste.
1565 * So when it's called by valid_cached_dir() and we can get
1566 * .gitignore SHA-1 from the index (i.e. .gitignore is not
1567 * modified on work tree), we could delay reading the
1568 * .gitignore content until we absolutely need it in
1569 * last_matching_pattern(). Be careful about ignore rule
1570 * order, though, if you do that.
1573 !oideq(&oid_stat
.oid
, &untracked
->exclude_oid
)) {
1574 invalidate_gitignore(dir
->untracked
, untracked
);
1575 oidcpy(&untracked
->exclude_oid
, &oid_stat
.oid
);
1577 dir
->exclude_stack
= stk
;
1578 current
= stk
->baselen
;
1580 strbuf_setlen(&dir
->basebuf
, baselen
);
1584 * Loads the exclude lists for the directory containing pathname, then
1585 * scans all exclude lists to determine whether pathname is excluded.
1586 * Returns the exclude_list element which matched, or NULL for
1589 struct path_pattern
*last_matching_pattern(struct dir_struct
*dir
,
1590 struct index_state
*istate
,
1591 const char *pathname
,
1594 int pathlen
= strlen(pathname
);
1595 const char *basename
= strrchr(pathname
, '/');
1596 basename
= (basename
) ? basename
+1 : pathname
;
1598 prep_exclude(dir
, istate
, pathname
, basename
-pathname
);
1601 return dir
->pattern
;
1603 return last_matching_pattern_from_lists(dir
, istate
, pathname
, pathlen
,
1608 * Loads the exclude lists for the directory containing pathname, then
1609 * scans all exclude lists to determine whether pathname is excluded.
1610 * Returns 1 if true, otherwise 0.
1612 int is_excluded(struct dir_struct
*dir
, struct index_state
*istate
,
1613 const char *pathname
, int *dtype_p
)
1615 struct path_pattern
*pattern
=
1616 last_matching_pattern(dir
, istate
, pathname
, dtype_p
);
1618 return pattern
->flags
& PATTERN_FLAG_NEGATIVE
? 0 : 1;
1622 static struct dir_entry
*dir_entry_new(const char *pathname
, int len
)
1624 struct dir_entry
*ent
;
1626 FLEX_ALLOC_MEM(ent
, name
, pathname
, len
);
1631 static struct dir_entry
*dir_add_name(struct dir_struct
*dir
,
1632 struct index_state
*istate
,
1633 const char *pathname
, int len
)
1635 if (index_file_exists(istate
, pathname
, len
, ignore_case
))
1638 ALLOC_GROW(dir
->entries
, dir
->nr
+1, dir
->alloc
);
1639 return dir
->entries
[dir
->nr
++] = dir_entry_new(pathname
, len
);
1642 struct dir_entry
*dir_add_ignored(struct dir_struct
*dir
,
1643 struct index_state
*istate
,
1644 const char *pathname
, int len
)
1646 if (!index_name_is_other(istate
, pathname
, len
))
1649 ALLOC_GROW(dir
->ignored
, dir
->ignored_nr
+1, dir
->ignored_alloc
);
1650 return dir
->ignored
[dir
->ignored_nr
++] = dir_entry_new(pathname
, len
);
1654 index_nonexistent
= 0,
1660 * Do not use the alphabetically sorted index to look up
1661 * the directory name; instead, use the case insensitive
1664 static enum exist_status
directory_exists_in_index_icase(struct index_state
*istate
,
1665 const char *dirname
, int len
)
1667 struct cache_entry
*ce
;
1669 if (index_dir_exists(istate
, dirname
, len
))
1670 return index_directory
;
1672 ce
= index_file_exists(istate
, dirname
, len
, ignore_case
);
1673 if (ce
&& S_ISGITLINK(ce
->ce_mode
))
1674 return index_gitdir
;
1676 return index_nonexistent
;
1680 * The index sorts alphabetically by entry name, which
1681 * means that a gitlink sorts as '\0' at the end, while
1682 * a directory (which is defined not as an entry, but as
1683 * the files it contains) will sort with the '/' at the
1686 static enum exist_status
directory_exists_in_index(struct index_state
*istate
,
1687 const char *dirname
, int len
)
1692 return directory_exists_in_index_icase(istate
, dirname
, len
);
1694 pos
= index_name_pos(istate
, dirname
, len
);
1697 while (pos
< istate
->cache_nr
) {
1698 const struct cache_entry
*ce
= istate
->cache
[pos
++];
1699 unsigned char endchar
;
1701 if (strncmp(ce
->name
, dirname
, len
))
1703 endchar
= ce
->name
[len
];
1707 return index_directory
;
1708 if (!endchar
&& S_ISGITLINK(ce
->ce_mode
))
1709 return index_gitdir
;
1711 return index_nonexistent
;
1715 * When we find a directory when traversing the filesystem, we
1716 * have three distinct cases:
1719 * - see it as a directory
1722 * and which one we choose depends on a combination of existing
1723 * git index contents and the flags passed into the directory
1724 * traversal routine.
1726 * Case 1: If we *already* have entries in the index under that
1727 * directory name, we always recurse into the directory to see
1730 * Case 2: If we *already* have that directory name as a gitlink,
1731 * we always continue to see it as a gitlink, regardless of whether
1732 * there is an actual git directory there or not (it might not
1733 * be checked out as a subproject!)
1735 * Case 3: if we didn't have it in the index previously, we
1736 * have a few sub-cases:
1738 * (a) if "show_other_directories" is true, we show it as
1739 * just a directory, unless "hide_empty_directories" is
1740 * also true, in which case we need to check if it contains any
1741 * untracked and / or ignored files.
1742 * (b) if it looks like a git directory, and we don't have
1743 * 'no_gitlinks' set we treat it as a gitlink, and show it
1745 * (c) otherwise, we recurse into it.
1747 static enum path_treatment
treat_directory(struct dir_struct
*dir
,
1748 struct index_state
*istate
,
1749 struct untracked_cache_dir
*untracked
,
1750 const char *dirname
, int len
, int baselen
, int excluded
,
1751 const struct pathspec
*pathspec
)
1754 * WARNING: From this function, you can return path_recurse or you
1755 * can call read_directory_recursive() (or neither), but
1756 * you CAN'T DO BOTH.
1758 enum path_treatment state
;
1759 int matches_how
= 0;
1760 int nested_repo
= 0, check_only
, stop_early
;
1761 int old_ignored_nr
, old_untracked_nr
;
1762 /* The "len-1" is to strip the final '/' */
1763 enum exist_status status
= directory_exists_in_index(istate
, dirname
, len
-1);
1765 if (status
== index_directory
)
1766 return path_recurse
;
1767 if (status
== index_gitdir
)
1769 if (status
!= index_nonexistent
)
1770 BUG("Unhandled value for directory_exists_in_index: %d\n", status
);
1773 * We don't want to descend into paths that don't match the necessary
1774 * patterns. Clearly, if we don't have a pathspec, then we can't check
1775 * for matching patterns. Also, if (excluded) then we know we matched
1776 * the exclusion patterns so as an optimization we can skip checking
1777 * for matching patterns.
1779 if (pathspec
&& !excluded
) {
1780 matches_how
= match_pathspec_with_flags(istate
, pathspec
,
1784 DO_MATCH_LEADING_PATHSPEC
);
1790 if ((dir
->flags
& DIR_SKIP_NESTED_GIT
) ||
1791 !(dir
->flags
& DIR_NO_GITLINKS
)) {
1792 struct strbuf sb
= STRBUF_INIT
;
1793 strbuf_addstr(&sb
, dirname
);
1794 nested_repo
= is_nonbare_repository_dir(&sb
);
1795 strbuf_release(&sb
);
1798 return ((dir
->flags
& DIR_SKIP_NESTED_GIT
) ? path_none
:
1799 (excluded
? path_excluded
: path_untracked
));
1801 if (!(dir
->flags
& DIR_SHOW_OTHER_DIRECTORIES
)) {
1803 (dir
->flags
& DIR_SHOW_IGNORED_TOO
) &&
1804 (dir
->flags
& DIR_SHOW_IGNORED_TOO_MODE_MATCHING
)) {
1807 * This is an excluded directory and we are
1808 * showing ignored paths that match an exclude
1809 * pattern. (e.g. show directory as ignored
1810 * only if it matches an exclude pattern).
1811 * This path will either be 'path_excluded`
1812 * (if we are showing empty directories or if
1813 * the directory is not empty), or will be
1814 * 'path_none' (empty directory, and we are
1815 * not showing empty directories).
1817 if (!(dir
->flags
& DIR_HIDE_EMPTY_DIRECTORIES
))
1818 return path_excluded
;
1820 if (read_directory_recursive(dir
, istate
, dirname
, len
,
1821 untracked
, 1, 1, pathspec
) == path_excluded
)
1822 return path_excluded
;
1826 return path_recurse
;
1829 /* This is the "show_other_directories" case */
1832 * If we have a pathspec which could match something _below_ this
1833 * directory (e.g. when checking 'subdir/' having a pathspec like
1834 * 'subdir/some/deep/path/file' or 'subdir/widget-*.c'), then we
1837 if (matches_how
== MATCHED_RECURSIVELY_LEADING_PATHSPEC
)
1838 return path_recurse
;
1841 * Other than the path_recurse case immediately above, we only need
1842 * to recurse into untracked/ignored directories if either of the
1843 * following bits is set:
1844 * - DIR_SHOW_IGNORED_TOO (because then we need to determine if
1845 * there are ignored entries below)
1846 * - DIR_HIDE_EMPTY_DIRECTORIES (because we have to determine if
1847 * the directory is empty)
1849 if (!(dir
->flags
& (DIR_SHOW_IGNORED_TOO
| DIR_HIDE_EMPTY_DIRECTORIES
)))
1850 return excluded
? path_excluded
: path_untracked
;
1853 * ...and even if DIR_SHOW_IGNORED_TOO is set, we can still avoid
1854 * recursing into ignored directories if the path is excluded and
1855 * DIR_SHOW_IGNORED_TOO_MODE_MATCHING is also set.
1858 (dir
->flags
& DIR_SHOW_IGNORED_TOO
) &&
1859 (dir
->flags
& DIR_SHOW_IGNORED_TOO_MODE_MATCHING
))
1860 return path_excluded
;
1863 * Even if we don't want to know all the paths under an untracked or
1864 * ignored directory, we may still need to go into the directory to
1865 * determine if it is empty (because with DIR_HIDE_EMPTY_DIRECTORIES,
1866 * an empty directory should be path_none instead of path_excluded or
1869 check_only
= ((dir
->flags
& DIR_HIDE_EMPTY_DIRECTORIES
) &&
1870 !(dir
->flags
& DIR_SHOW_IGNORED_TOO
));
1873 * However, there's another optimization possible as a subset of
1874 * check_only, based on the cases we have to consider:
1875 * A) Directory matches no exclude patterns:
1876 * * Directory is empty => path_none
1877 * * Directory has an untracked file under it => path_untracked
1878 * * Directory has only ignored files under it => path_excluded
1879 * B) Directory matches an exclude pattern:
1880 * * Directory is empty => path_none
1881 * * Directory has an untracked file under it => path_excluded
1882 * * Directory has only ignored files under it => path_excluded
1883 * In case A, we can exit as soon as we've found an untracked
1884 * file but otherwise have to walk all files. In case B, though,
1885 * we can stop at the first file we find under the directory.
1887 stop_early
= check_only
&& excluded
;
1890 * If /every/ file within an untracked directory is ignored, then
1891 * we want to treat the directory as ignored (for e.g. status
1892 * --porcelain), without listing the individual ignored files
1893 * underneath. To do so, we'll save the current ignored_nr, and
1894 * pop all the ones added after it if it turns out the entire
1895 * directory is ignored. Also, when DIR_SHOW_IGNORED_TOO and
1896 * !DIR_KEEP_UNTRACKED_CONTENTS then we don't want to show
1897 * untracked paths so will need to pop all those off the last
1898 * after we traverse.
1900 old_ignored_nr
= dir
->ignored_nr
;
1901 old_untracked_nr
= dir
->nr
;
1903 /* Actually recurse into dirname now, we'll fixup the state later. */
1904 untracked
= lookup_untracked(dir
->untracked
, untracked
,
1905 dirname
+ baselen
, len
- baselen
);
1906 state
= read_directory_recursive(dir
, istate
, dirname
, len
, untracked
,
1907 check_only
, stop_early
, pathspec
);
1909 /* There are a variety of reasons we may need to fixup the state... */
1910 if (state
== path_excluded
) {
1911 /* state == path_excluded implies all paths under
1912 * dirname were ignored...
1914 * if running e.g. `git status --porcelain --ignored=matching`,
1915 * then we want to see the subpaths that are ignored.
1917 * if running e.g. just `git status --porcelain`, then
1918 * we just want the directory itself to be listed as ignored
1919 * and not the individual paths underneath.
1921 int want_ignored_subpaths
=
1922 ((dir
->flags
& DIR_SHOW_IGNORED_TOO
) &&
1923 (dir
->flags
& DIR_SHOW_IGNORED_TOO_MODE_MATCHING
));
1925 if (want_ignored_subpaths
) {
1927 * with --ignored=matching, we want the subpaths
1928 * INSTEAD of the directory itself.
1933 for (i
= old_ignored_nr
+ 1; i
<dir
->ignored_nr
; ++i
)
1934 FREE_AND_NULL(dir
->ignored
[i
]);
1935 dir
->ignored_nr
= old_ignored_nr
;
1940 * We may need to ignore some of the untracked paths we found while
1941 * traversing subdirectories.
1943 if ((dir
->flags
& DIR_SHOW_IGNORED_TOO
) &&
1944 !(dir
->flags
& DIR_KEEP_UNTRACKED_CONTENTS
)) {
1946 for (i
= old_untracked_nr
+ 1; i
<dir
->nr
; ++i
)
1947 FREE_AND_NULL(dir
->entries
[i
]);
1948 dir
->nr
= old_untracked_nr
;
1952 * If there is nothing under the current directory and we are not
1953 * hiding empty directories, then we need to report on the
1954 * untracked or ignored status of the directory itself.
1956 if (state
== path_none
&& !(dir
->flags
& DIR_HIDE_EMPTY_DIRECTORIES
))
1957 state
= excluded
? path_excluded
: path_untracked
;
1963 * This is an inexact early pruning of any recursive directory
1964 * reading - if the path cannot possibly be in the pathspec,
1965 * return true, and we'll skip it early.
1967 static int simplify_away(const char *path
, int pathlen
,
1968 const struct pathspec
*pathspec
)
1972 if (!pathspec
|| !pathspec
->nr
)
1975 GUARD_PATHSPEC(pathspec
,
1984 for (i
= 0; i
< pathspec
->nr
; i
++) {
1985 const struct pathspec_item
*item
= &pathspec
->items
[i
];
1986 int len
= item
->nowildcard_len
;
1990 if (!ps_strncmp(item
, item
->match
, path
, len
))
1998 * This function tells us whether an excluded path matches a
1999 * list of "interesting" pathspecs. That is, whether a path matched
2000 * by any of the pathspecs could possibly be ignored by excluding
2001 * the specified path. This can happen if:
2003 * 1. the path is mentioned explicitly in the pathspec
2005 * 2. the path is a directory prefix of some element in the
2008 static int exclude_matches_pathspec(const char *path
, int pathlen
,
2009 const struct pathspec
*pathspec
)
2013 if (!pathspec
|| !pathspec
->nr
)
2016 GUARD_PATHSPEC(pathspec
,
2024 for (i
= 0; i
< pathspec
->nr
; i
++) {
2025 const struct pathspec_item
*item
= &pathspec
->items
[i
];
2026 int len
= item
->nowildcard_len
;
2028 if (len
== pathlen
&&
2029 !ps_strncmp(item
, item
->match
, path
, pathlen
))
2031 if (len
> pathlen
&&
2032 item
->match
[pathlen
] == '/' &&
2033 !ps_strncmp(item
, item
->match
, path
, pathlen
))
2039 static int get_index_dtype(struct index_state
*istate
,
2040 const char *path
, int len
)
2043 const struct cache_entry
*ce
;
2045 ce
= index_file_exists(istate
, path
, len
, 0);
2047 if (!ce_uptodate(ce
))
2049 if (S_ISGITLINK(ce
->ce_mode
))
2052 * Nobody actually cares about the
2053 * difference between DT_LNK and DT_REG
2058 /* Try to look it up as a directory */
2059 pos
= index_name_pos(istate
, path
, len
);
2063 while (pos
< istate
->cache_nr
) {
2064 ce
= istate
->cache
[pos
++];
2065 if (strncmp(ce
->name
, path
, len
))
2067 if (ce
->name
[len
] > '/')
2069 if (ce
->name
[len
] < '/')
2071 if (!ce_uptodate(ce
))
2072 break; /* continue? */
2078 static int resolve_dtype(int dtype
, struct index_state
*istate
,
2079 const char *path
, int len
)
2083 if (dtype
!= DT_UNKNOWN
)
2085 dtype
= get_index_dtype(istate
, path
, len
);
2086 if (dtype
!= DT_UNKNOWN
)
2088 if (lstat(path
, &st
))
2090 if (S_ISREG(st
.st_mode
))
2092 if (S_ISDIR(st
.st_mode
))
2094 if (S_ISLNK(st
.st_mode
))
2099 static enum path_treatment
treat_path_fast(struct dir_struct
*dir
,
2100 struct untracked_cache_dir
*untracked
,
2101 struct cached_dir
*cdir
,
2102 struct index_state
*istate
,
2103 struct strbuf
*path
,
2105 const struct pathspec
*pathspec
)
2108 * WARNING: From this function, you can return path_recurse or you
2109 * can call read_directory_recursive() (or neither), but
2110 * you CAN'T DO BOTH.
2112 strbuf_setlen(path
, baselen
);
2114 strbuf_addstr(path
, cdir
->file
);
2115 return path_untracked
;
2117 strbuf_addstr(path
, cdir
->ucd
->name
);
2118 /* treat_one_path() does this before it calls treat_directory() */
2119 strbuf_complete(path
, '/');
2120 if (cdir
->ucd
->check_only
)
2122 * check_only is set as a result of treat_directory() getting
2123 * to its bottom. Verify again the same set of directories
2124 * with check_only set.
2126 return read_directory_recursive(dir
, istate
, path
->buf
, path
->len
,
2127 cdir
->ucd
, 1, 0, pathspec
);
2129 * We get path_recurse in the first run when
2130 * directory_exists_in_index() returns index_nonexistent. We
2131 * are sure that new changes in the index does not impact the
2132 * outcome. Return now.
2134 return path_recurse
;
2137 static enum path_treatment
treat_path(struct dir_struct
*dir
,
2138 struct untracked_cache_dir
*untracked
,
2139 struct cached_dir
*cdir
,
2140 struct index_state
*istate
,
2141 struct strbuf
*path
,
2143 const struct pathspec
*pathspec
)
2145 int has_path_in_index
, dtype
, excluded
;
2148 return treat_path_fast(dir
, untracked
, cdir
, istate
, path
,
2150 if (is_dot_or_dotdot(cdir
->d_name
) || !fspathcmp(cdir
->d_name
, ".git"))
2152 strbuf_setlen(path
, baselen
);
2153 strbuf_addstr(path
, cdir
->d_name
);
2154 if (simplify_away(path
->buf
, path
->len
, pathspec
))
2157 dtype
= resolve_dtype(cdir
->d_type
, istate
, path
->buf
, path
->len
);
2159 /* Always exclude indexed files */
2160 has_path_in_index
= !!index_file_exists(istate
, path
->buf
, path
->len
,
2162 if (dtype
!= DT_DIR
&& has_path_in_index
)
2166 * When we are looking at a directory P in the working tree,
2167 * there are three cases:
2169 * (1) P exists in the index. Everything inside the directory P in
2170 * the working tree needs to go when P is checked out from the
2173 * (2) P does not exist in the index, but there is P/Q in the index.
2174 * We know P will stay a directory when we check out the contents
2175 * of the index, but we do not know yet if there is a directory
2176 * P/Q in the working tree to be killed, so we need to recurse.
2178 * (3) P does not exist in the index, and there is no P/Q in the index
2179 * to require P to be a directory, either. Only in this case, we
2180 * know that everything inside P will not be killed without
2183 if ((dir
->flags
& DIR_COLLECT_KILLED_ONLY
) &&
2184 (dtype
== DT_DIR
) &&
2185 !has_path_in_index
&&
2186 (directory_exists_in_index(istate
, path
->buf
, path
->len
) == index_nonexistent
))
2189 excluded
= is_excluded(dir
, istate
, path
->buf
, &dtype
);
2192 * Excluded? If we don't explicitly want to show
2193 * ignored files, ignore it
2195 if (excluded
&& !(dir
->flags
& (DIR_SHOW_IGNORED
|DIR_SHOW_IGNORED_TOO
)))
2196 return path_excluded
;
2203 * WARNING: Do not ignore/amend the return value from
2204 * treat_directory(), and especially do not change it to return
2205 * path_recurse as that can cause exponential slowdown.
2206 * Instead, modify treat_directory() to return the right value.
2208 strbuf_addch(path
, '/');
2209 return treat_directory(dir
, istate
, untracked
,
2210 path
->buf
, path
->len
,
2211 baselen
, excluded
, pathspec
);
2215 return path_excluded
;
2217 !match_pathspec(istate
, pathspec
, path
->buf
, path
->len
,
2218 0 /* prefix */, NULL
/* seen */,
2221 return path_untracked
;
2225 static void add_untracked(struct untracked_cache_dir
*dir
, const char *name
)
2229 ALLOC_GROW(dir
->untracked
, dir
->untracked_nr
+ 1,
2230 dir
->untracked_alloc
);
2231 dir
->untracked
[dir
->untracked_nr
++] = xstrdup(name
);
2234 static int valid_cached_dir(struct dir_struct
*dir
,
2235 struct untracked_cache_dir
*untracked
,
2236 struct index_state
*istate
,
2237 struct strbuf
*path
,
2246 * With fsmonitor, we can trust the untracked cache's valid field.
2248 refresh_fsmonitor(istate
);
2249 if (!(dir
->untracked
->use_fsmonitor
&& untracked
->valid
)) {
2250 if (lstat(path
->len
? path
->buf
: ".", &st
)) {
2251 memset(&untracked
->stat_data
, 0, sizeof(untracked
->stat_data
));
2254 if (!untracked
->valid
||
2255 match_stat_data_racy(istate
, &untracked
->stat_data
, &st
)) {
2256 fill_stat_data(&untracked
->stat_data
, &st
);
2261 if (untracked
->check_only
!= !!check_only
)
2265 * prep_exclude will be called eventually on this directory,
2266 * but it's called much later in last_matching_pattern(). We
2267 * need it now to determine the validity of the cache for this
2268 * path. The next calls will be nearly no-op, the way
2269 * prep_exclude() is designed.
2271 if (path
->len
&& path
->buf
[path
->len
- 1] != '/') {
2272 strbuf_addch(path
, '/');
2273 prep_exclude(dir
, istate
, path
->buf
, path
->len
);
2274 strbuf_setlen(path
, path
->len
- 1);
2276 prep_exclude(dir
, istate
, path
->buf
, path
->len
);
2278 /* hopefully prep_exclude() haven't invalidated this entry... */
2279 return untracked
->valid
;
2282 static int open_cached_dir(struct cached_dir
*cdir
,
2283 struct dir_struct
*dir
,
2284 struct untracked_cache_dir
*untracked
,
2285 struct index_state
*istate
,
2286 struct strbuf
*path
,
2291 memset(cdir
, 0, sizeof(*cdir
));
2292 cdir
->untracked
= untracked
;
2293 if (valid_cached_dir(dir
, untracked
, istate
, path
, check_only
))
2295 c_path
= path
->len
? path
->buf
: ".";
2296 cdir
->fdir
= opendir(c_path
);
2298 warning_errno(_("could not open directory '%s'"), c_path
);
2299 if (dir
->untracked
) {
2300 invalidate_directory(dir
->untracked
, untracked
);
2301 dir
->untracked
->dir_opened
++;
2308 static int read_cached_dir(struct cached_dir
*cdir
)
2313 de
= readdir(cdir
->fdir
);
2315 cdir
->d_name
= NULL
;
2316 cdir
->d_type
= DT_UNKNOWN
;
2319 cdir
->d_name
= de
->d_name
;
2320 cdir
->d_type
= DTYPE(de
);
2323 while (cdir
->nr_dirs
< cdir
->untracked
->dirs_nr
) {
2324 struct untracked_cache_dir
*d
= cdir
->untracked
->dirs
[cdir
->nr_dirs
];
2334 if (cdir
->nr_files
< cdir
->untracked
->untracked_nr
) {
2335 struct untracked_cache_dir
*d
= cdir
->untracked
;
2336 cdir
->file
= d
->untracked
[cdir
->nr_files
++];
2342 static void close_cached_dir(struct cached_dir
*cdir
)
2345 closedir(cdir
->fdir
);
2347 * We have gone through this directory and found no untracked
2348 * entries. Mark it valid.
2350 if (cdir
->untracked
) {
2351 cdir
->untracked
->valid
= 1;
2352 cdir
->untracked
->recurse
= 1;
2356 static void add_path_to_appropriate_result_list(struct dir_struct
*dir
,
2357 struct untracked_cache_dir
*untracked
,
2358 struct cached_dir
*cdir
,
2359 struct index_state
*istate
,
2360 struct strbuf
*path
,
2362 const struct pathspec
*pathspec
,
2363 enum path_treatment state
)
2365 /* add the path to the appropriate result list */
2368 if (dir
->flags
& DIR_SHOW_IGNORED
)
2369 dir_add_name(dir
, istate
, path
->buf
, path
->len
);
2370 else if ((dir
->flags
& DIR_SHOW_IGNORED_TOO
) ||
2371 ((dir
->flags
& DIR_COLLECT_IGNORED
) &&
2372 exclude_matches_pathspec(path
->buf
, path
->len
,
2374 dir_add_ignored(dir
, istate
, path
->buf
, path
->len
);
2377 case path_untracked
:
2378 if (dir
->flags
& DIR_SHOW_IGNORED
)
2380 dir_add_name(dir
, istate
, path
->buf
, path
->len
);
2382 add_untracked(untracked
, path
->buf
+ baselen
);
2391 * Read a directory tree. We currently ignore anything but
2392 * directories, regular files and symlinks. That's because git
2393 * doesn't handle them at all yet. Maybe that will change some
2396 * Also, we ignore the name ".git" (even if it is not a directory).
2397 * That likely will not change.
2399 * If 'stop_at_first_file' is specified, 'path_excluded' is returned
2400 * to signal that a file was found. This is the least significant value that
2401 * indicates that a file was encountered that does not depend on the order of
2402 * whether an untracked or excluded path was encountered first.
2404 * Returns the most significant path_treatment value encountered in the scan.
2405 * If 'stop_at_first_file' is specified, `path_excluded` is the most
2406 * significant path_treatment value that will be returned.
2409 static enum path_treatment
read_directory_recursive(struct dir_struct
*dir
,
2410 struct index_state
*istate
, const char *base
, int baselen
,
2411 struct untracked_cache_dir
*untracked
, int check_only
,
2412 int stop_at_first_file
, const struct pathspec
*pathspec
)
2415 * WARNING: Do NOT recurse unless path_recurse is returned from
2416 * treat_path(). Recursing on any other return value
2417 * can result in exponential slowdown.
2419 struct cached_dir cdir
;
2420 enum path_treatment state
, subdir_state
, dir_state
= path_none
;
2421 struct strbuf path
= STRBUF_INIT
;
2423 strbuf_add(&path
, base
, baselen
);
2425 if (open_cached_dir(&cdir
, dir
, untracked
, istate
, &path
, check_only
))
2429 untracked
->check_only
= !!check_only
;
2431 while (!read_cached_dir(&cdir
)) {
2432 /* check how the file or directory should be treated */
2433 state
= treat_path(dir
, untracked
, &cdir
, istate
, &path
,
2436 if (state
> dir_state
)
2439 /* recurse into subdir if instructed by treat_path */
2440 if (state
== path_recurse
) {
2441 struct untracked_cache_dir
*ud
;
2442 ud
= lookup_untracked(dir
->untracked
, untracked
,
2444 path
.len
- baselen
);
2446 read_directory_recursive(dir
, istate
, path
.buf
,
2448 check_only
, stop_at_first_file
, pathspec
);
2449 if (subdir_state
> dir_state
)
2450 dir_state
= subdir_state
;
2453 !match_pathspec(istate
, pathspec
, path
.buf
, path
.len
,
2454 0 /* prefix */, NULL
,
2455 0 /* do NOT special case dirs */))
2460 if (stop_at_first_file
) {
2462 * If stopping at first file, then
2463 * signal that a file was found by
2464 * returning `path_excluded`. This is
2465 * to return a consistent value
2466 * regardless of whether an ignored or
2467 * excluded file happened to be
2470 * In current usage, the
2471 * `stop_at_first_file` is passed when
2472 * an ancestor directory has matched
2473 * an exclude pattern, so any found
2474 * files will be excluded.
2476 if (dir_state
>= path_excluded
) {
2477 dir_state
= path_excluded
;
2482 /* abort early if maximum state has been reached */
2483 if (dir_state
== path_untracked
) {
2485 add_untracked(untracked
, path
.buf
+ baselen
);
2488 /* skip the add_path_to_appropriate_result_list() */
2492 add_path_to_appropriate_result_list(dir
, untracked
, &cdir
,
2493 istate
, &path
, baselen
,
2496 close_cached_dir(&cdir
);
2498 strbuf_release(&path
);
2503 int cmp_dir_entry(const void *p1
, const void *p2
)
2505 const struct dir_entry
*e1
= *(const struct dir_entry
**)p1
;
2506 const struct dir_entry
*e2
= *(const struct dir_entry
**)p2
;
2508 return name_compare(e1
->name
, e1
->len
, e2
->name
, e2
->len
);
2511 /* check if *out lexically strictly contains *in */
2512 int check_dir_entry_contains(const struct dir_entry
*out
, const struct dir_entry
*in
)
2514 return (out
->len
< in
->len
) &&
2515 (out
->name
[out
->len
- 1] == '/') &&
2516 !memcmp(out
->name
, in
->name
, out
->len
);
2519 static int treat_leading_path(struct dir_struct
*dir
,
2520 struct index_state
*istate
,
2521 const char *path
, int len
,
2522 const struct pathspec
*pathspec
)
2524 struct strbuf sb
= STRBUF_INIT
;
2525 struct strbuf subdir
= STRBUF_INIT
;
2526 int prevlen
, baselen
;
2528 struct cached_dir cdir
;
2529 enum path_treatment state
= path_none
;
2532 * For each directory component of path, we are going to check whether
2533 * that path is relevant given the pathspec. For example, if path is
2535 * then we will ask treat_path() whether we should go into foo, then
2536 * whether we should go into bar, then whether baz is relevant.
2537 * Checking each is important because e.g. if path is
2539 * then we need to check .git to know we shouldn't traverse it.
2540 * If the return from treat_path() is:
2541 * * path_none, for any path, we return false.
2542 * * path_recurse, for all path components, we return true
2543 * * <anything else> for some intermediate component, we make sure
2544 * to add that path to the relevant list but return false
2545 * signifying that we shouldn't recurse into it.
2548 while (len
&& path
[len
- 1] == '/')
2553 memset(&cdir
, 0, sizeof(cdir
));
2554 cdir
.d_type
= DT_DIR
;
2558 prevlen
= baselen
+ !!baselen
;
2559 cp
= path
+ prevlen
;
2560 cp
= memchr(cp
, '/', path
+ len
- cp
);
2564 baselen
= cp
- path
;
2566 strbuf_add(&sb
, path
, baselen
);
2567 if (!is_directory(sb
.buf
))
2570 strbuf_add(&sb
, path
, prevlen
);
2571 strbuf_reset(&subdir
);
2572 strbuf_add(&subdir
, path
+prevlen
, baselen
-prevlen
);
2573 cdir
.d_name
= subdir
.buf
;
2574 state
= treat_path(dir
, NULL
, &cdir
, istate
, &sb
, prevlen
, pathspec
);
2576 if (state
!= path_recurse
)
2577 break; /* do not recurse into it */
2579 break; /* finished checking */
2581 add_path_to_appropriate_result_list(dir
, NULL
, &cdir
, istate
,
2582 &sb
, baselen
, pathspec
,
2585 strbuf_release(&subdir
);
2586 strbuf_release(&sb
);
2587 return state
== path_recurse
;
2590 static const char *get_ident_string(void)
2592 static struct strbuf sb
= STRBUF_INIT
;
2597 if (uname(&uts
) < 0)
2598 die_errno(_("failed to get kernel name and information"));
2599 strbuf_addf(&sb
, "Location %s, system %s", get_git_work_tree(),
2604 static int ident_in_untracked(const struct untracked_cache
*uc
)
2607 * Previous git versions may have saved many NUL separated
2608 * strings in the "ident" field, but it is insane to manage
2609 * many locations, so just take care of the first one.
2612 return !strcmp(uc
->ident
.buf
, get_ident_string());
2615 static void set_untracked_ident(struct untracked_cache
*uc
)
2617 strbuf_reset(&uc
->ident
);
2618 strbuf_addstr(&uc
->ident
, get_ident_string());
2621 * This strbuf used to contain a list of NUL separated
2622 * strings, so save NUL too for backward compatibility.
2624 strbuf_addch(&uc
->ident
, 0);
2627 static void new_untracked_cache(struct index_state
*istate
)
2629 struct untracked_cache
*uc
= xcalloc(1, sizeof(*uc
));
2630 strbuf_init(&uc
->ident
, 100);
2631 uc
->exclude_per_dir
= ".gitignore";
2632 /* should be the same flags used by git-status */
2633 uc
->dir_flags
= DIR_SHOW_OTHER_DIRECTORIES
| DIR_HIDE_EMPTY_DIRECTORIES
;
2634 set_untracked_ident(uc
);
2635 istate
->untracked
= uc
;
2636 istate
->cache_changed
|= UNTRACKED_CHANGED
;
2639 void add_untracked_cache(struct index_state
*istate
)
2641 if (!istate
->untracked
) {
2642 new_untracked_cache(istate
);
2644 if (!ident_in_untracked(istate
->untracked
)) {
2645 free_untracked_cache(istate
->untracked
);
2646 new_untracked_cache(istate
);
2651 void remove_untracked_cache(struct index_state
*istate
)
2653 if (istate
->untracked
) {
2654 free_untracked_cache(istate
->untracked
);
2655 istate
->untracked
= NULL
;
2656 istate
->cache_changed
|= UNTRACKED_CHANGED
;
2660 static struct untracked_cache_dir
*validate_untracked_cache(struct dir_struct
*dir
,
2662 const struct pathspec
*pathspec
)
2664 struct untracked_cache_dir
*root
;
2665 static int untracked_cache_disabled
= -1;
2667 if (!dir
->untracked
)
2669 if (untracked_cache_disabled
< 0)
2670 untracked_cache_disabled
= git_env_bool("GIT_DISABLE_UNTRACKED_CACHE", 0);
2671 if (untracked_cache_disabled
)
2675 * We only support $GIT_DIR/info/exclude and core.excludesfile
2676 * as the global ignore rule files. Any other additions
2677 * (e.g. from command line) invalidate the cache. This
2678 * condition also catches running setup_standard_excludes()
2679 * before setting dir->untracked!
2681 if (dir
->unmanaged_exclude_files
)
2685 * Optimize for the main use case only: whole-tree git
2686 * status. More work involved in treat_leading_path() if we
2687 * use cache on just a subset of the worktree. pathspec
2688 * support could make the matter even worse.
2690 if (base_len
|| (pathspec
&& pathspec
->nr
))
2693 /* Different set of flags may produce different results */
2694 if (dir
->flags
!= dir
->untracked
->dir_flags
||
2696 * See treat_directory(), case index_nonexistent. Without
2697 * this flag, we may need to also cache .git file content
2698 * for the resolve_gitlink_ref() call, which we don't.
2700 !(dir
->flags
& DIR_SHOW_OTHER_DIRECTORIES
) ||
2701 /* We don't support collecting ignore files */
2702 (dir
->flags
& (DIR_SHOW_IGNORED
| DIR_SHOW_IGNORED_TOO
|
2703 DIR_COLLECT_IGNORED
)))
2707 * If we use .gitignore in the cache and now you change it to
2708 * .gitexclude, everything will go wrong.
2710 if (dir
->exclude_per_dir
!= dir
->untracked
->exclude_per_dir
&&
2711 strcmp(dir
->exclude_per_dir
, dir
->untracked
->exclude_per_dir
))
2715 * EXC_CMDL is not considered in the cache. If people set it,
2718 if (dir
->exclude_list_group
[EXC_CMDL
].nr
)
2721 if (!ident_in_untracked(dir
->untracked
)) {
2722 warning(_("untracked cache is disabled on this system or location"));
2726 if (!dir
->untracked
->root
) {
2727 const int len
= sizeof(*dir
->untracked
->root
);
2728 dir
->untracked
->root
= xmalloc(len
);
2729 memset(dir
->untracked
->root
, 0, len
);
2732 /* Validate $GIT_DIR/info/exclude and core.excludesfile */
2733 root
= dir
->untracked
->root
;
2734 if (!oideq(&dir
->ss_info_exclude
.oid
,
2735 &dir
->untracked
->ss_info_exclude
.oid
)) {
2736 invalidate_gitignore(dir
->untracked
, root
);
2737 dir
->untracked
->ss_info_exclude
= dir
->ss_info_exclude
;
2739 if (!oideq(&dir
->ss_excludes_file
.oid
,
2740 &dir
->untracked
->ss_excludes_file
.oid
)) {
2741 invalidate_gitignore(dir
->untracked
, root
);
2742 dir
->untracked
->ss_excludes_file
= dir
->ss_excludes_file
;
2745 /* Make sure this directory is not dropped out at saving phase */
2750 int read_directory(struct dir_struct
*dir
, struct index_state
*istate
,
2751 const char *path
, int len
, const struct pathspec
*pathspec
)
2753 struct untracked_cache_dir
*untracked
;
2755 trace_performance_enter();
2757 if (has_symlink_leading_path(path
, len
)) {
2758 trace_performance_leave("read directory %.*s", len
, path
);
2762 untracked
= validate_untracked_cache(dir
, len
, pathspec
);
2765 * make sure untracked cache code path is disabled,
2766 * e.g. prep_exclude()
2768 dir
->untracked
= NULL
;
2769 if (!len
|| treat_leading_path(dir
, istate
, path
, len
, pathspec
))
2770 read_directory_recursive(dir
, istate
, path
, len
, untracked
, 0, 0, pathspec
);
2771 QSORT(dir
->entries
, dir
->nr
, cmp_dir_entry
);
2772 QSORT(dir
->ignored
, dir
->ignored_nr
, cmp_dir_entry
);
2774 trace_performance_leave("read directory %.*s", len
, path
);
2775 if (dir
->untracked
) {
2776 static int force_untracked_cache
= -1;
2777 static struct trace_key trace_untracked_stats
= TRACE_KEY_INIT(UNTRACKED_STATS
);
2779 if (force_untracked_cache
< 0)
2780 force_untracked_cache
=
2781 git_env_bool("GIT_FORCE_UNTRACKED_CACHE", 0);
2782 trace_printf_key(&trace_untracked_stats
,
2783 "node creation: %u\n"
2784 "gitignore invalidation: %u\n"
2785 "directory invalidation: %u\n"
2787 dir
->untracked
->dir_created
,
2788 dir
->untracked
->gitignore_invalidated
,
2789 dir
->untracked
->dir_invalidated
,
2790 dir
->untracked
->dir_opened
);
2791 if (force_untracked_cache
&&
2792 dir
->untracked
== istate
->untracked
&&
2793 (dir
->untracked
->dir_opened
||
2794 dir
->untracked
->gitignore_invalidated
||
2795 dir
->untracked
->dir_invalidated
))
2796 istate
->cache_changed
|= UNTRACKED_CHANGED
;
2797 if (dir
->untracked
!= istate
->untracked
) {
2798 FREE_AND_NULL(dir
->untracked
);
2804 int file_exists(const char *f
)
2807 return lstat(f
, &sb
) == 0;
2810 int repo_file_exists(struct repository
*repo
, const char *path
)
2812 if (repo
!= the_repository
)
2813 BUG("do not know how to check file existence in arbitrary repo");
2815 return file_exists(path
);
2818 static int cmp_icase(char a
, char b
)
2823 return toupper(a
) - toupper(b
);
2828 * Given two normalized paths (a trailing slash is ok), if subdir is
2829 * outside dir, return -1. Otherwise return the offset in subdir that
2830 * can be used as relative path to dir.
2832 int dir_inside_of(const char *subdir
, const char *dir
)
2836 assert(dir
&& subdir
&& *dir
&& *subdir
);
2838 while (*dir
&& *subdir
&& !cmp_icase(*dir
, *subdir
)) {
2844 /* hel[p]/me vs hel[l]/yeah */
2845 if (*dir
&& *subdir
)
2849 return !*dir
? offset
: -1; /* same dir */
2851 /* foo/[b]ar vs foo/[] */
2852 if (is_dir_sep(dir
[-1]))
2853 return is_dir_sep(subdir
[-1]) ? offset
: -1;
2855 /* foo[/]bar vs foo[] */
2856 return is_dir_sep(*subdir
) ? offset
+ 1 : -1;
2859 int is_inside_dir(const char *dir
)
2868 rc
= (dir_inside_of(cwd
, dir
) >= 0);
2873 int is_empty_dir(const char *path
)
2875 DIR *dir
= opendir(path
);
2882 while ((e
= readdir(dir
)) != NULL
)
2883 if (!is_dot_or_dotdot(e
->d_name
)) {
2892 static int remove_dir_recurse(struct strbuf
*path
, int flag
, int *kept_up
)
2896 int ret
= 0, original_len
= path
->len
, len
, kept_down
= 0;
2897 int only_empty
= (flag
& REMOVE_DIR_EMPTY_ONLY
);
2898 int keep_toplevel
= (flag
& REMOVE_DIR_KEEP_TOPLEVEL
);
2899 struct object_id submodule_head
;
2901 if ((flag
& REMOVE_DIR_KEEP_NESTED_GIT
) &&
2902 !resolve_gitlink_ref(path
->buf
, "HEAD", &submodule_head
)) {
2903 /* Do not descend and nuke a nested git work tree. */
2909 flag
&= ~REMOVE_DIR_KEEP_TOPLEVEL
;
2910 dir
= opendir(path
->buf
);
2912 if (errno
== ENOENT
)
2913 return keep_toplevel
? -1 : 0;
2914 else if (errno
== EACCES
&& !keep_toplevel
)
2916 * An empty dir could be removable even if it
2919 return rmdir(path
->buf
);
2923 strbuf_complete(path
, '/');
2926 while ((e
= readdir(dir
)) != NULL
) {
2928 if (is_dot_or_dotdot(e
->d_name
))
2931 strbuf_setlen(path
, len
);
2932 strbuf_addstr(path
, e
->d_name
);
2933 if (lstat(path
->buf
, &st
)) {
2934 if (errno
== ENOENT
)
2936 * file disappeared, which is what we
2941 } else if (S_ISDIR(st
.st_mode
)) {
2942 if (!remove_dir_recurse(path
, flag
, &kept_down
))
2943 continue; /* happy */
2944 } else if (!only_empty
&&
2945 (!unlink(path
->buf
) || errno
== ENOENT
)) {
2946 continue; /* happy, too */
2949 /* path too long, stat fails, or non-directory still exists */
2955 strbuf_setlen(path
, original_len
);
2956 if (!ret
&& !keep_toplevel
&& !kept_down
)
2957 ret
= (!rmdir(path
->buf
) || errno
== ENOENT
) ? 0 : -1;
2960 * report the uplevel that it is not an error that we
2961 * did not rmdir() our directory.
2967 int remove_dir_recursively(struct strbuf
*path
, int flag
)
2969 return remove_dir_recurse(path
, flag
, NULL
);
2972 static GIT_PATH_FUNC(git_path_info_exclude
, "info/exclude")
2974 void setup_standard_excludes(struct dir_struct
*dir
)
2976 dir
->exclude_per_dir
= ".gitignore";
2978 /* core.excludesfile defaulting to $XDG_CONFIG_HOME/git/ignore */
2980 excludes_file
= xdg_config_home("ignore");
2981 if (excludes_file
&& !access_or_warn(excludes_file
, R_OK
, 0))
2982 add_patterns_from_file_1(dir
, excludes_file
,
2983 dir
->untracked
? &dir
->ss_excludes_file
: NULL
);
2985 /* per repository user preference */
2986 if (startup_info
->have_repository
) {
2987 const char *path
= git_path_info_exclude();
2988 if (!access_or_warn(path
, R_OK
, 0))
2989 add_patterns_from_file_1(dir
, path
,
2990 dir
->untracked
? &dir
->ss_info_exclude
: NULL
);
2994 int remove_path(const char *name
)
2998 if (unlink(name
) && !is_missing_file_error(errno
))
3001 slash
= strrchr(name
, '/');
3003 char *dirs
= xstrdup(name
);
3004 slash
= dirs
+ (slash
- name
);
3007 } while (rmdir(dirs
) == 0 && (slash
= strrchr(dirs
, '/')));
3014 * Frees memory within dir which was allocated for exclude lists and
3015 * the exclude_stack. Does not free dir itself.
3017 void clear_directory(struct dir_struct
*dir
)
3020 struct exclude_list_group
*group
;
3021 struct pattern_list
*pl
;
3022 struct exclude_stack
*stk
;
3024 for (i
= EXC_CMDL
; i
<= EXC_FILE
; i
++) {
3025 group
= &dir
->exclude_list_group
[i
];
3026 for (j
= 0; j
< group
->nr
; j
++) {
3029 free((char *)pl
->src
);
3030 clear_pattern_list(pl
);
3035 stk
= dir
->exclude_stack
;
3037 struct exclude_stack
*prev
= stk
->prev
;
3041 strbuf_release(&dir
->basebuf
);
3044 struct ondisk_untracked_cache
{
3045 struct stat_data info_exclude_stat
;
3046 struct stat_data excludes_file_stat
;
3050 #define ouc_offset(x) offsetof(struct ondisk_untracked_cache, x)
3053 int index
; /* number of written untracked_cache_dir */
3054 struct ewah_bitmap
*check_only
; /* from untracked_cache_dir */
3055 struct ewah_bitmap
*valid
; /* from untracked_cache_dir */
3056 struct ewah_bitmap
*sha1_valid
; /* set if exclude_sha1 is not null */
3058 struct strbuf sb_stat
;
3059 struct strbuf sb_sha1
;
3062 static void stat_data_to_disk(struct stat_data
*to
, const struct stat_data
*from
)
3064 to
->sd_ctime
.sec
= htonl(from
->sd_ctime
.sec
);
3065 to
->sd_ctime
.nsec
= htonl(from
->sd_ctime
.nsec
);
3066 to
->sd_mtime
.sec
= htonl(from
->sd_mtime
.sec
);
3067 to
->sd_mtime
.nsec
= htonl(from
->sd_mtime
.nsec
);
3068 to
->sd_dev
= htonl(from
->sd_dev
);
3069 to
->sd_ino
= htonl(from
->sd_ino
);
3070 to
->sd_uid
= htonl(from
->sd_uid
);
3071 to
->sd_gid
= htonl(from
->sd_gid
);
3072 to
->sd_size
= htonl(from
->sd_size
);
3075 static void write_one_dir(struct untracked_cache_dir
*untracked
,
3076 struct write_data
*wd
)
3078 struct stat_data stat_data
;
3079 struct strbuf
*out
= &wd
->out
;
3080 unsigned char intbuf
[16];
3081 unsigned int intlen
, value
;
3082 int i
= wd
->index
++;
3085 * untracked_nr should be reset whenever valid is clear, but
3088 if (!untracked
->valid
) {
3089 untracked
->untracked_nr
= 0;
3090 untracked
->check_only
= 0;
3093 if (untracked
->check_only
)
3094 ewah_set(wd
->check_only
, i
);
3095 if (untracked
->valid
) {
3096 ewah_set(wd
->valid
, i
);
3097 stat_data_to_disk(&stat_data
, &untracked
->stat_data
);
3098 strbuf_add(&wd
->sb_stat
, &stat_data
, sizeof(stat_data
));
3100 if (!is_null_oid(&untracked
->exclude_oid
)) {
3101 ewah_set(wd
->sha1_valid
, i
);
3102 strbuf_add(&wd
->sb_sha1
, untracked
->exclude_oid
.hash
,
3103 the_hash_algo
->rawsz
);
3106 intlen
= encode_varint(untracked
->untracked_nr
, intbuf
);
3107 strbuf_add(out
, intbuf
, intlen
);
3109 /* skip non-recurse directories */
3110 for (i
= 0, value
= 0; i
< untracked
->dirs_nr
; i
++)
3111 if (untracked
->dirs
[i
]->recurse
)
3113 intlen
= encode_varint(value
, intbuf
);
3114 strbuf_add(out
, intbuf
, intlen
);
3116 strbuf_add(out
, untracked
->name
, strlen(untracked
->name
) + 1);
3118 for (i
= 0; i
< untracked
->untracked_nr
; i
++)
3119 strbuf_add(out
, untracked
->untracked
[i
],
3120 strlen(untracked
->untracked
[i
]) + 1);
3122 for (i
= 0; i
< untracked
->dirs_nr
; i
++)
3123 if (untracked
->dirs
[i
]->recurse
)
3124 write_one_dir(untracked
->dirs
[i
], wd
);
3127 void write_untracked_extension(struct strbuf
*out
, struct untracked_cache
*untracked
)
3129 struct ondisk_untracked_cache
*ouc
;
3130 struct write_data wd
;
3131 unsigned char varbuf
[16];
3133 const unsigned hashsz
= the_hash_algo
->rawsz
;
3135 ouc
= xcalloc(1, sizeof(*ouc
));
3136 stat_data_to_disk(&ouc
->info_exclude_stat
, &untracked
->ss_info_exclude
.stat
);
3137 stat_data_to_disk(&ouc
->excludes_file_stat
, &untracked
->ss_excludes_file
.stat
);
3138 ouc
->dir_flags
= htonl(untracked
->dir_flags
);
3140 varint_len
= encode_varint(untracked
->ident
.len
, varbuf
);
3141 strbuf_add(out
, varbuf
, varint_len
);
3142 strbuf_addbuf(out
, &untracked
->ident
);
3144 strbuf_add(out
, ouc
, sizeof(*ouc
));
3145 strbuf_add(out
, untracked
->ss_info_exclude
.oid
.hash
, hashsz
);
3146 strbuf_add(out
, untracked
->ss_excludes_file
.oid
.hash
, hashsz
);
3147 strbuf_add(out
, untracked
->exclude_per_dir
, strlen(untracked
->exclude_per_dir
) + 1);
3150 if (!untracked
->root
) {
3151 varint_len
= encode_varint(0, varbuf
);
3152 strbuf_add(out
, varbuf
, varint_len
);
3157 wd
.check_only
= ewah_new();
3158 wd
.valid
= ewah_new();
3159 wd
.sha1_valid
= ewah_new();
3160 strbuf_init(&wd
.out
, 1024);
3161 strbuf_init(&wd
.sb_stat
, 1024);
3162 strbuf_init(&wd
.sb_sha1
, 1024);
3163 write_one_dir(untracked
->root
, &wd
);
3165 varint_len
= encode_varint(wd
.index
, varbuf
);
3166 strbuf_add(out
, varbuf
, varint_len
);
3167 strbuf_addbuf(out
, &wd
.out
);
3168 ewah_serialize_strbuf(wd
.valid
, out
);
3169 ewah_serialize_strbuf(wd
.check_only
, out
);
3170 ewah_serialize_strbuf(wd
.sha1_valid
, out
);
3171 strbuf_addbuf(out
, &wd
.sb_stat
);
3172 strbuf_addbuf(out
, &wd
.sb_sha1
);
3173 strbuf_addch(out
, '\0'); /* safe guard for string lists */
3175 ewah_free(wd
.valid
);
3176 ewah_free(wd
.check_only
);
3177 ewah_free(wd
.sha1_valid
);
3178 strbuf_release(&wd
.out
);
3179 strbuf_release(&wd
.sb_stat
);
3180 strbuf_release(&wd
.sb_sha1
);
3183 static void free_untracked(struct untracked_cache_dir
*ucd
)
3188 for (i
= 0; i
< ucd
->dirs_nr
; i
++)
3189 free_untracked(ucd
->dirs
[i
]);
3190 for (i
= 0; i
< ucd
->untracked_nr
; i
++)
3191 free(ucd
->untracked
[i
]);
3192 free(ucd
->untracked
);
3197 void free_untracked_cache(struct untracked_cache
*uc
)
3200 free_untracked(uc
->root
);
3206 struct untracked_cache_dir
**ucd
;
3207 struct ewah_bitmap
*check_only
;
3208 struct ewah_bitmap
*valid
;
3209 struct ewah_bitmap
*sha1_valid
;
3210 const unsigned char *data
;
3211 const unsigned char *end
;
3214 static void stat_data_from_disk(struct stat_data
*to
, const unsigned char *data
)
3216 memcpy(to
, data
, sizeof(*to
));
3217 to
->sd_ctime
.sec
= ntohl(to
->sd_ctime
.sec
);
3218 to
->sd_ctime
.nsec
= ntohl(to
->sd_ctime
.nsec
);
3219 to
->sd_mtime
.sec
= ntohl(to
->sd_mtime
.sec
);
3220 to
->sd_mtime
.nsec
= ntohl(to
->sd_mtime
.nsec
);
3221 to
->sd_dev
= ntohl(to
->sd_dev
);
3222 to
->sd_ino
= ntohl(to
->sd_ino
);
3223 to
->sd_uid
= ntohl(to
->sd_uid
);
3224 to
->sd_gid
= ntohl(to
->sd_gid
);
3225 to
->sd_size
= ntohl(to
->sd_size
);
3228 static int read_one_dir(struct untracked_cache_dir
**untracked_
,
3229 struct read_data
*rd
)
3231 struct untracked_cache_dir ud
, *untracked
;
3232 const unsigned char *data
= rd
->data
, *end
= rd
->end
;
3233 const unsigned char *eos
;
3237 memset(&ud
, 0, sizeof(ud
));
3239 value
= decode_varint(&data
);
3243 ud
.untracked_alloc
= value
;
3244 ud
.untracked_nr
= value
;
3245 if (ud
.untracked_nr
)
3246 ALLOC_ARRAY(ud
.untracked
, ud
.untracked_nr
);
3248 ud
.dirs_alloc
= ud
.dirs_nr
= decode_varint(&data
);
3251 ALLOC_ARRAY(ud
.dirs
, ud
.dirs_nr
);
3253 eos
= memchr(data
, '\0', end
- data
);
3254 if (!eos
|| eos
== end
)
3257 *untracked_
= untracked
= xmalloc(st_add3(sizeof(*untracked
), eos
- data
, 1));
3258 memcpy(untracked
, &ud
, sizeof(ud
));
3259 memcpy(untracked
->name
, data
, eos
- data
+ 1);
3262 for (i
= 0; i
< untracked
->untracked_nr
; i
++) {
3263 eos
= memchr(data
, '\0', end
- data
);
3264 if (!eos
|| eos
== end
)
3266 untracked
->untracked
[i
] = xmemdupz(data
, eos
- data
);
3270 rd
->ucd
[rd
->index
++] = untracked
;
3273 for (i
= 0; i
< untracked
->dirs_nr
; i
++) {
3274 if (read_one_dir(untracked
->dirs
+ i
, rd
) < 0)
3280 static void set_check_only(size_t pos
, void *cb
)
3282 struct read_data
*rd
= cb
;
3283 struct untracked_cache_dir
*ud
= rd
->ucd
[pos
];
3287 static void read_stat(size_t pos
, void *cb
)
3289 struct read_data
*rd
= cb
;
3290 struct untracked_cache_dir
*ud
= rd
->ucd
[pos
];
3291 if (rd
->data
+ sizeof(struct stat_data
) > rd
->end
) {
3292 rd
->data
= rd
->end
+ 1;
3295 stat_data_from_disk(&ud
->stat_data
, rd
->data
);
3296 rd
->data
+= sizeof(struct stat_data
);
3300 static void read_oid(size_t pos
, void *cb
)
3302 struct read_data
*rd
= cb
;
3303 struct untracked_cache_dir
*ud
= rd
->ucd
[pos
];
3304 if (rd
->data
+ the_hash_algo
->rawsz
> rd
->end
) {
3305 rd
->data
= rd
->end
+ 1;
3308 hashcpy(ud
->exclude_oid
.hash
, rd
->data
);
3309 rd
->data
+= the_hash_algo
->rawsz
;
3312 static void load_oid_stat(struct oid_stat
*oid_stat
, const unsigned char *data
,
3313 const unsigned char *sha1
)
3315 stat_data_from_disk(&oid_stat
->stat
, data
);
3316 hashcpy(oid_stat
->oid
.hash
, sha1
);
3317 oid_stat
->valid
= 1;
3320 struct untracked_cache
*read_untracked_extension(const void *data
, unsigned long sz
)
3322 struct untracked_cache
*uc
;
3323 struct read_data rd
;
3324 const unsigned char *next
= data
, *end
= (const unsigned char *)data
+ sz
;
3328 const char *exclude_per_dir
;
3329 const unsigned hashsz
= the_hash_algo
->rawsz
;
3330 const unsigned offset
= sizeof(struct ondisk_untracked_cache
);
3331 const unsigned exclude_per_dir_offset
= offset
+ 2 * hashsz
;
3333 if (sz
<= 1 || end
[-1] != '\0')
3337 ident_len
= decode_varint(&next
);
3338 if (next
+ ident_len
> end
)
3340 ident
= (const char *)next
;
3343 if (next
+ exclude_per_dir_offset
+ 1 > end
)
3346 uc
= xcalloc(1, sizeof(*uc
));
3347 strbuf_init(&uc
->ident
, ident_len
);
3348 strbuf_add(&uc
->ident
, ident
, ident_len
);
3349 load_oid_stat(&uc
->ss_info_exclude
,
3350 next
+ ouc_offset(info_exclude_stat
),
3352 load_oid_stat(&uc
->ss_excludes_file
,
3353 next
+ ouc_offset(excludes_file_stat
),
3354 next
+ offset
+ hashsz
);
3355 uc
->dir_flags
= get_be32(next
+ ouc_offset(dir_flags
));
3356 exclude_per_dir
= (const char *)next
+ exclude_per_dir_offset
;
3357 uc
->exclude_per_dir
= xstrdup(exclude_per_dir
);
3358 /* NUL after exclude_per_dir is covered by sizeof(*ouc) */
3359 next
+= exclude_per_dir_offset
+ strlen(exclude_per_dir
) + 1;
3363 len
= decode_varint(&next
);
3364 if (next
> end
|| len
== 0)
3367 rd
.valid
= ewah_new();
3368 rd
.check_only
= ewah_new();
3369 rd
.sha1_valid
= ewah_new();
3373 ALLOC_ARRAY(rd
.ucd
, len
);
3375 if (read_one_dir(&uc
->root
, &rd
) || rd
.index
!= len
)
3379 len
= ewah_read_mmap(rd
.valid
, next
, end
- next
);
3384 len
= ewah_read_mmap(rd
.check_only
, next
, end
- next
);
3389 len
= ewah_read_mmap(rd
.sha1_valid
, next
, end
- next
);
3393 ewah_each_bit(rd
.check_only
, set_check_only
, &rd
);
3394 rd
.data
= next
+ len
;
3395 ewah_each_bit(rd
.valid
, read_stat
, &rd
);
3396 ewah_each_bit(rd
.sha1_valid
, read_oid
, &rd
);
3401 ewah_free(rd
.valid
);
3402 ewah_free(rd
.check_only
);
3403 ewah_free(rd
.sha1_valid
);
3406 free_untracked_cache(uc
);
3412 static void invalidate_one_directory(struct untracked_cache
*uc
,
3413 struct untracked_cache_dir
*ucd
)
3415 uc
->dir_invalidated
++;
3417 ucd
->untracked_nr
= 0;
3421 * Normally when an entry is added or removed from a directory,
3422 * invalidating that directory is enough. No need to touch its
3423 * ancestors. When a directory is shown as "foo/bar/" in git-status
3424 * however, deleting or adding an entry may have cascading effect.
3426 * Say the "foo/bar/file" has become untracked, we need to tell the
3427 * untracked_cache_dir of "foo" that "bar/" is not an untracked
3428 * directory any more (because "bar" is managed by foo as an untracked
3431 * Similarly, if "foo/bar/file" moves from untracked to tracked and it
3432 * was the last untracked entry in the entire "foo", we should show
3433 * "foo/" instead. Which means we have to invalidate past "bar" up to
3436 * This function traverses all directories from root to leaf. If there
3437 * is a chance of one of the above cases happening, we invalidate back
3438 * to root. Otherwise we just invalidate the leaf. There may be a more
3439 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to
3440 * detect these cases and avoid unnecessary invalidation, for example,
3441 * checking for the untracked entry named "bar/" in "foo", but for now
3442 * stick to something safe and simple.
3444 static int invalidate_one_component(struct untracked_cache
*uc
,
3445 struct untracked_cache_dir
*dir
,
3446 const char *path
, int len
)
3448 const char *rest
= strchr(path
, '/');
3451 int component_len
= rest
- path
;
3452 struct untracked_cache_dir
*d
=
3453 lookup_untracked(uc
, dir
, path
, component_len
);
3455 invalidate_one_component(uc
, d
, rest
+ 1,
3456 len
- (component_len
+ 1));
3458 invalidate_one_directory(uc
, dir
);
3462 invalidate_one_directory(uc
, dir
);
3463 return uc
->dir_flags
& DIR_SHOW_OTHER_DIRECTORIES
;
3466 void untracked_cache_invalidate_path(struct index_state
*istate
,
3467 const char *path
, int safe_path
)
3469 if (!istate
->untracked
|| !istate
->untracked
->root
)
3471 if (!safe_path
&& !verify_path(path
, 0))
3473 invalidate_one_component(istate
->untracked
, istate
->untracked
->root
,
3474 path
, strlen(path
));
3477 void untracked_cache_remove_from_index(struct index_state
*istate
,
3480 untracked_cache_invalidate_path(istate
, path
, 1);
3483 void untracked_cache_add_to_index(struct index_state
*istate
,
3486 untracked_cache_invalidate_path(istate
, path
, 1);
3489 static void connect_wt_gitdir_in_nested(const char *sub_worktree
,
3490 const char *sub_gitdir
)
3493 struct repository subrepo
;
3494 struct strbuf sub_wt
= STRBUF_INIT
;
3495 struct strbuf sub_gd
= STRBUF_INIT
;
3497 const struct submodule
*sub
;
3499 /* If the submodule has no working tree, we can ignore it. */
3500 if (repo_init(&subrepo
, sub_gitdir
, sub_worktree
))
3503 if (repo_read_index(&subrepo
) < 0)
3504 die(_("index file corrupt in repo %s"), subrepo
.gitdir
);
3506 for (i
= 0; i
< subrepo
.index
->cache_nr
; i
++) {
3507 const struct cache_entry
*ce
= subrepo
.index
->cache
[i
];
3509 if (!S_ISGITLINK(ce
->ce_mode
))
3512 while (i
+ 1 < subrepo
.index
->cache_nr
&&
3513 !strcmp(ce
->name
, subrepo
.index
->cache
[i
+ 1]->name
))
3515 * Skip entries with the same name in different stages
3516 * to make sure an entry is returned only once.
3520 sub
= submodule_from_path(&subrepo
, &null_oid
, ce
->name
);
3521 if (!sub
|| !is_submodule_active(&subrepo
, ce
->name
))
3522 /* .gitmodules broken or inactive sub */
3525 strbuf_reset(&sub_wt
);
3526 strbuf_reset(&sub_gd
);
3527 strbuf_addf(&sub_wt
, "%s/%s", sub_worktree
, sub
->path
);
3528 strbuf_addf(&sub_gd
, "%s/modules/%s", sub_gitdir
, sub
->name
);
3530 connect_work_tree_and_git_dir(sub_wt
.buf
, sub_gd
.buf
, 1);
3532 strbuf_release(&sub_wt
);
3533 strbuf_release(&sub_gd
);
3534 repo_clear(&subrepo
);
3537 void connect_work_tree_and_git_dir(const char *work_tree_
,
3538 const char *git_dir_
,
3539 int recurse_into_nested
)
3541 struct strbuf gitfile_sb
= STRBUF_INIT
;
3542 struct strbuf cfg_sb
= STRBUF_INIT
;
3543 struct strbuf rel_path
= STRBUF_INIT
;
3544 char *git_dir
, *work_tree
;
3546 /* Prepare .git file */
3547 strbuf_addf(&gitfile_sb
, "%s/.git", work_tree_
);
3548 if (safe_create_leading_directories_const(gitfile_sb
.buf
))
3549 die(_("could not create directories for %s"), gitfile_sb
.buf
);
3551 /* Prepare config file */
3552 strbuf_addf(&cfg_sb
, "%s/config", git_dir_
);
3553 if (safe_create_leading_directories_const(cfg_sb
.buf
))
3554 die(_("could not create directories for %s"), cfg_sb
.buf
);
3556 git_dir
= real_pathdup(git_dir_
, 1);
3557 work_tree
= real_pathdup(work_tree_
, 1);
3559 /* Write .git file */
3560 write_file(gitfile_sb
.buf
, "gitdir: %s",
3561 relative_path(git_dir
, work_tree
, &rel_path
));
3562 /* Update core.worktree setting */
3563 git_config_set_in_file(cfg_sb
.buf
, "core.worktree",
3564 relative_path(work_tree
, git_dir
, &rel_path
));
3566 strbuf_release(&gitfile_sb
);
3567 strbuf_release(&cfg_sb
);
3568 strbuf_release(&rel_path
);
3570 if (recurse_into_nested
)
3571 connect_wt_gitdir_in_nested(work_tree
, git_dir
);
3578 * Migrate the git directory of the given path from old_git_dir to new_git_dir.
3580 void relocate_gitdir(const char *path
, const char *old_git_dir
, const char *new_git_dir
)
3582 if (rename(old_git_dir
, new_git_dir
) < 0)
3583 die_errno(_("could not migrate git directory from '%s' to '%s'"),
3584 old_git_dir
, new_git_dir
);
3586 connect_work_tree_and_git_dir(path
, new_git_dir
, 0);