2 * This handles recursive filename detection with exclude
3 * files, index knowledge etc..
5 * See Documentation/technical/api-directory-listing.txt
7 * Copyright (C) Linus Torvalds, 2005-2006
8 * Junio Hamano, 2005-2006
10 #define NO_THE_INDEX_COMPATIBILITY_MACROS
15 #include "wildmatch.h"
19 #include "ewah/ewok.h"
22 * Tells read_directory_recursive how a file or directory should be treated.
23 * Values are ordered by significance, e.g. if a directory contains both
24 * excluded and untracked files, it is listed as untracked because
25 * path_untracked > path_excluded.
35 * Support data structure for our opendir/readdir/closedir wrappers
39 struct untracked_cache_dir
*untracked
;
45 struct untracked_cache_dir
*ucd
;
48 static enum path_treatment
read_directory_recursive(struct dir_struct
*dir
,
49 struct index_state
*istate
, const char *path
, int len
,
50 struct untracked_cache_dir
*untracked
,
51 int check_only
, const struct pathspec
*pathspec
);
52 static int get_dtype(struct dirent
*de
, struct index_state
*istate
,
53 const char *path
, int len
);
55 int fspathcmp(const char *a
, const char *b
)
57 return ignore_case
? strcasecmp(a
, b
) : strcmp(a
, b
);
60 int fspathncmp(const char *a
, const char *b
, size_t count
)
62 return ignore_case
? strncasecmp(a
, b
, count
) : strncmp(a
, b
, count
);
65 int git_fnmatch(const struct pathspec_item
*item
,
66 const char *pattern
, const char *string
,
70 if (ps_strncmp(item
, pattern
, string
, prefix
))
75 if (item
->flags
& PATHSPEC_ONESTAR
) {
76 int pattern_len
= strlen(++pattern
);
77 int string_len
= strlen(string
);
78 return string_len
< pattern_len
||
79 ps_strcmp(item
, pattern
,
80 string
+ string_len
- pattern_len
);
82 if (item
->magic
& PATHSPEC_GLOB
)
83 return wildmatch(pattern
, string
,
85 (item
->magic
& PATHSPEC_ICASE
? WM_CASEFOLD
: 0),
88 /* wildmatch has not learned no FNM_PATHNAME mode yet */
89 return wildmatch(pattern
, string
,
90 item
->magic
& PATHSPEC_ICASE
? WM_CASEFOLD
: 0,
94 static int fnmatch_icase_mem(const char *pattern
, int patternlen
,
95 const char *string
, int stringlen
,
99 struct strbuf pat_buf
= STRBUF_INIT
;
100 struct strbuf str_buf
= STRBUF_INIT
;
101 const char *use_pat
= pattern
;
102 const char *use_str
= string
;
104 if (pattern
[patternlen
]) {
105 strbuf_add(&pat_buf
, pattern
, patternlen
);
106 use_pat
= pat_buf
.buf
;
108 if (string
[stringlen
]) {
109 strbuf_add(&str_buf
, string
, stringlen
);
110 use_str
= str_buf
.buf
;
114 flags
|= WM_CASEFOLD
;
115 match_status
= wildmatch(use_pat
, use_str
, flags
, NULL
);
117 strbuf_release(&pat_buf
);
118 strbuf_release(&str_buf
);
123 static size_t common_prefix_len(const struct pathspec
*pathspec
)
129 * ":(icase)path" is treated as a pathspec full of
130 * wildcard. In other words, only prefix is considered common
131 * prefix. If the pathspec is abc/foo abc/bar, running in
132 * subdir xyz, the common prefix is still xyz, not xuz/abc as
135 GUARD_PATHSPEC(pathspec
,
144 for (n
= 0; n
< pathspec
->nr
; n
++) {
145 size_t i
= 0, len
= 0, item_len
;
146 if (pathspec
->items
[n
].magic
& PATHSPEC_EXCLUDE
)
148 if (pathspec
->items
[n
].magic
& PATHSPEC_ICASE
)
149 item_len
= pathspec
->items
[n
].prefix
;
151 item_len
= pathspec
->items
[n
].nowildcard_len
;
152 while (i
< item_len
&& (n
== 0 || i
< max
)) {
153 char c
= pathspec
->items
[n
].match
[i
];
154 if (c
!= pathspec
->items
[0].match
[i
])
160 if (n
== 0 || len
< max
) {
170 * Returns a copy of the longest leading path common among all
173 char *common_prefix(const struct pathspec
*pathspec
)
175 unsigned long len
= common_prefix_len(pathspec
);
177 return len
? xmemdupz(pathspec
->items
[0].match
, len
) : NULL
;
180 int fill_directory(struct dir_struct
*dir
, const struct pathspec
*pathspec
)
186 * Calculate common prefix for the pathspec, and
187 * use that to optimize the directory walk
189 prefix_len
= common_prefix_len(pathspec
);
190 prefix
= prefix_len
? pathspec
->items
[0].match
: "";
192 /* Read the directory and prune it */
193 read_directory(dir
, prefix
, prefix_len
, pathspec
);
198 int within_depth(const char *name
, int namelen
,
199 int depth
, int max_depth
)
201 const char *cp
= name
, *cpe
= name
+ namelen
;
207 if (depth
> max_depth
)
213 #define DO_MATCH_EXCLUDE (1<<0)
214 #define DO_MATCH_DIRECTORY (1<<1)
215 #define DO_MATCH_SUBMODULE (1<<2)
217 static int match_attrs(const char *name
, int namelen
,
218 const struct pathspec_item
*item
)
222 git_check_attr(name
, item
->attr_check
);
223 for (i
= 0; i
< item
->attr_match_nr
; i
++) {
226 enum attr_match_mode match_mode
;
228 value
= item
->attr_check
->items
[i
].value
;
229 match_mode
= item
->attr_match
[i
].match_mode
;
231 if (ATTR_TRUE(value
))
232 matched
= (match_mode
== MATCH_SET
);
233 else if (ATTR_FALSE(value
))
234 matched
= (match_mode
== MATCH_UNSET
);
235 else if (ATTR_UNSET(value
))
236 matched
= (match_mode
== MATCH_UNSPECIFIED
);
238 matched
= (match_mode
== MATCH_VALUE
&&
239 !strcmp(item
->attr_match
[i
].value
, value
));
248 * Does 'match' match the given name?
249 * A match is found if
251 * (1) the 'match' string is leading directory of 'name', or
252 * (2) the 'match' string is a wildcard and matches 'name', or
253 * (3) the 'match' string is exactly the same as 'name'.
255 * and the return value tells which case it was.
257 * It returns 0 when there is no match.
259 static int match_pathspec_item(const struct pathspec_item
*item
, int prefix
,
260 const char *name
, int namelen
, unsigned flags
)
262 /* name/namelen has prefix cut off by caller */
263 const char *match
= item
->match
+ prefix
;
264 int matchlen
= item
->len
- prefix
;
267 * The normal call pattern is:
268 * 1. prefix = common_prefix_len(ps);
269 * 2. prune something, or fill_directory
270 * 3. match_pathspec()
272 * 'prefix' at #1 may be shorter than the command's prefix and
273 * it's ok for #2 to match extra files. Those extras will be
276 * Suppose the pathspec is 'foo' and '../bar' running from
277 * subdir 'xyz'. The common prefix at #1 will be empty, thanks
278 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The
279 * user does not want XYZ/foo, only the "foo" part should be
280 * case-insensitive. We need to filter out XYZ/foo here. In
281 * other words, we do not trust the caller on comparing the
282 * prefix part when :(icase) is involved. We do exact
283 * comparison ourselves.
285 * Normally the caller (common_prefix_len() in fact) does
286 * _exact_ matching on name[-prefix+1..-1] and we do not need
287 * to check that part. Be defensive and check it anyway, in
288 * case common_prefix_len is changed, or a new caller is
289 * introduced that does not use common_prefix_len.
291 * If the penalty turns out too high when prefix is really
292 * long, maybe change it to
293 * strncmp(match, name, item->prefix - prefix)
295 if (item
->prefix
&& (item
->magic
& PATHSPEC_ICASE
) &&
296 strncmp(item
->match
, name
- prefix
, item
->prefix
))
299 if (item
->attr_match_nr
&& !match_attrs(name
, namelen
, item
))
302 /* If the match was just the prefix, we matched */
304 return MATCHED_RECURSIVELY
;
306 if (matchlen
<= namelen
&& !ps_strncmp(item
, match
, name
, matchlen
)) {
307 if (matchlen
== namelen
)
308 return MATCHED_EXACTLY
;
310 if (match
[matchlen
-1] == '/' || name
[matchlen
] == '/')
311 return MATCHED_RECURSIVELY
;
312 } else if ((flags
& DO_MATCH_DIRECTORY
) &&
313 match
[matchlen
- 1] == '/' &&
314 namelen
== matchlen
- 1 &&
315 !ps_strncmp(item
, match
, name
, namelen
))
316 return MATCHED_EXACTLY
;
318 if (item
->nowildcard_len
< item
->len
&&
319 !git_fnmatch(item
, match
, name
,
320 item
->nowildcard_len
- prefix
))
321 return MATCHED_FNMATCH
;
323 /* Perform checks to see if "name" is a super set of the pathspec */
324 if (flags
& DO_MATCH_SUBMODULE
) {
325 /* name is a literal prefix of the pathspec */
326 if ((namelen
< matchlen
) &&
327 (match
[namelen
] == '/') &&
328 !ps_strncmp(item
, match
, name
, namelen
))
329 return MATCHED_RECURSIVELY
;
331 /* name" doesn't match up to the first wild character */
332 if (item
->nowildcard_len
< item
->len
&&
333 ps_strncmp(item
, match
, name
,
334 item
->nowildcard_len
- prefix
))
338 * Here is where we would perform a wildmatch to check if
339 * "name" can be matched as a directory (or a prefix) against
340 * the pathspec. Since wildmatch doesn't have this capability
341 * at the present we have to punt and say that it is a match,
342 * potentially returning a false positive
343 * The submodules themselves will be able to perform more
344 * accurate matching to determine if the pathspec matches.
346 return MATCHED_RECURSIVELY
;
353 * Given a name and a list of pathspecs, returns the nature of the
354 * closest (i.e. most specific) match of the name to any of the
357 * The caller typically calls this multiple times with the same
358 * pathspec and seen[] array but with different name/namelen
359 * (e.g. entries from the index) and is interested in seeing if and
360 * how each pathspec matches all the names it calls this function
361 * with. A mark is left in the seen[] array for each pathspec element
362 * indicating the closest type of match that element achieved, so if
363 * seen[n] remains zero after multiple invocations, that means the nth
364 * pathspec did not match any names, which could indicate that the
365 * user mistyped the nth pathspec.
367 static int do_match_pathspec(const struct pathspec
*ps
,
368 const char *name
, int namelen
,
369 int prefix
, char *seen
,
372 int i
, retval
= 0, exclude
= flags
& DO_MATCH_EXCLUDE
;
384 if (!ps
->recursive
||
385 !(ps
->magic
& PATHSPEC_MAXDEPTH
) ||
387 return MATCHED_RECURSIVELY
;
389 if (within_depth(name
, namelen
, 0, ps
->max_depth
))
390 return MATCHED_EXACTLY
;
398 for (i
= ps
->nr
- 1; i
>= 0; i
--) {
401 if ((!exclude
&& ps
->items
[i
].magic
& PATHSPEC_EXCLUDE
) ||
402 ( exclude
&& !(ps
->items
[i
].magic
& PATHSPEC_EXCLUDE
)))
405 if (seen
&& seen
[i
] == MATCHED_EXACTLY
)
408 * Make exclude patterns optional and never report
409 * "pathspec ':(exclude)foo' matches no files"
411 if (seen
&& ps
->items
[i
].magic
& PATHSPEC_EXCLUDE
)
412 seen
[i
] = MATCHED_FNMATCH
;
413 how
= match_pathspec_item(ps
->items
+i
, prefix
, name
,
416 (ps
->magic
& PATHSPEC_MAXDEPTH
) &&
417 ps
->max_depth
!= -1 &&
418 how
&& how
!= MATCHED_FNMATCH
) {
419 int len
= ps
->items
[i
].len
;
420 if (name
[len
] == '/')
422 if (within_depth(name
+len
, namelen
-len
, 0, ps
->max_depth
))
423 how
= MATCHED_EXACTLY
;
430 if (seen
&& seen
[i
] < how
)
437 int match_pathspec(const struct pathspec
*ps
,
438 const char *name
, int namelen
,
439 int prefix
, char *seen
, int is_dir
)
441 int positive
, negative
;
442 unsigned flags
= is_dir
? DO_MATCH_DIRECTORY
: 0;
443 positive
= do_match_pathspec(ps
, name
, namelen
,
444 prefix
, seen
, flags
);
445 if (!(ps
->magic
& PATHSPEC_EXCLUDE
) || !positive
)
447 negative
= do_match_pathspec(ps
, name
, namelen
,
449 flags
| DO_MATCH_EXCLUDE
);
450 return negative
? 0 : positive
;
454 * Check if a submodule is a superset of the pathspec
456 int submodule_path_match(const struct pathspec
*ps
,
457 const char *submodule_name
,
460 int matched
= do_match_pathspec(ps
, submodule_name
,
461 strlen(submodule_name
),
468 int report_path_error(const char *ps_matched
,
469 const struct pathspec
*pathspec
,
473 * Make sure all pathspec matched; otherwise it is an error.
476 for (num
= 0; num
< pathspec
->nr
; num
++) {
477 int other
, found_dup
;
482 * The caller might have fed identical pathspec
483 * twice. Do not barf on such a mistake.
484 * FIXME: parse_pathspec should have eliminated
485 * duplicate pathspec.
487 for (found_dup
= other
= 0;
488 !found_dup
&& other
< pathspec
->nr
;
490 if (other
== num
|| !ps_matched
[other
])
492 if (!strcmp(pathspec
->items
[other
].original
,
493 pathspec
->items
[num
].original
))
495 * Ok, we have a match already.
502 error("pathspec '%s' did not match any file(s) known to git.",
503 pathspec
->items
[num
].original
);
510 * Return the length of the "simple" part of a path match limiter.
512 int simple_length(const char *match
)
517 unsigned char c
= *match
++;
519 if (c
== '\0' || is_glob_special(c
))
524 int no_wildcard(const char *string
)
526 return string
[simple_length(string
)] == '\0';
529 void parse_exclude_pattern(const char **pattern
,
534 const char *p
= *pattern
;
539 *flags
|= EXC_FLAG_NEGATIVE
;
543 if (len
&& p
[len
- 1] == '/') {
545 *flags
|= EXC_FLAG_MUSTBEDIR
;
547 for (i
= 0; i
< len
; i
++) {
552 *flags
|= EXC_FLAG_NODIR
;
553 *nowildcardlen
= simple_length(p
);
555 * we should have excluded the trailing slash from 'p' too,
556 * but that's one more allocation. Instead just make sure
557 * nowildcardlen does not exceed real patternlen
559 if (*nowildcardlen
> len
)
560 *nowildcardlen
= len
;
561 if (*p
== '*' && no_wildcard(p
+ 1))
562 *flags
|= EXC_FLAG_ENDSWITH
;
567 void add_exclude(const char *string
, const char *base
,
568 int baselen
, struct exclude_list
*el
, int srcpos
)
575 parse_exclude_pattern(&string
, &patternlen
, &flags
, &nowildcardlen
);
576 if (flags
& EXC_FLAG_MUSTBEDIR
) {
577 FLEXPTR_ALLOC_MEM(x
, pattern
, string
, patternlen
);
579 x
= xmalloc(sizeof(*x
));
582 x
->patternlen
= patternlen
;
583 x
->nowildcardlen
= nowildcardlen
;
585 x
->baselen
= baselen
;
588 ALLOC_GROW(el
->excludes
, el
->nr
+ 1, el
->alloc
);
589 el
->excludes
[el
->nr
++] = x
;
593 static void *read_skip_worktree_file_from_index(const struct index_state
*istate
,
594 const char *path
, size_t *size
,
595 struct sha1_stat
*sha1_stat
)
599 enum object_type type
;
603 pos
= index_name_pos(istate
, path
, len
);
606 if (!ce_skip_worktree(istate
->cache
[pos
]))
608 data
= read_sha1_file(istate
->cache
[pos
]->oid
.hash
, &type
, &sz
);
609 if (!data
|| type
!= OBJ_BLOB
) {
615 memset(&sha1_stat
->stat
, 0, sizeof(sha1_stat
->stat
));
616 hashcpy(sha1_stat
->sha1
, istate
->cache
[pos
]->oid
.hash
);
622 * Frees memory within el which was allocated for exclude patterns and
623 * the file buffer. Does not free el itself.
625 void clear_exclude_list(struct exclude_list
*el
)
629 for (i
= 0; i
< el
->nr
; i
++)
630 free(el
->excludes
[i
]);
634 memset(el
, 0, sizeof(*el
));
637 static void trim_trailing_spaces(char *buf
)
639 char *p
, *last_space
= NULL
;
641 for (p
= buf
; *p
; p
++)
661 * Given a subdirectory name and "dir" of the current directory,
662 * search the subdir in "dir" and return it, or create a new one if it
663 * does not exist in "dir".
665 * If "name" has the trailing slash, it'll be excluded in the search.
667 static struct untracked_cache_dir
*lookup_untracked(struct untracked_cache
*uc
,
668 struct untracked_cache_dir
*dir
,
669 const char *name
, int len
)
672 struct untracked_cache_dir
*d
;
675 if (len
&& name
[len
- 1] == '/')
679 while (last
> first
) {
680 int cmp
, next
= (last
+ first
) >> 1;
682 cmp
= strncmp(name
, d
->name
, len
);
683 if (!cmp
&& strlen(d
->name
) > len
)
695 FLEX_ALLOC_MEM(d
, name
, name
, len
);
697 ALLOC_GROW(dir
->dirs
, dir
->dirs_nr
+ 1, dir
->dirs_alloc
);
698 memmove(dir
->dirs
+ first
+ 1, dir
->dirs
+ first
,
699 (dir
->dirs_nr
- first
) * sizeof(*dir
->dirs
));
701 dir
->dirs
[first
] = d
;
705 static void do_invalidate_gitignore(struct untracked_cache_dir
*dir
)
709 dir
->untracked_nr
= 0;
710 for (i
= 0; i
< dir
->dirs_nr
; i
++)
711 do_invalidate_gitignore(dir
->dirs
[i
]);
714 static void invalidate_gitignore(struct untracked_cache
*uc
,
715 struct untracked_cache_dir
*dir
)
717 uc
->gitignore_invalidated
++;
718 do_invalidate_gitignore(dir
);
721 static void invalidate_directory(struct untracked_cache
*uc
,
722 struct untracked_cache_dir
*dir
)
725 uc
->dir_invalidated
++;
727 dir
->untracked_nr
= 0;
728 for (i
= 0; i
< dir
->dirs_nr
; i
++)
729 dir
->dirs
[i
]->recurse
= 0;
733 * Given a file with name "fname", read it (either from disk, or from
734 * an index if 'istate' is non-null), parse it and store the
735 * exclude rules in "el".
737 * If "ss" is not NULL, compute SHA-1 of the exclude file and fill
738 * stat data from disk (only valid if add_excludes returns zero). If
739 * ss_valid is non-zero, "ss" must contain good value as input.
741 static int add_excludes(const char *fname
, const char *base
, int baselen
,
742 struct exclude_list
*el
,
743 struct index_state
*istate
,
744 struct sha1_stat
*sha1_stat
)
747 int fd
, i
, lineno
= 1;
751 fd
= open(fname
, O_RDONLY
);
752 if (fd
< 0 || fstat(fd
, &st
) < 0) {
754 warn_on_inaccessible(fname
);
758 (buf
= read_skip_worktree_file_from_index(istate
, fname
, &size
, sha1_stat
)) == NULL
)
764 if (buf
[size
-1] != '\n') {
765 buf
= xrealloc(buf
, st_add(size
, 1));
769 size
= xsize_t(st
.st_size
);
772 fill_stat_data(&sha1_stat
->stat
, &st
);
773 hashcpy(sha1_stat
->sha1
, EMPTY_BLOB_SHA1_BIN
);
774 sha1_stat
->valid
= 1;
779 buf
= xmallocz(size
);
780 if (read_in_full(fd
, buf
, size
) != size
) {
789 if (sha1_stat
->valid
&&
790 !match_stat_data_racy(istate
, &sha1_stat
->stat
, &st
))
791 ; /* no content change, ss->sha1 still good */
793 (pos
= index_name_pos(istate
, fname
, strlen(fname
))) >= 0 &&
794 !ce_stage(istate
->cache
[pos
]) &&
795 ce_uptodate(istate
->cache
[pos
]) &&
796 !would_convert_to_git(fname
))
797 hashcpy(sha1_stat
->sha1
,
798 istate
->cache
[pos
]->oid
.hash
);
800 hash_sha1_file(buf
, size
, "blob", sha1_stat
->sha1
);
801 fill_stat_data(&sha1_stat
->stat
, &st
);
802 sha1_stat
->valid
= 1;
808 if (skip_utf8_bom(&buf
, size
))
809 size
-= buf
- el
->filebuf
;
813 for (i
= 0; i
< size
; i
++) {
814 if (buf
[i
] == '\n') {
815 if (entry
!= buf
+ i
&& entry
[0] != '#') {
816 buf
[i
- (i
&& buf
[i
-1] == '\r')] = 0;
817 trim_trailing_spaces(entry
);
818 add_exclude(entry
, base
, baselen
, el
, lineno
);
827 int add_excludes_from_file_to_list(const char *fname
, const char *base
,
828 int baselen
, struct exclude_list
*el
,
829 struct index_state
*istate
)
831 return add_excludes(fname
, base
, baselen
, el
, istate
, NULL
);
834 struct exclude_list
*add_exclude_list(struct dir_struct
*dir
,
835 int group_type
, const char *src
)
837 struct exclude_list
*el
;
838 struct exclude_list_group
*group
;
840 group
= &dir
->exclude_list_group
[group_type
];
841 ALLOC_GROW(group
->el
, group
->nr
+ 1, group
->alloc
);
842 el
= &group
->el
[group
->nr
++];
843 memset(el
, 0, sizeof(*el
));
849 * Used to set up core.excludesfile and .git/info/exclude lists.
851 static void add_excludes_from_file_1(struct dir_struct
*dir
, const char *fname
,
852 struct sha1_stat
*sha1_stat
)
854 struct exclude_list
*el
;
856 * catch setup_standard_excludes() that's called before
857 * dir->untracked is assigned. That function behaves
858 * differently when dir->untracked is non-NULL.
861 dir
->unmanaged_exclude_files
++;
862 el
= add_exclude_list(dir
, EXC_FILE
, fname
);
863 if (add_excludes(fname
, "", 0, el
, NULL
, sha1_stat
) < 0)
864 die("cannot use %s as an exclude file", fname
);
867 void add_excludes_from_file(struct dir_struct
*dir
, const char *fname
)
869 dir
->unmanaged_exclude_files
++; /* see validate_untracked_cache() */
870 add_excludes_from_file_1(dir
, fname
, NULL
);
873 int match_basename(const char *basename
, int basenamelen
,
874 const char *pattern
, int prefix
, int patternlen
,
877 if (prefix
== patternlen
) {
878 if (patternlen
== basenamelen
&&
879 !fspathncmp(pattern
, basename
, basenamelen
))
881 } else if (flags
& EXC_FLAG_ENDSWITH
) {
882 /* "*literal" matching against "fooliteral" */
883 if (patternlen
- 1 <= basenamelen
&&
884 !fspathncmp(pattern
+ 1,
885 basename
+ basenamelen
- (patternlen
- 1),
889 if (fnmatch_icase_mem(pattern
, patternlen
,
890 basename
, basenamelen
,
897 int match_pathname(const char *pathname
, int pathlen
,
898 const char *base
, int baselen
,
899 const char *pattern
, int prefix
, int patternlen
,
906 * match with FNM_PATHNAME; the pattern has base implicitly
909 if (*pattern
== '/') {
916 * baselen does not count the trailing slash. base[] may or
917 * may not end with a trailing slash though.
919 if (pathlen
< baselen
+ 1 ||
920 (baselen
&& pathname
[baselen
] != '/') ||
921 fspathncmp(pathname
, base
, baselen
))
924 namelen
= baselen
? pathlen
- baselen
- 1 : pathlen
;
925 name
= pathname
+ pathlen
- namelen
;
929 * if the non-wildcard part is longer than the
930 * remaining pathname, surely it cannot match.
932 if (prefix
> namelen
)
935 if (fspathncmp(pattern
, name
, prefix
))
938 patternlen
-= prefix
;
943 * If the whole pattern did not have a wildcard,
944 * then our prefix match is all we need; we
945 * do not need to call fnmatch at all.
947 if (!patternlen
&& !namelen
)
951 return fnmatch_icase_mem(pattern
, patternlen
,
957 * Scan the given exclude list in reverse to see whether pathname
958 * should be ignored. The first match (i.e. the last on the list), if
959 * any, determines the fate. Returns the exclude_list element which
960 * matched, or NULL for undecided.
962 static struct exclude
*last_exclude_matching_from_list(const char *pathname
,
964 const char *basename
,
966 struct exclude_list
*el
,
967 struct index_state
*istate
)
969 struct exclude
*exc
= NULL
; /* undecided */
973 return NULL
; /* undefined */
975 for (i
= el
->nr
- 1; 0 <= i
; i
--) {
976 struct exclude
*x
= el
->excludes
[i
];
977 const char *exclude
= x
->pattern
;
978 int prefix
= x
->nowildcardlen
;
980 if (x
->flags
& EXC_FLAG_MUSTBEDIR
) {
981 if (*dtype
== DT_UNKNOWN
)
982 *dtype
= get_dtype(NULL
, istate
, pathname
, pathlen
);
983 if (*dtype
!= DT_DIR
)
987 if (x
->flags
& EXC_FLAG_NODIR
) {
988 if (match_basename(basename
,
989 pathlen
- (basename
- pathname
),
990 exclude
, prefix
, x
->patternlen
,
998 assert(x
->baselen
== 0 || x
->base
[x
->baselen
- 1] == '/');
999 if (match_pathname(pathname
, pathlen
,
1000 x
->base
, x
->baselen
? x
->baselen
- 1 : 0,
1001 exclude
, prefix
, x
->patternlen
, x
->flags
)) {
1010 * Scan the list and let the last match determine the fate.
1011 * Return 1 for exclude, 0 for include and -1 for undecided.
1013 int is_excluded_from_list(const char *pathname
,
1014 int pathlen
, const char *basename
, int *dtype
,
1015 struct exclude_list
*el
, struct index_state
*istate
)
1017 struct exclude
*exclude
;
1018 exclude
= last_exclude_matching_from_list(pathname
, pathlen
, basename
,
1021 return exclude
->flags
& EXC_FLAG_NEGATIVE
? 0 : 1;
1022 return -1; /* undecided */
1025 static struct exclude
*last_exclude_matching_from_lists(struct dir_struct
*dir
,
1026 struct index_state
*istate
,
1027 const char *pathname
, int pathlen
, const char *basename
,
1031 struct exclude_list_group
*group
;
1032 struct exclude
*exclude
;
1033 for (i
= EXC_CMDL
; i
<= EXC_FILE
; i
++) {
1034 group
= &dir
->exclude_list_group
[i
];
1035 for (j
= group
->nr
- 1; j
>= 0; j
--) {
1036 exclude
= last_exclude_matching_from_list(
1037 pathname
, pathlen
, basename
, dtype_p
,
1038 &group
->el
[j
], istate
);
1047 * Loads the per-directory exclude list for the substring of base
1048 * which has a char length of baselen.
1050 static void prep_exclude(struct dir_struct
*dir
,
1051 struct index_state
*istate
,
1052 const char *base
, int baselen
)
1054 struct exclude_list_group
*group
;
1055 struct exclude_list
*el
;
1056 struct exclude_stack
*stk
= NULL
;
1057 struct untracked_cache_dir
*untracked
;
1060 group
= &dir
->exclude_list_group
[EXC_DIRS
];
1063 * Pop the exclude lists from the EXCL_DIRS exclude_list_group
1064 * which originate from directories not in the prefix of the
1065 * path being checked.
1067 while ((stk
= dir
->exclude_stack
) != NULL
) {
1068 if (stk
->baselen
<= baselen
&&
1069 !strncmp(dir
->basebuf
.buf
, base
, stk
->baselen
))
1071 el
= &group
->el
[dir
->exclude_stack
->exclude_ix
];
1072 dir
->exclude_stack
= stk
->prev
;
1073 dir
->exclude
= NULL
;
1074 free((char *)el
->src
); /* see strbuf_detach() below */
1075 clear_exclude_list(el
);
1080 /* Skip traversing into sub directories if the parent is excluded */
1085 * Lazy initialization. All call sites currently just
1086 * memset(dir, 0, sizeof(*dir)) before use. Changing all of
1087 * them seems lots of work for little benefit.
1089 if (!dir
->basebuf
.buf
)
1090 strbuf_init(&dir
->basebuf
, PATH_MAX
);
1092 /* Read from the parent directories and push them down. */
1093 current
= stk
? stk
->baselen
: -1;
1094 strbuf_setlen(&dir
->basebuf
, current
< 0 ? 0 : current
);
1096 untracked
= stk
? stk
->ucd
: dir
->untracked
->root
;
1100 while (current
< baselen
) {
1102 struct sha1_stat sha1_stat
;
1104 stk
= xcalloc(1, sizeof(*stk
));
1109 cp
= strchr(base
+ current
+ 1, '/');
1111 die("oops in prep_exclude");
1114 lookup_untracked(dir
->untracked
, untracked
,
1116 cp
- base
- current
);
1118 stk
->prev
= dir
->exclude_stack
;
1119 stk
->baselen
= cp
- base
;
1120 stk
->exclude_ix
= group
->nr
;
1121 stk
->ucd
= untracked
;
1122 el
= add_exclude_list(dir
, EXC_DIRS
, NULL
);
1123 strbuf_add(&dir
->basebuf
, base
+ current
, stk
->baselen
- current
);
1124 assert(stk
->baselen
== dir
->basebuf
.len
);
1126 /* Abort if the directory is excluded */
1129 dir
->basebuf
.buf
[stk
->baselen
- 1] = 0;
1130 dir
->exclude
= last_exclude_matching_from_lists(dir
,
1132 dir
->basebuf
.buf
, stk
->baselen
- 1,
1133 dir
->basebuf
.buf
+ current
, &dt
);
1134 dir
->basebuf
.buf
[stk
->baselen
- 1] = '/';
1136 dir
->exclude
->flags
& EXC_FLAG_NEGATIVE
)
1137 dir
->exclude
= NULL
;
1139 dir
->exclude_stack
= stk
;
1144 /* Try to read per-directory file */
1145 hashclr(sha1_stat
.sha1
);
1146 sha1_stat
.valid
= 0;
1147 if (dir
->exclude_per_dir
&&
1149 * If we know that no files have been added in
1150 * this directory (i.e. valid_cached_dir() has
1151 * been executed and set untracked->valid) ..
1153 (!untracked
|| !untracked
->valid
||
1155 * .. and .gitignore does not exist before
1156 * (i.e. null exclude_sha1). Then we can skip
1157 * loading .gitignore, which would result in
1160 !is_null_sha1(untracked
->exclude_sha1
))) {
1162 * dir->basebuf gets reused by the traversal, but we
1163 * need fname to remain unchanged to ensure the src
1164 * member of each struct exclude correctly
1165 * back-references its source file. Other invocations
1166 * of add_exclude_list provide stable strings, so we
1167 * strbuf_detach() and free() here in the caller.
1169 struct strbuf sb
= STRBUF_INIT
;
1170 strbuf_addbuf(&sb
, &dir
->basebuf
);
1171 strbuf_addstr(&sb
, dir
->exclude_per_dir
);
1172 el
->src
= strbuf_detach(&sb
, NULL
);
1173 add_excludes(el
->src
, el
->src
, stk
->baselen
, el
, istate
,
1174 untracked
? &sha1_stat
: NULL
);
1177 * NEEDSWORK: when untracked cache is enabled, prep_exclude()
1178 * will first be called in valid_cached_dir() then maybe many
1179 * times more in last_exclude_matching(). When the cache is
1180 * used, last_exclude_matching() will not be called and
1181 * reading .gitignore content will be a waste.
1183 * So when it's called by valid_cached_dir() and we can get
1184 * .gitignore SHA-1 from the index (i.e. .gitignore is not
1185 * modified on work tree), we could delay reading the
1186 * .gitignore content until we absolutely need it in
1187 * last_exclude_matching(). Be careful about ignore rule
1188 * order, though, if you do that.
1191 hashcmp(sha1_stat
.sha1
, untracked
->exclude_sha1
)) {
1192 invalidate_gitignore(dir
->untracked
, untracked
);
1193 hashcpy(untracked
->exclude_sha1
, sha1_stat
.sha1
);
1195 dir
->exclude_stack
= stk
;
1196 current
= stk
->baselen
;
1198 strbuf_setlen(&dir
->basebuf
, baselen
);
1202 * Loads the exclude lists for the directory containing pathname, then
1203 * scans all exclude lists to determine whether pathname is excluded.
1204 * Returns the exclude_list element which matched, or NULL for
1207 struct exclude
*last_exclude_matching(struct dir_struct
*dir
,
1208 struct index_state
*istate
,
1209 const char *pathname
,
1212 int pathlen
= strlen(pathname
);
1213 const char *basename
= strrchr(pathname
, '/');
1214 basename
= (basename
) ? basename
+1 : pathname
;
1216 prep_exclude(dir
, istate
, pathname
, basename
-pathname
);
1219 return dir
->exclude
;
1221 return last_exclude_matching_from_lists(dir
, istate
, pathname
, pathlen
,
1226 * Loads the exclude lists for the directory containing pathname, then
1227 * scans all exclude lists to determine whether pathname is excluded.
1228 * Returns 1 if true, otherwise 0.
1230 int is_excluded(struct dir_struct
*dir
, struct index_state
*istate
,
1231 const char *pathname
, int *dtype_p
)
1233 struct exclude
*exclude
=
1234 last_exclude_matching(dir
, istate
, pathname
, dtype_p
);
1236 return exclude
->flags
& EXC_FLAG_NEGATIVE
? 0 : 1;
1240 static struct dir_entry
*dir_entry_new(const char *pathname
, int len
)
1242 struct dir_entry
*ent
;
1244 FLEX_ALLOC_MEM(ent
, name
, pathname
, len
);
1249 static struct dir_entry
*dir_add_name(struct dir_struct
*dir
,
1250 struct index_state
*istate
,
1251 const char *pathname
, int len
)
1253 if (index_file_exists(istate
, pathname
, len
, ignore_case
))
1256 ALLOC_GROW(dir
->entries
, dir
->nr
+1, dir
->alloc
);
1257 return dir
->entries
[dir
->nr
++] = dir_entry_new(pathname
, len
);
1260 struct dir_entry
*dir_add_ignored(struct dir_struct
*dir
,
1261 struct index_state
*istate
,
1262 const char *pathname
, int len
)
1264 if (!index_name_is_other(istate
, pathname
, len
))
1267 ALLOC_GROW(dir
->ignored
, dir
->ignored_nr
+1, dir
->ignored_alloc
);
1268 return dir
->ignored
[dir
->ignored_nr
++] = dir_entry_new(pathname
, len
);
1272 index_nonexistent
= 0,
1278 * Do not use the alphabetically sorted index to look up
1279 * the directory name; instead, use the case insensitive
1282 static enum exist_status
directory_exists_in_index_icase(struct index_state
*istate
,
1283 const char *dirname
, int len
)
1285 struct cache_entry
*ce
;
1287 if (index_dir_exists(istate
, dirname
, len
))
1288 return index_directory
;
1290 ce
= index_file_exists(istate
, dirname
, len
, ignore_case
);
1291 if (ce
&& S_ISGITLINK(ce
->ce_mode
))
1292 return index_gitdir
;
1294 return index_nonexistent
;
1298 * The index sorts alphabetically by entry name, which
1299 * means that a gitlink sorts as '\0' at the end, while
1300 * a directory (which is defined not as an entry, but as
1301 * the files it contains) will sort with the '/' at the
1304 static enum exist_status
directory_exists_in_index(struct index_state
*istate
,
1305 const char *dirname
, int len
)
1310 return directory_exists_in_index_icase(istate
, dirname
, len
);
1312 pos
= index_name_pos(istate
, dirname
, len
);
1315 while (pos
< istate
->cache_nr
) {
1316 const struct cache_entry
*ce
= istate
->cache
[pos
++];
1317 unsigned char endchar
;
1319 if (strncmp(ce
->name
, dirname
, len
))
1321 endchar
= ce
->name
[len
];
1325 return index_directory
;
1326 if (!endchar
&& S_ISGITLINK(ce
->ce_mode
))
1327 return index_gitdir
;
1329 return index_nonexistent
;
1333 * When we find a directory when traversing the filesystem, we
1334 * have three distinct cases:
1337 * - see it as a directory
1340 * and which one we choose depends on a combination of existing
1341 * git index contents and the flags passed into the directory
1342 * traversal routine.
1344 * Case 1: If we *already* have entries in the index under that
1345 * directory name, we always recurse into the directory to see
1348 * Case 2: If we *already* have that directory name as a gitlink,
1349 * we always continue to see it as a gitlink, regardless of whether
1350 * there is an actual git directory there or not (it might not
1351 * be checked out as a subproject!)
1353 * Case 3: if we didn't have it in the index previously, we
1354 * have a few sub-cases:
1356 * (a) if "show_other_directories" is true, we show it as
1357 * just a directory, unless "hide_empty_directories" is
1358 * also true, in which case we need to check if it contains any
1359 * untracked and / or ignored files.
1360 * (b) if it looks like a git directory, and we don't have
1361 * 'no_gitlinks' set we treat it as a gitlink, and show it
1363 * (c) otherwise, we recurse into it.
1365 static enum path_treatment
treat_directory(struct dir_struct
*dir
,
1366 struct index_state
*istate
,
1367 struct untracked_cache_dir
*untracked
,
1368 const char *dirname
, int len
, int baselen
, int exclude
,
1369 const struct pathspec
*pathspec
)
1371 /* The "len-1" is to strip the final '/' */
1372 switch (directory_exists_in_index(istate
, dirname
, len
-1)) {
1373 case index_directory
:
1374 return path_recurse
;
1379 case index_nonexistent
:
1380 if (dir
->flags
& DIR_SHOW_OTHER_DIRECTORIES
)
1382 if (!(dir
->flags
& DIR_NO_GITLINKS
)) {
1383 unsigned char sha1
[20];
1384 if (resolve_gitlink_ref(dirname
, "HEAD", sha1
) == 0)
1385 return path_untracked
;
1387 return path_recurse
;
1390 /* This is the "show_other_directories" case */
1392 if (!(dir
->flags
& DIR_HIDE_EMPTY_DIRECTORIES
))
1393 return exclude
? path_excluded
: path_untracked
;
1395 untracked
= lookup_untracked(dir
->untracked
, untracked
,
1396 dirname
+ baselen
, len
- baselen
);
1397 return read_directory_recursive(dir
, istate
, dirname
, len
,
1398 untracked
, 1, pathspec
);
1402 * This is an inexact early pruning of any recursive directory
1403 * reading - if the path cannot possibly be in the pathspec,
1404 * return true, and we'll skip it early.
1406 static int simplify_away(const char *path
, int pathlen
,
1407 const struct pathspec
*pathspec
)
1411 if (!pathspec
|| !pathspec
->nr
)
1414 GUARD_PATHSPEC(pathspec
,
1423 for (i
= 0; i
< pathspec
->nr
; i
++) {
1424 const struct pathspec_item
*item
= &pathspec
->items
[i
];
1425 int len
= item
->nowildcard_len
;
1429 if (!ps_strncmp(item
, item
->match
, path
, len
))
1437 * This function tells us whether an excluded path matches a
1438 * list of "interesting" pathspecs. That is, whether a path matched
1439 * by any of the pathspecs could possibly be ignored by excluding
1440 * the specified path. This can happen if:
1442 * 1. the path is mentioned explicitly in the pathspec
1444 * 2. the path is a directory prefix of some element in the
1447 static int exclude_matches_pathspec(const char *path
, int pathlen
,
1448 const struct pathspec
*pathspec
)
1452 if (!pathspec
|| !pathspec
->nr
)
1455 GUARD_PATHSPEC(pathspec
,
1463 for (i
= 0; i
< pathspec
->nr
; i
++) {
1464 const struct pathspec_item
*item
= &pathspec
->items
[i
];
1465 int len
= item
->nowildcard_len
;
1467 if (len
== pathlen
&&
1468 !ps_strncmp(item
, item
->match
, path
, pathlen
))
1470 if (len
> pathlen
&&
1471 item
->match
[pathlen
] == '/' &&
1472 !ps_strncmp(item
, item
->match
, path
, pathlen
))
1478 static int get_index_dtype(struct index_state
*istate
,
1479 const char *path
, int len
)
1482 const struct cache_entry
*ce
;
1484 ce
= index_file_exists(istate
, path
, len
, 0);
1486 if (!ce_uptodate(ce
))
1488 if (S_ISGITLINK(ce
->ce_mode
))
1491 * Nobody actually cares about the
1492 * difference between DT_LNK and DT_REG
1497 /* Try to look it up as a directory */
1498 pos
= index_name_pos(istate
, path
, len
);
1502 while (pos
< istate
->cache_nr
) {
1503 ce
= istate
->cache
[pos
++];
1504 if (strncmp(ce
->name
, path
, len
))
1506 if (ce
->name
[len
] > '/')
1508 if (ce
->name
[len
] < '/')
1510 if (!ce_uptodate(ce
))
1511 break; /* continue? */
1517 static int get_dtype(struct dirent
*de
, struct index_state
*istate
,
1518 const char *path
, int len
)
1520 int dtype
= de
? DTYPE(de
) : DT_UNKNOWN
;
1523 if (dtype
!= DT_UNKNOWN
)
1525 dtype
= get_index_dtype(istate
, path
, len
);
1526 if (dtype
!= DT_UNKNOWN
)
1528 if (lstat(path
, &st
))
1530 if (S_ISREG(st
.st_mode
))
1532 if (S_ISDIR(st
.st_mode
))
1534 if (S_ISLNK(st
.st_mode
))
1539 static enum path_treatment
treat_one_path(struct dir_struct
*dir
,
1540 struct untracked_cache_dir
*untracked
,
1541 struct index_state
*istate
,
1542 struct strbuf
*path
,
1544 const struct pathspec
*pathspec
,
1545 int dtype
, struct dirent
*de
)
1548 int has_path_in_index
= !!index_file_exists(istate
, path
->buf
, path
->len
, ignore_case
);
1550 if (dtype
== DT_UNKNOWN
)
1551 dtype
= get_dtype(de
, istate
, path
->buf
, path
->len
);
1553 /* Always exclude indexed files */
1554 if (dtype
!= DT_DIR
&& has_path_in_index
)
1558 * When we are looking at a directory P in the working tree,
1559 * there are three cases:
1561 * (1) P exists in the index. Everything inside the directory P in
1562 * the working tree needs to go when P is checked out from the
1565 * (2) P does not exist in the index, but there is P/Q in the index.
1566 * We know P will stay a directory when we check out the contents
1567 * of the index, but we do not know yet if there is a directory
1568 * P/Q in the working tree to be killed, so we need to recurse.
1570 * (3) P does not exist in the index, and there is no P/Q in the index
1571 * to require P to be a directory, either. Only in this case, we
1572 * know that everything inside P will not be killed without
1575 if ((dir
->flags
& DIR_COLLECT_KILLED_ONLY
) &&
1576 (dtype
== DT_DIR
) &&
1577 !has_path_in_index
&&
1578 (directory_exists_in_index(istate
, path
->buf
, path
->len
) == index_nonexistent
))
1581 exclude
= is_excluded(dir
, istate
, path
->buf
, &dtype
);
1584 * Excluded? If we don't explicitly want to show
1585 * ignored files, ignore it
1587 if (exclude
&& !(dir
->flags
& (DIR_SHOW_IGNORED
|DIR_SHOW_IGNORED_TOO
)))
1588 return path_excluded
;
1594 strbuf_addch(path
, '/');
1595 return treat_directory(dir
, istate
, untracked
, path
->buf
, path
->len
,
1596 baselen
, exclude
, pathspec
);
1599 return exclude
? path_excluded
: path_untracked
;
1603 static enum path_treatment
treat_path_fast(struct dir_struct
*dir
,
1604 struct untracked_cache_dir
*untracked
,
1605 struct cached_dir
*cdir
,
1606 struct index_state
*istate
,
1607 struct strbuf
*path
,
1609 const struct pathspec
*pathspec
)
1611 strbuf_setlen(path
, baselen
);
1613 strbuf_addstr(path
, cdir
->file
);
1614 return path_untracked
;
1616 strbuf_addstr(path
, cdir
->ucd
->name
);
1617 /* treat_one_path() does this before it calls treat_directory() */
1618 strbuf_complete(path
, '/');
1619 if (cdir
->ucd
->check_only
)
1621 * check_only is set as a result of treat_directory() getting
1622 * to its bottom. Verify again the same set of directories
1623 * with check_only set.
1625 return read_directory_recursive(dir
, istate
, path
->buf
, path
->len
,
1626 cdir
->ucd
, 1, pathspec
);
1628 * We get path_recurse in the first run when
1629 * directory_exists_in_index() returns index_nonexistent. We
1630 * are sure that new changes in the index does not impact the
1631 * outcome. Return now.
1633 return path_recurse
;
1636 static enum path_treatment
treat_path(struct dir_struct
*dir
,
1637 struct untracked_cache_dir
*untracked
,
1638 struct cached_dir
*cdir
,
1639 struct index_state
*istate
,
1640 struct strbuf
*path
,
1642 const struct pathspec
*pathspec
)
1645 struct dirent
*de
= cdir
->de
;
1648 return treat_path_fast(dir
, untracked
, cdir
, istate
, path
,
1650 if (is_dot_or_dotdot(de
->d_name
) || !strcmp(de
->d_name
, ".git"))
1652 strbuf_setlen(path
, baselen
);
1653 strbuf_addstr(path
, de
->d_name
);
1654 if (simplify_away(path
->buf
, path
->len
, pathspec
))
1658 return treat_one_path(dir
, untracked
, istate
, path
, baselen
, pathspec
, dtype
, de
);
1661 static void add_untracked(struct untracked_cache_dir
*dir
, const char *name
)
1665 ALLOC_GROW(dir
->untracked
, dir
->untracked_nr
+ 1,
1666 dir
->untracked_alloc
);
1667 dir
->untracked
[dir
->untracked_nr
++] = xstrdup(name
);
1670 static int valid_cached_dir(struct dir_struct
*dir
,
1671 struct untracked_cache_dir
*untracked
,
1672 struct index_state
*istate
,
1673 struct strbuf
*path
,
1681 if (stat(path
->len
? path
->buf
: ".", &st
)) {
1682 invalidate_directory(dir
->untracked
, untracked
);
1683 memset(&untracked
->stat_data
, 0, sizeof(untracked
->stat_data
));
1686 if (!untracked
->valid
||
1687 match_stat_data_racy(istate
, &untracked
->stat_data
, &st
)) {
1688 if (untracked
->valid
)
1689 invalidate_directory(dir
->untracked
, untracked
);
1690 fill_stat_data(&untracked
->stat_data
, &st
);
1694 if (untracked
->check_only
!= !!check_only
) {
1695 invalidate_directory(dir
->untracked
, untracked
);
1700 * prep_exclude will be called eventually on this directory,
1701 * but it's called much later in last_exclude_matching(). We
1702 * need it now to determine the validity of the cache for this
1703 * path. The next calls will be nearly no-op, the way
1704 * prep_exclude() is designed.
1706 if (path
->len
&& path
->buf
[path
->len
- 1] != '/') {
1707 strbuf_addch(path
, '/');
1708 prep_exclude(dir
, istate
, path
->buf
, path
->len
);
1709 strbuf_setlen(path
, path
->len
- 1);
1711 prep_exclude(dir
, istate
, path
->buf
, path
->len
);
1713 /* hopefully prep_exclude() haven't invalidated this entry... */
1714 return untracked
->valid
;
1717 static int open_cached_dir(struct cached_dir
*cdir
,
1718 struct dir_struct
*dir
,
1719 struct untracked_cache_dir
*untracked
,
1720 struct index_state
*istate
,
1721 struct strbuf
*path
,
1724 memset(cdir
, 0, sizeof(*cdir
));
1725 cdir
->untracked
= untracked
;
1726 if (valid_cached_dir(dir
, untracked
, istate
, path
, check_only
))
1728 cdir
->fdir
= opendir(path
->len
? path
->buf
: ".");
1730 dir
->untracked
->dir_opened
++;
1736 static int read_cached_dir(struct cached_dir
*cdir
)
1739 cdir
->de
= readdir(cdir
->fdir
);
1744 while (cdir
->nr_dirs
< cdir
->untracked
->dirs_nr
) {
1745 struct untracked_cache_dir
*d
= cdir
->untracked
->dirs
[cdir
->nr_dirs
];
1755 if (cdir
->nr_files
< cdir
->untracked
->untracked_nr
) {
1756 struct untracked_cache_dir
*d
= cdir
->untracked
;
1757 cdir
->file
= d
->untracked
[cdir
->nr_files
++];
1763 static void close_cached_dir(struct cached_dir
*cdir
)
1766 closedir(cdir
->fdir
);
1768 * We have gone through this directory and found no untracked
1769 * entries. Mark it valid.
1771 if (cdir
->untracked
) {
1772 cdir
->untracked
->valid
= 1;
1773 cdir
->untracked
->recurse
= 1;
1778 * Read a directory tree. We currently ignore anything but
1779 * directories, regular files and symlinks. That's because git
1780 * doesn't handle them at all yet. Maybe that will change some
1783 * Also, we ignore the name ".git" (even if it is not a directory).
1784 * That likely will not change.
1786 * Returns the most significant path_treatment value encountered in the scan.
1788 static enum path_treatment
read_directory_recursive(struct dir_struct
*dir
,
1789 struct index_state
*istate
, const char *base
, int baselen
,
1790 struct untracked_cache_dir
*untracked
, int check_only
,
1791 const struct pathspec
*pathspec
)
1793 struct cached_dir cdir
;
1794 enum path_treatment state
, subdir_state
, dir_state
= path_none
;
1795 struct strbuf path
= STRBUF_INIT
;
1797 strbuf_add(&path
, base
, baselen
);
1799 if (open_cached_dir(&cdir
, dir
, untracked
, istate
, &path
, check_only
))
1803 untracked
->check_only
= !!check_only
;
1805 while (!read_cached_dir(&cdir
)) {
1806 /* check how the file or directory should be treated */
1807 state
= treat_path(dir
, untracked
, &cdir
, istate
, &path
,
1810 if (state
> dir_state
)
1813 /* recurse into subdir if instructed by treat_path */
1814 if (state
== path_recurse
) {
1815 struct untracked_cache_dir
*ud
;
1816 ud
= lookup_untracked(dir
->untracked
, untracked
,
1818 path
.len
- baselen
);
1820 read_directory_recursive(dir
, istate
, path
.buf
,
1822 check_only
, pathspec
);
1823 if (subdir_state
> dir_state
)
1824 dir_state
= subdir_state
;
1828 /* abort early if maximum state has been reached */
1829 if (dir_state
== path_untracked
) {
1831 add_untracked(untracked
, path
.buf
+ baselen
);
1834 /* skip the dir_add_* part */
1838 /* add the path to the appropriate result list */
1841 if (dir
->flags
& DIR_SHOW_IGNORED
)
1842 dir_add_name(dir
, istate
, path
.buf
, path
.len
);
1843 else if ((dir
->flags
& DIR_SHOW_IGNORED_TOO
) ||
1844 ((dir
->flags
& DIR_COLLECT_IGNORED
) &&
1845 exclude_matches_pathspec(path
.buf
, path
.len
,
1847 dir_add_ignored(dir
, istate
, path
.buf
, path
.len
);
1850 case path_untracked
:
1851 if (dir
->flags
& DIR_SHOW_IGNORED
)
1853 dir_add_name(dir
, istate
, path
.buf
, path
.len
);
1855 add_untracked(untracked
, path
.buf
+ baselen
);
1862 close_cached_dir(&cdir
);
1864 strbuf_release(&path
);
1869 static int cmp_name(const void *p1
, const void *p2
)
1871 const struct dir_entry
*e1
= *(const struct dir_entry
**)p1
;
1872 const struct dir_entry
*e2
= *(const struct dir_entry
**)p2
;
1874 return name_compare(e1
->name
, e1
->len
, e2
->name
, e2
->len
);
1877 static int treat_leading_path(struct dir_struct
*dir
,
1878 struct index_state
*istate
,
1879 const char *path
, int len
,
1880 const struct pathspec
*pathspec
)
1882 struct strbuf sb
= STRBUF_INIT
;
1883 int baselen
, rc
= 0;
1885 int old_flags
= dir
->flags
;
1887 while (len
&& path
[len
- 1] == '/')
1892 dir
->flags
&= ~DIR_SHOW_OTHER_DIRECTORIES
;
1894 cp
= path
+ baselen
+ !!baselen
;
1895 cp
= memchr(cp
, '/', path
+ len
- cp
);
1899 baselen
= cp
- path
;
1900 strbuf_setlen(&sb
, 0);
1901 strbuf_add(&sb
, path
, baselen
);
1902 if (!is_directory(sb
.buf
))
1904 if (simplify_away(sb
.buf
, sb
.len
, pathspec
))
1906 if (treat_one_path(dir
, NULL
, istate
, &sb
, baselen
, pathspec
,
1907 DT_DIR
, NULL
) == path_none
)
1908 break; /* do not recurse into it */
1909 if (len
<= baselen
) {
1911 break; /* finished checking */
1914 strbuf_release(&sb
);
1915 dir
->flags
= old_flags
;
1919 static const char *get_ident_string(void)
1921 static struct strbuf sb
= STRBUF_INIT
;
1926 if (uname(&uts
) < 0)
1927 die_errno(_("failed to get kernel name and information"));
1928 strbuf_addf(&sb
, "Location %s, system %s", get_git_work_tree(),
1933 static int ident_in_untracked(const struct untracked_cache
*uc
)
1936 * Previous git versions may have saved many NUL separated
1937 * strings in the "ident" field, but it is insane to manage
1938 * many locations, so just take care of the first one.
1941 return !strcmp(uc
->ident
.buf
, get_ident_string());
1944 static void set_untracked_ident(struct untracked_cache
*uc
)
1946 strbuf_reset(&uc
->ident
);
1947 strbuf_addstr(&uc
->ident
, get_ident_string());
1950 * This strbuf used to contain a list of NUL separated
1951 * strings, so save NUL too for backward compatibility.
1953 strbuf_addch(&uc
->ident
, 0);
1956 static void new_untracked_cache(struct index_state
*istate
)
1958 struct untracked_cache
*uc
= xcalloc(1, sizeof(*uc
));
1959 strbuf_init(&uc
->ident
, 100);
1960 uc
->exclude_per_dir
= ".gitignore";
1961 /* should be the same flags used by git-status */
1962 uc
->dir_flags
= DIR_SHOW_OTHER_DIRECTORIES
| DIR_HIDE_EMPTY_DIRECTORIES
;
1963 set_untracked_ident(uc
);
1964 istate
->untracked
= uc
;
1965 istate
->cache_changed
|= UNTRACKED_CHANGED
;
1968 void add_untracked_cache(struct index_state
*istate
)
1970 if (!istate
->untracked
) {
1971 new_untracked_cache(istate
);
1973 if (!ident_in_untracked(istate
->untracked
)) {
1974 free_untracked_cache(istate
->untracked
);
1975 new_untracked_cache(istate
);
1980 void remove_untracked_cache(struct index_state
*istate
)
1982 if (istate
->untracked
) {
1983 free_untracked_cache(istate
->untracked
);
1984 istate
->untracked
= NULL
;
1985 istate
->cache_changed
|= UNTRACKED_CHANGED
;
1989 static struct untracked_cache_dir
*validate_untracked_cache(struct dir_struct
*dir
,
1991 const struct pathspec
*pathspec
)
1993 struct untracked_cache_dir
*root
;
1995 if (!dir
->untracked
|| getenv("GIT_DISABLE_UNTRACKED_CACHE"))
1999 * We only support $GIT_DIR/info/exclude and core.excludesfile
2000 * as the global ignore rule files. Any other additions
2001 * (e.g. from command line) invalidate the cache. This
2002 * condition also catches running setup_standard_excludes()
2003 * before setting dir->untracked!
2005 if (dir
->unmanaged_exclude_files
)
2009 * Optimize for the main use case only: whole-tree git
2010 * status. More work involved in treat_leading_path() if we
2011 * use cache on just a subset of the worktree. pathspec
2012 * support could make the matter even worse.
2014 if (base_len
|| (pathspec
&& pathspec
->nr
))
2017 /* Different set of flags may produce different results */
2018 if (dir
->flags
!= dir
->untracked
->dir_flags
||
2020 * See treat_directory(), case index_nonexistent. Without
2021 * this flag, we may need to also cache .git file content
2022 * for the resolve_gitlink_ref() call, which we don't.
2024 !(dir
->flags
& DIR_SHOW_OTHER_DIRECTORIES
) ||
2025 /* We don't support collecting ignore files */
2026 (dir
->flags
& (DIR_SHOW_IGNORED
| DIR_SHOW_IGNORED_TOO
|
2027 DIR_COLLECT_IGNORED
)))
2031 * If we use .gitignore in the cache and now you change it to
2032 * .gitexclude, everything will go wrong.
2034 if (dir
->exclude_per_dir
!= dir
->untracked
->exclude_per_dir
&&
2035 strcmp(dir
->exclude_per_dir
, dir
->untracked
->exclude_per_dir
))
2039 * EXC_CMDL is not considered in the cache. If people set it,
2042 if (dir
->exclude_list_group
[EXC_CMDL
].nr
)
2045 if (!ident_in_untracked(dir
->untracked
)) {
2046 warning(_("Untracked cache is disabled on this system or location."));
2050 if (!dir
->untracked
->root
) {
2051 const int len
= sizeof(*dir
->untracked
->root
);
2052 dir
->untracked
->root
= xmalloc(len
);
2053 memset(dir
->untracked
->root
, 0, len
);
2056 /* Validate $GIT_DIR/info/exclude and core.excludesfile */
2057 root
= dir
->untracked
->root
;
2058 if (hashcmp(dir
->ss_info_exclude
.sha1
,
2059 dir
->untracked
->ss_info_exclude
.sha1
)) {
2060 invalidate_gitignore(dir
->untracked
, root
);
2061 dir
->untracked
->ss_info_exclude
= dir
->ss_info_exclude
;
2063 if (hashcmp(dir
->ss_excludes_file
.sha1
,
2064 dir
->untracked
->ss_excludes_file
.sha1
)) {
2065 invalidate_gitignore(dir
->untracked
, root
);
2066 dir
->untracked
->ss_excludes_file
= dir
->ss_excludes_file
;
2069 /* Make sure this directory is not dropped out at saving phase */
2074 int read_directory(struct dir_struct
*dir
, const char *path
,
2075 int len
, const struct pathspec
*pathspec
)
2077 struct untracked_cache_dir
*untracked
;
2079 if (has_symlink_leading_path(path
, len
))
2082 untracked
= validate_untracked_cache(dir
, len
, pathspec
);
2085 * make sure untracked cache code path is disabled,
2086 * e.g. prep_exclude()
2088 dir
->untracked
= NULL
;
2089 if (!len
|| treat_leading_path(dir
, &the_index
, path
, len
, pathspec
))
2090 read_directory_recursive(dir
, &the_index
, path
, len
, untracked
, 0, pathspec
);
2091 QSORT(dir
->entries
, dir
->nr
, cmp_name
);
2092 QSORT(dir
->ignored
, dir
->ignored_nr
, cmp_name
);
2093 if (dir
->untracked
) {
2094 static struct trace_key trace_untracked_stats
= TRACE_KEY_INIT(UNTRACKED_STATS
);
2095 trace_printf_key(&trace_untracked_stats
,
2096 "node creation: %u\n"
2097 "gitignore invalidation: %u\n"
2098 "directory invalidation: %u\n"
2100 dir
->untracked
->dir_created
,
2101 dir
->untracked
->gitignore_invalidated
,
2102 dir
->untracked
->dir_invalidated
,
2103 dir
->untracked
->dir_opened
);
2104 if (dir
->untracked
== the_index
.untracked
&&
2105 (dir
->untracked
->dir_opened
||
2106 dir
->untracked
->gitignore_invalidated
||
2107 dir
->untracked
->dir_invalidated
))
2108 the_index
.cache_changed
|= UNTRACKED_CHANGED
;
2109 if (dir
->untracked
!= the_index
.untracked
) {
2110 free(dir
->untracked
);
2111 dir
->untracked
= NULL
;
2117 int file_exists(const char *f
)
2120 return lstat(f
, &sb
) == 0;
2123 static int cmp_icase(char a
, char b
)
2128 return toupper(a
) - toupper(b
);
2133 * Given two normalized paths (a trailing slash is ok), if subdir is
2134 * outside dir, return -1. Otherwise return the offset in subdir that
2135 * can be used as relative path to dir.
2137 int dir_inside_of(const char *subdir
, const char *dir
)
2141 assert(dir
&& subdir
&& *dir
&& *subdir
);
2143 while (*dir
&& *subdir
&& !cmp_icase(*dir
, *subdir
)) {
2149 /* hel[p]/me vs hel[l]/yeah */
2150 if (*dir
&& *subdir
)
2154 return !*dir
? offset
: -1; /* same dir */
2156 /* foo/[b]ar vs foo/[] */
2157 if (is_dir_sep(dir
[-1]))
2158 return is_dir_sep(subdir
[-1]) ? offset
: -1;
2160 /* foo[/]bar vs foo[] */
2161 return is_dir_sep(*subdir
) ? offset
+ 1 : -1;
2164 int is_inside_dir(const char *dir
)
2173 rc
= (dir_inside_of(cwd
, dir
) >= 0);
2178 int is_empty_dir(const char *path
)
2180 DIR *dir
= opendir(path
);
2187 while ((e
= readdir(dir
)) != NULL
)
2188 if (!is_dot_or_dotdot(e
->d_name
)) {
2197 static int remove_dir_recurse(struct strbuf
*path
, int flag
, int *kept_up
)
2201 int ret
= 0, original_len
= path
->len
, len
, kept_down
= 0;
2202 int only_empty
= (flag
& REMOVE_DIR_EMPTY_ONLY
);
2203 int keep_toplevel
= (flag
& REMOVE_DIR_KEEP_TOPLEVEL
);
2204 unsigned char submodule_head
[20];
2206 if ((flag
& REMOVE_DIR_KEEP_NESTED_GIT
) &&
2207 !resolve_gitlink_ref(path
->buf
, "HEAD", submodule_head
)) {
2208 /* Do not descend and nuke a nested git work tree. */
2214 flag
&= ~REMOVE_DIR_KEEP_TOPLEVEL
;
2215 dir
= opendir(path
->buf
);
2217 if (errno
== ENOENT
)
2218 return keep_toplevel
? -1 : 0;
2219 else if (errno
== EACCES
&& !keep_toplevel
)
2221 * An empty dir could be removable even if it
2224 return rmdir(path
->buf
);
2228 strbuf_complete(path
, '/');
2231 while ((e
= readdir(dir
)) != NULL
) {
2233 if (is_dot_or_dotdot(e
->d_name
))
2236 strbuf_setlen(path
, len
);
2237 strbuf_addstr(path
, e
->d_name
);
2238 if (lstat(path
->buf
, &st
)) {
2239 if (errno
== ENOENT
)
2241 * file disappeared, which is what we
2246 } else if (S_ISDIR(st
.st_mode
)) {
2247 if (!remove_dir_recurse(path
, flag
, &kept_down
))
2248 continue; /* happy */
2249 } else if (!only_empty
&&
2250 (!unlink(path
->buf
) || errno
== ENOENT
)) {
2251 continue; /* happy, too */
2254 /* path too long, stat fails, or non-directory still exists */
2260 strbuf_setlen(path
, original_len
);
2261 if (!ret
&& !keep_toplevel
&& !kept_down
)
2262 ret
= (!rmdir(path
->buf
) || errno
== ENOENT
) ? 0 : -1;
2265 * report the uplevel that it is not an error that we
2266 * did not rmdir() our directory.
2272 int remove_dir_recursively(struct strbuf
*path
, int flag
)
2274 return remove_dir_recurse(path
, flag
, NULL
);
2277 static GIT_PATH_FUNC(git_path_info_exclude
, "info/exclude")
2279 void setup_standard_excludes(struct dir_struct
*dir
)
2281 dir
->exclude_per_dir
= ".gitignore";
2283 /* core.excludefile defaulting to $XDG_HOME/git/ignore */
2285 excludes_file
= xdg_config_home("ignore");
2286 if (excludes_file
&& !access_or_warn(excludes_file
, R_OK
, 0))
2287 add_excludes_from_file_1(dir
, excludes_file
,
2288 dir
->untracked
? &dir
->ss_excludes_file
: NULL
);
2290 /* per repository user preference */
2291 if (startup_info
->have_repository
) {
2292 const char *path
= git_path_info_exclude();
2293 if (!access_or_warn(path
, R_OK
, 0))
2294 add_excludes_from_file_1(dir
, path
,
2295 dir
->untracked
? &dir
->ss_info_exclude
: NULL
);
2299 int remove_path(const char *name
)
2303 if (unlink(name
) && errno
!= ENOENT
&& errno
!= ENOTDIR
)
2306 slash
= strrchr(name
, '/');
2308 char *dirs
= xstrdup(name
);
2309 slash
= dirs
+ (slash
- name
);
2312 } while (rmdir(dirs
) == 0 && (slash
= strrchr(dirs
, '/')));
2319 * Frees memory within dir which was allocated for exclude lists and
2320 * the exclude_stack. Does not free dir itself.
2322 void clear_directory(struct dir_struct
*dir
)
2325 struct exclude_list_group
*group
;
2326 struct exclude_list
*el
;
2327 struct exclude_stack
*stk
;
2329 for (i
= EXC_CMDL
; i
<= EXC_FILE
; i
++) {
2330 group
= &dir
->exclude_list_group
[i
];
2331 for (j
= 0; j
< group
->nr
; j
++) {
2334 free((char *)el
->src
);
2335 clear_exclude_list(el
);
2340 stk
= dir
->exclude_stack
;
2342 struct exclude_stack
*prev
= stk
->prev
;
2346 strbuf_release(&dir
->basebuf
);
2349 struct ondisk_untracked_cache
{
2350 struct stat_data info_exclude_stat
;
2351 struct stat_data excludes_file_stat
;
2353 unsigned char info_exclude_sha1
[20];
2354 unsigned char excludes_file_sha1
[20];
2355 char exclude_per_dir
[FLEX_ARRAY
];
2358 #define ouc_size(len) (offsetof(struct ondisk_untracked_cache, exclude_per_dir) + len + 1)
2361 int index
; /* number of written untracked_cache_dir */
2362 struct ewah_bitmap
*check_only
; /* from untracked_cache_dir */
2363 struct ewah_bitmap
*valid
; /* from untracked_cache_dir */
2364 struct ewah_bitmap
*sha1_valid
; /* set if exclude_sha1 is not null */
2366 struct strbuf sb_stat
;
2367 struct strbuf sb_sha1
;
2370 static void stat_data_to_disk(struct stat_data
*to
, const struct stat_data
*from
)
2372 to
->sd_ctime
.sec
= htonl(from
->sd_ctime
.sec
);
2373 to
->sd_ctime
.nsec
= htonl(from
->sd_ctime
.nsec
);
2374 to
->sd_mtime
.sec
= htonl(from
->sd_mtime
.sec
);
2375 to
->sd_mtime
.nsec
= htonl(from
->sd_mtime
.nsec
);
2376 to
->sd_dev
= htonl(from
->sd_dev
);
2377 to
->sd_ino
= htonl(from
->sd_ino
);
2378 to
->sd_uid
= htonl(from
->sd_uid
);
2379 to
->sd_gid
= htonl(from
->sd_gid
);
2380 to
->sd_size
= htonl(from
->sd_size
);
2383 static void write_one_dir(struct untracked_cache_dir
*untracked
,
2384 struct write_data
*wd
)
2386 struct stat_data stat_data
;
2387 struct strbuf
*out
= &wd
->out
;
2388 unsigned char intbuf
[16];
2389 unsigned int intlen
, value
;
2390 int i
= wd
->index
++;
2393 * untracked_nr should be reset whenever valid is clear, but
2396 if (!untracked
->valid
) {
2397 untracked
->untracked_nr
= 0;
2398 untracked
->check_only
= 0;
2401 if (untracked
->check_only
)
2402 ewah_set(wd
->check_only
, i
);
2403 if (untracked
->valid
) {
2404 ewah_set(wd
->valid
, i
);
2405 stat_data_to_disk(&stat_data
, &untracked
->stat_data
);
2406 strbuf_add(&wd
->sb_stat
, &stat_data
, sizeof(stat_data
));
2408 if (!is_null_sha1(untracked
->exclude_sha1
)) {
2409 ewah_set(wd
->sha1_valid
, i
);
2410 strbuf_add(&wd
->sb_sha1
, untracked
->exclude_sha1
, 20);
2413 intlen
= encode_varint(untracked
->untracked_nr
, intbuf
);
2414 strbuf_add(out
, intbuf
, intlen
);
2416 /* skip non-recurse directories */
2417 for (i
= 0, value
= 0; i
< untracked
->dirs_nr
; i
++)
2418 if (untracked
->dirs
[i
]->recurse
)
2420 intlen
= encode_varint(value
, intbuf
);
2421 strbuf_add(out
, intbuf
, intlen
);
2423 strbuf_add(out
, untracked
->name
, strlen(untracked
->name
) + 1);
2425 for (i
= 0; i
< untracked
->untracked_nr
; i
++)
2426 strbuf_add(out
, untracked
->untracked
[i
],
2427 strlen(untracked
->untracked
[i
]) + 1);
2429 for (i
= 0; i
< untracked
->dirs_nr
; i
++)
2430 if (untracked
->dirs
[i
]->recurse
)
2431 write_one_dir(untracked
->dirs
[i
], wd
);
2434 void write_untracked_extension(struct strbuf
*out
, struct untracked_cache
*untracked
)
2436 struct ondisk_untracked_cache
*ouc
;
2437 struct write_data wd
;
2438 unsigned char varbuf
[16];
2440 size_t len
= strlen(untracked
->exclude_per_dir
);
2442 FLEX_ALLOC_MEM(ouc
, exclude_per_dir
, untracked
->exclude_per_dir
, len
);
2443 stat_data_to_disk(&ouc
->info_exclude_stat
, &untracked
->ss_info_exclude
.stat
);
2444 stat_data_to_disk(&ouc
->excludes_file_stat
, &untracked
->ss_excludes_file
.stat
);
2445 hashcpy(ouc
->info_exclude_sha1
, untracked
->ss_info_exclude
.sha1
);
2446 hashcpy(ouc
->excludes_file_sha1
, untracked
->ss_excludes_file
.sha1
);
2447 ouc
->dir_flags
= htonl(untracked
->dir_flags
);
2449 varint_len
= encode_varint(untracked
->ident
.len
, varbuf
);
2450 strbuf_add(out
, varbuf
, varint_len
);
2451 strbuf_addbuf(out
, &untracked
->ident
);
2453 strbuf_add(out
, ouc
, ouc_size(len
));
2457 if (!untracked
->root
) {
2458 varint_len
= encode_varint(0, varbuf
);
2459 strbuf_add(out
, varbuf
, varint_len
);
2464 wd
.check_only
= ewah_new();
2465 wd
.valid
= ewah_new();
2466 wd
.sha1_valid
= ewah_new();
2467 strbuf_init(&wd
.out
, 1024);
2468 strbuf_init(&wd
.sb_stat
, 1024);
2469 strbuf_init(&wd
.sb_sha1
, 1024);
2470 write_one_dir(untracked
->root
, &wd
);
2472 varint_len
= encode_varint(wd
.index
, varbuf
);
2473 strbuf_add(out
, varbuf
, varint_len
);
2474 strbuf_addbuf(out
, &wd
.out
);
2475 ewah_serialize_strbuf(wd
.valid
, out
);
2476 ewah_serialize_strbuf(wd
.check_only
, out
);
2477 ewah_serialize_strbuf(wd
.sha1_valid
, out
);
2478 strbuf_addbuf(out
, &wd
.sb_stat
);
2479 strbuf_addbuf(out
, &wd
.sb_sha1
);
2480 strbuf_addch(out
, '\0'); /* safe guard for string lists */
2482 ewah_free(wd
.valid
);
2483 ewah_free(wd
.check_only
);
2484 ewah_free(wd
.sha1_valid
);
2485 strbuf_release(&wd
.out
);
2486 strbuf_release(&wd
.sb_stat
);
2487 strbuf_release(&wd
.sb_sha1
);
2490 static void free_untracked(struct untracked_cache_dir
*ucd
)
2495 for (i
= 0; i
< ucd
->dirs_nr
; i
++)
2496 free_untracked(ucd
->dirs
[i
]);
2497 for (i
= 0; i
< ucd
->untracked_nr
; i
++)
2498 free(ucd
->untracked
[i
]);
2499 free(ucd
->untracked
);
2504 void free_untracked_cache(struct untracked_cache
*uc
)
2507 free_untracked(uc
->root
);
2513 struct untracked_cache_dir
**ucd
;
2514 struct ewah_bitmap
*check_only
;
2515 struct ewah_bitmap
*valid
;
2516 struct ewah_bitmap
*sha1_valid
;
2517 const unsigned char *data
;
2518 const unsigned char *end
;
2521 static void stat_data_from_disk(struct stat_data
*to
, const struct stat_data
*from
)
2523 to
->sd_ctime
.sec
= get_be32(&from
->sd_ctime
.sec
);
2524 to
->sd_ctime
.nsec
= get_be32(&from
->sd_ctime
.nsec
);
2525 to
->sd_mtime
.sec
= get_be32(&from
->sd_mtime
.sec
);
2526 to
->sd_mtime
.nsec
= get_be32(&from
->sd_mtime
.nsec
);
2527 to
->sd_dev
= get_be32(&from
->sd_dev
);
2528 to
->sd_ino
= get_be32(&from
->sd_ino
);
2529 to
->sd_uid
= get_be32(&from
->sd_uid
);
2530 to
->sd_gid
= get_be32(&from
->sd_gid
);
2531 to
->sd_size
= get_be32(&from
->sd_size
);
2534 static int read_one_dir(struct untracked_cache_dir
**untracked_
,
2535 struct read_data
*rd
)
2537 struct untracked_cache_dir ud
, *untracked
;
2538 const unsigned char *next
, *data
= rd
->data
, *end
= rd
->end
;
2542 memset(&ud
, 0, sizeof(ud
));
2545 value
= decode_varint(&next
);
2549 ud
.untracked_alloc
= value
;
2550 ud
.untracked_nr
= value
;
2551 if (ud
.untracked_nr
)
2552 ALLOC_ARRAY(ud
.untracked
, ud
.untracked_nr
);
2556 ud
.dirs_alloc
= ud
.dirs_nr
= decode_varint(&next
);
2559 ALLOC_ARRAY(ud
.dirs
, ud
.dirs_nr
);
2562 len
= strlen((const char *)data
);
2563 next
= data
+ len
+ 1;
2566 *untracked_
= untracked
= xmalloc(st_add(sizeof(*untracked
), len
));
2567 memcpy(untracked
, &ud
, sizeof(ud
));
2568 memcpy(untracked
->name
, data
, len
+ 1);
2571 for (i
= 0; i
< untracked
->untracked_nr
; i
++) {
2572 len
= strlen((const char *)data
);
2573 next
= data
+ len
+ 1;
2576 untracked
->untracked
[i
] = xstrdup((const char*)data
);
2580 rd
->ucd
[rd
->index
++] = untracked
;
2583 for (i
= 0; i
< untracked
->dirs_nr
; i
++) {
2584 len
= read_one_dir(untracked
->dirs
+ i
, rd
);
2591 static void set_check_only(size_t pos
, void *cb
)
2593 struct read_data
*rd
= cb
;
2594 struct untracked_cache_dir
*ud
= rd
->ucd
[pos
];
2598 static void read_stat(size_t pos
, void *cb
)
2600 struct read_data
*rd
= cb
;
2601 struct untracked_cache_dir
*ud
= rd
->ucd
[pos
];
2602 if (rd
->data
+ sizeof(struct stat_data
) > rd
->end
) {
2603 rd
->data
= rd
->end
+ 1;
2606 stat_data_from_disk(&ud
->stat_data
, (struct stat_data
*)rd
->data
);
2607 rd
->data
+= sizeof(struct stat_data
);
2611 static void read_sha1(size_t pos
, void *cb
)
2613 struct read_data
*rd
= cb
;
2614 struct untracked_cache_dir
*ud
= rd
->ucd
[pos
];
2615 if (rd
->data
+ 20 > rd
->end
) {
2616 rd
->data
= rd
->end
+ 1;
2619 hashcpy(ud
->exclude_sha1
, rd
->data
);
2623 static void load_sha1_stat(struct sha1_stat
*sha1_stat
,
2624 const struct stat_data
*stat
,
2625 const unsigned char *sha1
)
2627 stat_data_from_disk(&sha1_stat
->stat
, stat
);
2628 hashcpy(sha1_stat
->sha1
, sha1
);
2629 sha1_stat
->valid
= 1;
2632 struct untracked_cache
*read_untracked_extension(const void *data
, unsigned long sz
)
2634 const struct ondisk_untracked_cache
*ouc
;
2635 struct untracked_cache
*uc
;
2636 struct read_data rd
;
2637 const unsigned char *next
= data
, *end
= (const unsigned char *)data
+ sz
;
2641 if (sz
<= 1 || end
[-1] != '\0')
2645 ident_len
= decode_varint(&next
);
2646 if (next
+ ident_len
> end
)
2648 ident
= (const char *)next
;
2651 ouc
= (const struct ondisk_untracked_cache
*)next
;
2652 if (next
+ ouc_size(0) > end
)
2655 uc
= xcalloc(1, sizeof(*uc
));
2656 strbuf_init(&uc
->ident
, ident_len
);
2657 strbuf_add(&uc
->ident
, ident
, ident_len
);
2658 load_sha1_stat(&uc
->ss_info_exclude
, &ouc
->info_exclude_stat
,
2659 ouc
->info_exclude_sha1
);
2660 load_sha1_stat(&uc
->ss_excludes_file
, &ouc
->excludes_file_stat
,
2661 ouc
->excludes_file_sha1
);
2662 uc
->dir_flags
= get_be32(&ouc
->dir_flags
);
2663 uc
->exclude_per_dir
= xstrdup(ouc
->exclude_per_dir
);
2664 /* NUL after exclude_per_dir is covered by sizeof(*ouc) */
2665 next
+= ouc_size(strlen(ouc
->exclude_per_dir
));
2669 len
= decode_varint(&next
);
2670 if (next
> end
|| len
== 0)
2673 rd
.valid
= ewah_new();
2674 rd
.check_only
= ewah_new();
2675 rd
.sha1_valid
= ewah_new();
2679 ALLOC_ARRAY(rd
.ucd
, len
);
2681 if (read_one_dir(&uc
->root
, &rd
) || rd
.index
!= len
)
2685 len
= ewah_read_mmap(rd
.valid
, next
, end
- next
);
2690 len
= ewah_read_mmap(rd
.check_only
, next
, end
- next
);
2695 len
= ewah_read_mmap(rd
.sha1_valid
, next
, end
- next
);
2699 ewah_each_bit(rd
.check_only
, set_check_only
, &rd
);
2700 rd
.data
= next
+ len
;
2701 ewah_each_bit(rd
.valid
, read_stat
, &rd
);
2702 ewah_each_bit(rd
.sha1_valid
, read_sha1
, &rd
);
2707 ewah_free(rd
.valid
);
2708 ewah_free(rd
.check_only
);
2709 ewah_free(rd
.sha1_valid
);
2712 free_untracked_cache(uc
);
2718 static void invalidate_one_directory(struct untracked_cache
*uc
,
2719 struct untracked_cache_dir
*ucd
)
2721 uc
->dir_invalidated
++;
2723 ucd
->untracked_nr
= 0;
2727 * Normally when an entry is added or removed from a directory,
2728 * invalidating that directory is enough. No need to touch its
2729 * ancestors. When a directory is shown as "foo/bar/" in git-status
2730 * however, deleting or adding an entry may have cascading effect.
2732 * Say the "foo/bar/file" has become untracked, we need to tell the
2733 * untracked_cache_dir of "foo" that "bar/" is not an untracked
2734 * directory any more (because "bar" is managed by foo as an untracked
2737 * Similarly, if "foo/bar/file" moves from untracked to tracked and it
2738 * was the last untracked entry in the entire "foo", we should show
2739 * "foo/" instead. Which means we have to invalidate past "bar" up to
2742 * This function traverses all directories from root to leaf. If there
2743 * is a chance of one of the above cases happening, we invalidate back
2744 * to root. Otherwise we just invalidate the leaf. There may be a more
2745 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to
2746 * detect these cases and avoid unnecessary invalidation, for example,
2747 * checking for the untracked entry named "bar/" in "foo", but for now
2748 * stick to something safe and simple.
2750 static int invalidate_one_component(struct untracked_cache
*uc
,
2751 struct untracked_cache_dir
*dir
,
2752 const char *path
, int len
)
2754 const char *rest
= strchr(path
, '/');
2757 int component_len
= rest
- path
;
2758 struct untracked_cache_dir
*d
=
2759 lookup_untracked(uc
, dir
, path
, component_len
);
2761 invalidate_one_component(uc
, d
, rest
+ 1,
2762 len
- (component_len
+ 1));
2764 invalidate_one_directory(uc
, dir
);
2768 invalidate_one_directory(uc
, dir
);
2769 return uc
->dir_flags
& DIR_SHOW_OTHER_DIRECTORIES
;
2772 void untracked_cache_invalidate_path(struct index_state
*istate
,
2775 if (!istate
->untracked
|| !istate
->untracked
->root
)
2777 invalidate_one_component(istate
->untracked
, istate
->untracked
->root
,
2778 path
, strlen(path
));
2781 void untracked_cache_remove_from_index(struct index_state
*istate
,
2784 untracked_cache_invalidate_path(istate
, path
);
2787 void untracked_cache_add_to_index(struct index_state
*istate
,
2790 untracked_cache_invalidate_path(istate
, path
);
2793 /* Update gitfile and core.worktree setting to connect work tree and git dir */
2794 void connect_work_tree_and_git_dir(const char *work_tree_
, const char *git_dir_
)
2796 struct strbuf gitfile_sb
= STRBUF_INIT
;
2797 struct strbuf cfg_sb
= STRBUF_INIT
;
2798 struct strbuf rel_path
= STRBUF_INIT
;
2799 char *git_dir
, *work_tree
;
2801 /* Prepare .git file */
2802 strbuf_addf(&gitfile_sb
, "%s/.git", work_tree_
);
2803 if (safe_create_leading_directories_const(gitfile_sb
.buf
))
2804 die(_("could not create directories for %s"), gitfile_sb
.buf
);
2806 /* Prepare config file */
2807 strbuf_addf(&cfg_sb
, "%s/config", git_dir_
);
2808 if (safe_create_leading_directories_const(cfg_sb
.buf
))
2809 die(_("could not create directories for %s"), cfg_sb
.buf
);
2811 git_dir
= real_pathdup(git_dir_
, 1);
2812 work_tree
= real_pathdup(work_tree_
, 1);
2814 /* Write .git file */
2815 write_file(gitfile_sb
.buf
, "gitdir: %s",
2816 relative_path(git_dir
, work_tree
, &rel_path
));
2817 /* Update core.worktree setting */
2818 git_config_set_in_file(cfg_sb
.buf
, "core.worktree",
2819 relative_path(work_tree
, git_dir
, &rel_path
));
2821 strbuf_release(&gitfile_sb
);
2822 strbuf_release(&cfg_sb
);
2823 strbuf_release(&rel_path
);
2829 * Migrate the git directory of the given path from old_git_dir to new_git_dir.
2831 void relocate_gitdir(const char *path
, const char *old_git_dir
, const char *new_git_dir
)
2833 if (rename(old_git_dir
, new_git_dir
) < 0)
2834 die_errno(_("could not migrate git directory from '%s' to '%s'"),
2835 old_git_dir
, new_git_dir
);
2837 connect_work_tree_and_git_dir(path
, new_git_dir
);