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
13 #include "object-store.h"
16 #include "wildmatch.h"
20 #include "ewah/ewok.h"
21 #include "fsmonitor.h"
22 #include "submodule-config.h"
25 * Tells read_directory_recursive how a file or directory should be treated.
26 * Values are ordered by significance, e.g. if a directory contains both
27 * excluded and untracked files, it is listed as untracked because
28 * path_untracked > path_excluded.
38 * Support data structure for our opendir/readdir/closedir wrappers
42 struct untracked_cache_dir
*untracked
;
48 struct untracked_cache_dir
*ucd
;
51 static enum path_treatment
read_directory_recursive(struct dir_struct
*dir
,
52 struct index_state
*istate
, const char *path
, int len
,
53 struct untracked_cache_dir
*untracked
,
54 int check_only
, int stop_at_first_file
, const struct pathspec
*pathspec
);
55 static int get_dtype(struct dirent
*de
, struct index_state
*istate
,
56 const char *path
, int len
);
58 int count_slashes(const char *s
)
67 int fspathcmp(const char *a
, const char *b
)
69 return ignore_case
? strcasecmp(a
, b
) : strcmp(a
, b
);
72 int fspathncmp(const char *a
, const char *b
, size_t count
)
74 return ignore_case
? strncasecmp(a
, b
, count
) : strncmp(a
, b
, count
);
77 int git_fnmatch(const struct pathspec_item
*item
,
78 const char *pattern
, const char *string
,
82 if (ps_strncmp(item
, pattern
, string
, prefix
))
87 if (item
->flags
& PATHSPEC_ONESTAR
) {
88 int pattern_len
= strlen(++pattern
);
89 int string_len
= strlen(string
);
90 return string_len
< pattern_len
||
91 ps_strcmp(item
, pattern
,
92 string
+ string_len
- pattern_len
);
94 if (item
->magic
& PATHSPEC_GLOB
)
95 return wildmatch(pattern
, string
,
97 (item
->magic
& PATHSPEC_ICASE
? WM_CASEFOLD
: 0));
99 /* wildmatch has not learned no FNM_PATHNAME mode yet */
100 return wildmatch(pattern
, string
,
101 item
->magic
& PATHSPEC_ICASE
? WM_CASEFOLD
: 0);
104 static int fnmatch_icase_mem(const char *pattern
, int patternlen
,
105 const char *string
, int stringlen
,
109 struct strbuf pat_buf
= STRBUF_INIT
;
110 struct strbuf str_buf
= STRBUF_INIT
;
111 const char *use_pat
= pattern
;
112 const char *use_str
= string
;
114 if (pattern
[patternlen
]) {
115 strbuf_add(&pat_buf
, pattern
, patternlen
);
116 use_pat
= pat_buf
.buf
;
118 if (string
[stringlen
]) {
119 strbuf_add(&str_buf
, string
, stringlen
);
120 use_str
= str_buf
.buf
;
124 flags
|= WM_CASEFOLD
;
125 match_status
= wildmatch(use_pat
, use_str
, flags
);
127 strbuf_release(&pat_buf
);
128 strbuf_release(&str_buf
);
133 static size_t common_prefix_len(const struct pathspec
*pathspec
)
139 * ":(icase)path" is treated as a pathspec full of
140 * wildcard. In other words, only prefix is considered common
141 * prefix. If the pathspec is abc/foo abc/bar, running in
142 * subdir xyz, the common prefix is still xyz, not xyz/abc as
145 GUARD_PATHSPEC(pathspec
,
154 for (n
= 0; n
< pathspec
->nr
; n
++) {
155 size_t i
= 0, len
= 0, item_len
;
156 if (pathspec
->items
[n
].magic
& PATHSPEC_EXCLUDE
)
158 if (pathspec
->items
[n
].magic
& PATHSPEC_ICASE
)
159 item_len
= pathspec
->items
[n
].prefix
;
161 item_len
= pathspec
->items
[n
].nowildcard_len
;
162 while (i
< item_len
&& (n
== 0 || i
< max
)) {
163 char c
= pathspec
->items
[n
].match
[i
];
164 if (c
!= pathspec
->items
[0].match
[i
])
170 if (n
== 0 || len
< max
) {
180 * Returns a copy of the longest leading path common among all
183 char *common_prefix(const struct pathspec
*pathspec
)
185 unsigned long len
= common_prefix_len(pathspec
);
187 return len
? xmemdupz(pathspec
->items
[0].match
, len
) : NULL
;
190 int fill_directory(struct dir_struct
*dir
,
191 struct index_state
*istate
,
192 const struct pathspec
*pathspec
)
198 * Calculate common prefix for the pathspec, and
199 * use that to optimize the directory walk
201 prefix_len
= common_prefix_len(pathspec
);
202 prefix
= prefix_len
? pathspec
->items
[0].match
: "";
204 /* Read the directory and prune it */
205 read_directory(dir
, istate
, prefix
, prefix_len
, pathspec
);
210 int within_depth(const char *name
, int namelen
,
211 int depth
, int max_depth
)
213 const char *cp
= name
, *cpe
= name
+ namelen
;
219 if (depth
> max_depth
)
226 * Read the contents of the blob with the given OID into a buffer.
227 * Append a trailing LF to the end if the last line doesn't have one.
230 * -1 when the OID is invalid or unknown or does not refer to a blob.
231 * 0 when the blob is empty.
232 * 1 along with { data, size } of the (possibly augmented) buffer
235 * Optionally updates the given oid_stat with the given OID (when valid).
237 static int do_read_blob(const struct object_id
*oid
, struct oid_stat
*oid_stat
,
238 size_t *size_out
, char **data_out
)
240 enum object_type type
;
247 data
= read_object_file(oid
, &type
, &sz
);
248 if (!data
|| type
!= OBJ_BLOB
) {
254 memset(&oid_stat
->stat
, 0, sizeof(oid_stat
->stat
));
255 oidcpy(&oid_stat
->oid
, oid
);
263 if (data
[sz
- 1] != '\n') {
264 data
= xrealloc(data
, st_add(sz
, 1));
268 *size_out
= xsize_t(sz
);
274 #define DO_MATCH_EXCLUDE (1<<0)
275 #define DO_MATCH_DIRECTORY (1<<1)
276 #define DO_MATCH_SUBMODULE (1<<2)
279 * Does 'match' match the given name?
280 * A match is found if
282 * (1) the 'match' string is leading directory of 'name', or
283 * (2) the 'match' string is a wildcard and matches 'name', or
284 * (3) the 'match' string is exactly the same as 'name'.
286 * and the return value tells which case it was.
288 * It returns 0 when there is no match.
290 static int match_pathspec_item(const struct index_state
*istate
,
291 const struct pathspec_item
*item
, int prefix
,
292 const char *name
, int namelen
, unsigned flags
)
294 /* name/namelen has prefix cut off by caller */
295 const char *match
= item
->match
+ prefix
;
296 int matchlen
= item
->len
- prefix
;
299 * The normal call pattern is:
300 * 1. prefix = common_prefix_len(ps);
301 * 2. prune something, or fill_directory
302 * 3. match_pathspec()
304 * 'prefix' at #1 may be shorter than the command's prefix and
305 * it's ok for #2 to match extra files. Those extras will be
308 * Suppose the pathspec is 'foo' and '../bar' running from
309 * subdir 'xyz'. The common prefix at #1 will be empty, thanks
310 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The
311 * user does not want XYZ/foo, only the "foo" part should be
312 * case-insensitive. We need to filter out XYZ/foo here. In
313 * other words, we do not trust the caller on comparing the
314 * prefix part when :(icase) is involved. We do exact
315 * comparison ourselves.
317 * Normally the caller (common_prefix_len() in fact) does
318 * _exact_ matching on name[-prefix+1..-1] and we do not need
319 * to check that part. Be defensive and check it anyway, in
320 * case common_prefix_len is changed, or a new caller is
321 * introduced that does not use common_prefix_len.
323 * If the penalty turns out too high when prefix is really
324 * long, maybe change it to
325 * strncmp(match, name, item->prefix - prefix)
327 if (item
->prefix
&& (item
->magic
& PATHSPEC_ICASE
) &&
328 strncmp(item
->match
, name
- prefix
, item
->prefix
))
331 if (item
->attr_match_nr
&&
332 !match_pathspec_attrs(istate
, name
, namelen
, item
))
335 /* If the match was just the prefix, we matched */
337 return MATCHED_RECURSIVELY
;
339 if (matchlen
<= namelen
&& !ps_strncmp(item
, match
, name
, matchlen
)) {
340 if (matchlen
== namelen
)
341 return MATCHED_EXACTLY
;
343 if (match
[matchlen
-1] == '/' || name
[matchlen
] == '/')
344 return MATCHED_RECURSIVELY
;
345 } else if ((flags
& DO_MATCH_DIRECTORY
) &&
346 match
[matchlen
- 1] == '/' &&
347 namelen
== matchlen
- 1 &&
348 !ps_strncmp(item
, match
, name
, namelen
))
349 return MATCHED_EXACTLY
;
351 if (item
->nowildcard_len
< item
->len
&&
352 !git_fnmatch(item
, match
, name
,
353 item
->nowildcard_len
- prefix
))
354 return MATCHED_FNMATCH
;
356 /* Perform checks to see if "name" is a super set of the pathspec */
357 if (flags
& DO_MATCH_SUBMODULE
) {
358 /* name is a literal prefix of the pathspec */
359 int offset
= name
[namelen
-1] == '/' ? 1 : 0;
360 if ((namelen
< matchlen
) &&
361 (match
[namelen
-offset
] == '/') &&
362 !ps_strncmp(item
, match
, name
, namelen
))
363 return MATCHED_RECURSIVELY
;
365 /* name" doesn't match up to the first wild character */
366 if (item
->nowildcard_len
< item
->len
&&
367 ps_strncmp(item
, match
, name
,
368 item
->nowildcard_len
- prefix
))
372 * Here is where we would perform a wildmatch to check if
373 * "name" can be matched as a directory (or a prefix) against
374 * the pathspec. Since wildmatch doesn't have this capability
375 * at the present we have to punt and say that it is a match,
376 * potentially returning a false positive
377 * The submodules themselves will be able to perform more
378 * accurate matching to determine if the pathspec matches.
380 return MATCHED_RECURSIVELY
;
387 * Given a name and a list of pathspecs, returns the nature of the
388 * closest (i.e. most specific) match of the name to any of the
391 * The caller typically calls this multiple times with the same
392 * pathspec and seen[] array but with different name/namelen
393 * (e.g. entries from the index) and is interested in seeing if and
394 * how each pathspec matches all the names it calls this function
395 * with. A mark is left in the seen[] array for each pathspec element
396 * indicating the closest type of match that element achieved, so if
397 * seen[n] remains zero after multiple invocations, that means the nth
398 * pathspec did not match any names, which could indicate that the
399 * user mistyped the nth pathspec.
401 static int do_match_pathspec(const struct index_state
*istate
,
402 const struct pathspec
*ps
,
403 const char *name
, int namelen
,
404 int prefix
, char *seen
,
407 int i
, retval
= 0, exclude
= flags
& DO_MATCH_EXCLUDE
;
419 if (!ps
->recursive
||
420 !(ps
->magic
& PATHSPEC_MAXDEPTH
) ||
422 return MATCHED_RECURSIVELY
;
424 if (within_depth(name
, namelen
, 0, ps
->max_depth
))
425 return MATCHED_EXACTLY
;
433 for (i
= ps
->nr
- 1; i
>= 0; i
--) {
436 if ((!exclude
&& ps
->items
[i
].magic
& PATHSPEC_EXCLUDE
) ||
437 ( exclude
&& !(ps
->items
[i
].magic
& PATHSPEC_EXCLUDE
)))
440 if (seen
&& seen
[i
] == MATCHED_EXACTLY
)
443 * Make exclude patterns optional and never report
444 * "pathspec ':(exclude)foo' matches no files"
446 if (seen
&& ps
->items
[i
].magic
& PATHSPEC_EXCLUDE
)
447 seen
[i
] = MATCHED_FNMATCH
;
448 how
= match_pathspec_item(istate
, ps
->items
+i
, prefix
, name
,
451 (ps
->magic
& PATHSPEC_MAXDEPTH
) &&
452 ps
->max_depth
!= -1 &&
453 how
&& how
!= MATCHED_FNMATCH
) {
454 int len
= ps
->items
[i
].len
;
455 if (name
[len
] == '/')
457 if (within_depth(name
+len
, namelen
-len
, 0, ps
->max_depth
))
458 how
= MATCHED_EXACTLY
;
465 if (seen
&& seen
[i
] < how
)
472 int match_pathspec(const struct index_state
*istate
,
473 const struct pathspec
*ps
,
474 const char *name
, int namelen
,
475 int prefix
, char *seen
, int is_dir
)
477 int positive
, negative
;
478 unsigned flags
= is_dir
? DO_MATCH_DIRECTORY
: 0;
479 positive
= do_match_pathspec(istate
, ps
, name
, namelen
,
480 prefix
, seen
, flags
);
481 if (!(ps
->magic
& PATHSPEC_EXCLUDE
) || !positive
)
483 negative
= do_match_pathspec(istate
, ps
, name
, namelen
,
485 flags
| DO_MATCH_EXCLUDE
);
486 return negative
? 0 : positive
;
490 * Check if a submodule is a superset of the pathspec
492 int submodule_path_match(const struct index_state
*istate
,
493 const struct pathspec
*ps
,
494 const char *submodule_name
,
497 int matched
= do_match_pathspec(istate
, ps
, submodule_name
,
498 strlen(submodule_name
),
505 int report_path_error(const char *ps_matched
,
506 const struct pathspec
*pathspec
)
509 * Make sure all pathspec matched; otherwise it is an error.
512 for (num
= 0; num
< pathspec
->nr
; num
++) {
513 int other
, found_dup
;
518 * The caller might have fed identical pathspec
519 * twice. Do not barf on such a mistake.
520 * FIXME: parse_pathspec should have eliminated
521 * duplicate pathspec.
523 for (found_dup
= other
= 0;
524 !found_dup
&& other
< pathspec
->nr
;
526 if (other
== num
|| !ps_matched
[other
])
528 if (!strcmp(pathspec
->items
[other
].original
,
529 pathspec
->items
[num
].original
))
531 * Ok, we have a match already.
538 error(_("pathspec '%s' did not match any file(s) known to git"),
539 pathspec
->items
[num
].original
);
546 * Return the length of the "simple" part of a path match limiter.
548 int simple_length(const char *match
)
553 unsigned char c
= *match
++;
555 if (c
== '\0' || is_glob_special(c
))
560 int no_wildcard(const char *string
)
562 return string
[simple_length(string
)] == '\0';
565 void parse_exclude_pattern(const char **pattern
,
570 const char *p
= *pattern
;
575 *flags
|= EXC_FLAG_NEGATIVE
;
579 if (len
&& p
[len
- 1] == '/') {
581 *flags
|= EXC_FLAG_MUSTBEDIR
;
583 for (i
= 0; i
< len
; i
++) {
588 *flags
|= EXC_FLAG_NODIR
;
589 *nowildcardlen
= simple_length(p
);
591 * we should have excluded the trailing slash from 'p' too,
592 * but that's one more allocation. Instead just make sure
593 * nowildcardlen does not exceed real patternlen
595 if (*nowildcardlen
> len
)
596 *nowildcardlen
= len
;
597 if (*p
== '*' && no_wildcard(p
+ 1))
598 *flags
|= EXC_FLAG_ENDSWITH
;
603 void add_exclude(const char *string
, const char *base
,
604 int baselen
, struct exclude_list
*el
, int srcpos
)
611 parse_exclude_pattern(&string
, &patternlen
, &flags
, &nowildcardlen
);
612 if (flags
& EXC_FLAG_MUSTBEDIR
) {
613 FLEXPTR_ALLOC_MEM(x
, pattern
, string
, patternlen
);
615 x
= xmalloc(sizeof(*x
));
618 x
->patternlen
= patternlen
;
619 x
->nowildcardlen
= nowildcardlen
;
621 x
->baselen
= baselen
;
624 ALLOC_GROW(el
->excludes
, el
->nr
+ 1, el
->alloc
);
625 el
->excludes
[el
->nr
++] = x
;
629 static int read_skip_worktree_file_from_index(const struct index_state
*istate
,
631 size_t *size_out
, char **data_out
,
632 struct oid_stat
*oid_stat
)
637 pos
= index_name_pos(istate
, path
, len
);
640 if (!ce_skip_worktree(istate
->cache
[pos
]))
643 return do_read_blob(&istate
->cache
[pos
]->oid
, oid_stat
, size_out
, data_out
);
647 * Frees memory within el which was allocated for exclude patterns and
648 * the file buffer. Does not free el itself.
650 void clear_exclude_list(struct exclude_list
*el
)
654 for (i
= 0; i
< el
->nr
; i
++)
655 free(el
->excludes
[i
]);
659 memset(el
, 0, sizeof(*el
));
662 static void trim_trailing_spaces(char *buf
)
664 char *p
, *last_space
= NULL
;
666 for (p
= buf
; *p
; p
++)
686 * Given a subdirectory name and "dir" of the current directory,
687 * search the subdir in "dir" and return it, or create a new one if it
688 * does not exist in "dir".
690 * If "name" has the trailing slash, it'll be excluded in the search.
692 static struct untracked_cache_dir
*lookup_untracked(struct untracked_cache
*uc
,
693 struct untracked_cache_dir
*dir
,
694 const char *name
, int len
)
697 struct untracked_cache_dir
*d
;
700 if (len
&& name
[len
- 1] == '/')
704 while (last
> first
) {
705 int cmp
, next
= first
+ ((last
- first
) >> 1);
707 cmp
= strncmp(name
, d
->name
, len
);
708 if (!cmp
&& strlen(d
->name
) > len
)
720 FLEX_ALLOC_MEM(d
, name
, name
, len
);
722 ALLOC_GROW(dir
->dirs
, dir
->dirs_nr
+ 1, dir
->dirs_alloc
);
723 MOVE_ARRAY(dir
->dirs
+ first
+ 1, dir
->dirs
+ first
,
724 dir
->dirs_nr
- first
);
726 dir
->dirs
[first
] = d
;
730 static void do_invalidate_gitignore(struct untracked_cache_dir
*dir
)
734 dir
->untracked_nr
= 0;
735 for (i
= 0; i
< dir
->dirs_nr
; i
++)
736 do_invalidate_gitignore(dir
->dirs
[i
]);
739 static void invalidate_gitignore(struct untracked_cache
*uc
,
740 struct untracked_cache_dir
*dir
)
742 uc
->gitignore_invalidated
++;
743 do_invalidate_gitignore(dir
);
746 static void invalidate_directory(struct untracked_cache
*uc
,
747 struct untracked_cache_dir
*dir
)
752 * Invalidation increment here is just roughly correct. If
753 * untracked_nr or any of dirs[].recurse is non-zero, we
754 * should increment dir_invalidated too. But that's more
758 uc
->dir_invalidated
++;
761 dir
->untracked_nr
= 0;
762 for (i
= 0; i
< dir
->dirs_nr
; i
++)
763 dir
->dirs
[i
]->recurse
= 0;
766 static int add_excludes_from_buffer(char *buf
, size_t size
,
767 const char *base
, int baselen
,
768 struct exclude_list
*el
);
771 * Given a file with name "fname", read it (either from disk, or from
772 * an index if 'istate' is non-null), parse it and store the
773 * exclude rules in "el".
775 * If "ss" is not NULL, compute SHA-1 of the exclude file and fill
776 * stat data from disk (only valid if add_excludes returns zero). If
777 * ss_valid is non-zero, "ss" must contain good value as input.
779 static int add_excludes(const char *fname
, const char *base
, int baselen
,
780 struct exclude_list
*el
, struct index_state
*istate
,
781 struct oid_stat
*oid_stat
)
789 fd
= open(fname
, O_RDONLY
);
790 if (fd
< 0 || fstat(fd
, &st
) < 0) {
792 warn_on_fopen_errors(fname
);
797 r
= read_skip_worktree_file_from_index(istate
, fname
,
803 size
= xsize_t(st
.st_size
);
806 fill_stat_data(&oid_stat
->stat
, &st
);
807 oidcpy(&oid_stat
->oid
, the_hash_algo
->empty_blob
);
813 buf
= xmallocz(size
);
814 if (read_in_full(fd
, buf
, size
) != size
) {
823 if (oid_stat
->valid
&&
824 !match_stat_data_racy(istate
, &oid_stat
->stat
, &st
))
825 ; /* no content change, ss->sha1 still good */
827 (pos
= index_name_pos(istate
, fname
, strlen(fname
))) >= 0 &&
828 !ce_stage(istate
->cache
[pos
]) &&
829 ce_uptodate(istate
->cache
[pos
]) &&
830 !would_convert_to_git(istate
, fname
))
831 oidcpy(&oid_stat
->oid
,
832 &istate
->cache
[pos
]->oid
);
834 hash_object_file(buf
, size
, "blob",
836 fill_stat_data(&oid_stat
->stat
, &st
);
841 add_excludes_from_buffer(buf
, size
, base
, baselen
, el
);
845 static int add_excludes_from_buffer(char *buf
, size_t size
,
846 const char *base
, int baselen
,
847 struct exclude_list
*el
)
854 if (skip_utf8_bom(&buf
, size
))
855 size
-= buf
- el
->filebuf
;
859 for (i
= 0; i
< size
; i
++) {
860 if (buf
[i
] == '\n') {
861 if (entry
!= buf
+ i
&& entry
[0] != '#') {
862 buf
[i
- (i
&& buf
[i
-1] == '\r')] = 0;
863 trim_trailing_spaces(entry
);
864 add_exclude(entry
, base
, baselen
, el
, lineno
);
873 int add_excludes_from_file_to_list(const char *fname
, const char *base
,
874 int baselen
, struct exclude_list
*el
,
875 struct index_state
*istate
)
877 return add_excludes(fname
, base
, baselen
, el
, istate
, NULL
);
880 int add_excludes_from_blob_to_list(
881 struct object_id
*oid
,
882 const char *base
, int baselen
,
883 struct exclude_list
*el
)
889 r
= do_read_blob(oid
, NULL
, &size
, &buf
);
893 add_excludes_from_buffer(buf
, size
, base
, baselen
, el
);
897 struct exclude_list
*add_exclude_list(struct dir_struct
*dir
,
898 int group_type
, const char *src
)
900 struct exclude_list
*el
;
901 struct exclude_list_group
*group
;
903 group
= &dir
->exclude_list_group
[group_type
];
904 ALLOC_GROW(group
->el
, group
->nr
+ 1, group
->alloc
);
905 el
= &group
->el
[group
->nr
++];
906 memset(el
, 0, sizeof(*el
));
912 * Used to set up core.excludesfile and .git/info/exclude lists.
914 static void add_excludes_from_file_1(struct dir_struct
*dir
, const char *fname
,
915 struct oid_stat
*oid_stat
)
917 struct exclude_list
*el
;
919 * catch setup_standard_excludes() that's called before
920 * dir->untracked is assigned. That function behaves
921 * differently when dir->untracked is non-NULL.
924 dir
->unmanaged_exclude_files
++;
925 el
= add_exclude_list(dir
, EXC_FILE
, fname
);
926 if (add_excludes(fname
, "", 0, el
, NULL
, oid_stat
) < 0)
927 die(_("cannot use %s as an exclude file"), fname
);
930 void add_excludes_from_file(struct dir_struct
*dir
, const char *fname
)
932 dir
->unmanaged_exclude_files
++; /* see validate_untracked_cache() */
933 add_excludes_from_file_1(dir
, fname
, NULL
);
936 int match_basename(const char *basename
, int basenamelen
,
937 const char *pattern
, int prefix
, int patternlen
,
940 if (prefix
== patternlen
) {
941 if (patternlen
== basenamelen
&&
942 !fspathncmp(pattern
, basename
, basenamelen
))
944 } else if (flags
& EXC_FLAG_ENDSWITH
) {
945 /* "*literal" matching against "fooliteral" */
946 if (patternlen
- 1 <= basenamelen
&&
947 !fspathncmp(pattern
+ 1,
948 basename
+ basenamelen
- (patternlen
- 1),
952 if (fnmatch_icase_mem(pattern
, patternlen
,
953 basename
, basenamelen
,
960 int match_pathname(const char *pathname
, int pathlen
,
961 const char *base
, int baselen
,
962 const char *pattern
, int prefix
, int patternlen
,
969 * match with FNM_PATHNAME; the pattern has base implicitly
972 if (*pattern
== '/') {
979 * baselen does not count the trailing slash. base[] may or
980 * may not end with a trailing slash though.
982 if (pathlen
< baselen
+ 1 ||
983 (baselen
&& pathname
[baselen
] != '/') ||
984 fspathncmp(pathname
, base
, baselen
))
987 namelen
= baselen
? pathlen
- baselen
- 1 : pathlen
;
988 name
= pathname
+ pathlen
- namelen
;
992 * if the non-wildcard part is longer than the
993 * remaining pathname, surely it cannot match.
995 if (prefix
> namelen
)
998 if (fspathncmp(pattern
, name
, prefix
))
1001 patternlen
-= prefix
;
1006 * If the whole pattern did not have a wildcard,
1007 * then our prefix match is all we need; we
1008 * do not need to call fnmatch at all.
1010 if (!patternlen
&& !namelen
)
1014 return fnmatch_icase_mem(pattern
, patternlen
,
1020 * Scan the given exclude list in reverse to see whether pathname
1021 * should be ignored. The first match (i.e. the last on the list), if
1022 * any, determines the fate. Returns the exclude_list element which
1023 * matched, or NULL for undecided.
1025 static struct exclude
*last_exclude_matching_from_list(const char *pathname
,
1027 const char *basename
,
1029 struct exclude_list
*el
,
1030 struct index_state
*istate
)
1032 struct exclude
*exc
= NULL
; /* undecided */
1036 return NULL
; /* undefined */
1038 for (i
= el
->nr
- 1; 0 <= i
; i
--) {
1039 struct exclude
*x
= el
->excludes
[i
];
1040 const char *exclude
= x
->pattern
;
1041 int prefix
= x
->nowildcardlen
;
1043 if (x
->flags
& EXC_FLAG_MUSTBEDIR
) {
1044 if (*dtype
== DT_UNKNOWN
)
1045 *dtype
= get_dtype(NULL
, istate
, pathname
, pathlen
);
1046 if (*dtype
!= DT_DIR
)
1050 if (x
->flags
& EXC_FLAG_NODIR
) {
1051 if (match_basename(basename
,
1052 pathlen
- (basename
- pathname
),
1053 exclude
, prefix
, x
->patternlen
,
1061 assert(x
->baselen
== 0 || x
->base
[x
->baselen
- 1] == '/');
1062 if (match_pathname(pathname
, pathlen
,
1063 x
->base
, x
->baselen
? x
->baselen
- 1 : 0,
1064 exclude
, prefix
, x
->patternlen
, x
->flags
)) {
1073 * Scan the list and let the last match determine the fate.
1074 * Return 1 for exclude, 0 for include and -1 for undecided.
1076 int is_excluded_from_list(const char *pathname
,
1077 int pathlen
, const char *basename
, int *dtype
,
1078 struct exclude_list
*el
, struct index_state
*istate
)
1080 struct exclude
*exclude
;
1081 exclude
= last_exclude_matching_from_list(pathname
, pathlen
, basename
,
1084 return exclude
->flags
& EXC_FLAG_NEGATIVE
? 0 : 1;
1085 return -1; /* undecided */
1088 static struct exclude
*last_exclude_matching_from_lists(struct dir_struct
*dir
,
1089 struct index_state
*istate
,
1090 const char *pathname
, int pathlen
, const char *basename
,
1094 struct exclude_list_group
*group
;
1095 struct exclude
*exclude
;
1096 for (i
= EXC_CMDL
; i
<= EXC_FILE
; i
++) {
1097 group
= &dir
->exclude_list_group
[i
];
1098 for (j
= group
->nr
- 1; j
>= 0; j
--) {
1099 exclude
= last_exclude_matching_from_list(
1100 pathname
, pathlen
, basename
, dtype_p
,
1101 &group
->el
[j
], istate
);
1110 * Loads the per-directory exclude list for the substring of base
1111 * which has a char length of baselen.
1113 static void prep_exclude(struct dir_struct
*dir
,
1114 struct index_state
*istate
,
1115 const char *base
, int baselen
)
1117 struct exclude_list_group
*group
;
1118 struct exclude_list
*el
;
1119 struct exclude_stack
*stk
= NULL
;
1120 struct untracked_cache_dir
*untracked
;
1123 group
= &dir
->exclude_list_group
[EXC_DIRS
];
1126 * Pop the exclude lists from the EXCL_DIRS exclude_list_group
1127 * which originate from directories not in the prefix of the
1128 * path being checked.
1130 while ((stk
= dir
->exclude_stack
) != NULL
) {
1131 if (stk
->baselen
<= baselen
&&
1132 !strncmp(dir
->basebuf
.buf
, base
, stk
->baselen
))
1134 el
= &group
->el
[dir
->exclude_stack
->exclude_ix
];
1135 dir
->exclude_stack
= stk
->prev
;
1136 dir
->exclude
= NULL
;
1137 free((char *)el
->src
); /* see strbuf_detach() below */
1138 clear_exclude_list(el
);
1143 /* Skip traversing into sub directories if the parent is excluded */
1148 * Lazy initialization. All call sites currently just
1149 * memset(dir, 0, sizeof(*dir)) before use. Changing all of
1150 * them seems lots of work for little benefit.
1152 if (!dir
->basebuf
.buf
)
1153 strbuf_init(&dir
->basebuf
, PATH_MAX
);
1155 /* Read from the parent directories and push them down. */
1156 current
= stk
? stk
->baselen
: -1;
1157 strbuf_setlen(&dir
->basebuf
, current
< 0 ? 0 : current
);
1159 untracked
= stk
? stk
->ucd
: dir
->untracked
->root
;
1163 while (current
< baselen
) {
1165 struct oid_stat oid_stat
;
1167 stk
= xcalloc(1, sizeof(*stk
));
1172 cp
= strchr(base
+ current
+ 1, '/');
1174 die("oops in prep_exclude");
1177 lookup_untracked(dir
->untracked
, untracked
,
1179 cp
- base
- current
);
1181 stk
->prev
= dir
->exclude_stack
;
1182 stk
->baselen
= cp
- base
;
1183 stk
->exclude_ix
= group
->nr
;
1184 stk
->ucd
= untracked
;
1185 el
= add_exclude_list(dir
, EXC_DIRS
, NULL
);
1186 strbuf_add(&dir
->basebuf
, base
+ current
, stk
->baselen
- current
);
1187 assert(stk
->baselen
== dir
->basebuf
.len
);
1189 /* Abort if the directory is excluded */
1192 dir
->basebuf
.buf
[stk
->baselen
- 1] = 0;
1193 dir
->exclude
= last_exclude_matching_from_lists(dir
,
1195 dir
->basebuf
.buf
, stk
->baselen
- 1,
1196 dir
->basebuf
.buf
+ current
, &dt
);
1197 dir
->basebuf
.buf
[stk
->baselen
- 1] = '/';
1199 dir
->exclude
->flags
& EXC_FLAG_NEGATIVE
)
1200 dir
->exclude
= NULL
;
1202 dir
->exclude_stack
= stk
;
1207 /* Try to read per-directory file */
1208 oidclr(&oid_stat
.oid
);
1210 if (dir
->exclude_per_dir
&&
1212 * If we know that no files have been added in
1213 * this directory (i.e. valid_cached_dir() has
1214 * been executed and set untracked->valid) ..
1216 (!untracked
|| !untracked
->valid
||
1218 * .. and .gitignore does not exist before
1219 * (i.e. null exclude_oid). Then we can skip
1220 * loading .gitignore, which would result in
1223 !is_null_oid(&untracked
->exclude_oid
))) {
1225 * dir->basebuf gets reused by the traversal, but we
1226 * need fname to remain unchanged to ensure the src
1227 * member of each struct exclude correctly
1228 * back-references its source file. Other invocations
1229 * of add_exclude_list provide stable strings, so we
1230 * strbuf_detach() and free() here in the caller.
1232 struct strbuf sb
= STRBUF_INIT
;
1233 strbuf_addbuf(&sb
, &dir
->basebuf
);
1234 strbuf_addstr(&sb
, dir
->exclude_per_dir
);
1235 el
->src
= strbuf_detach(&sb
, NULL
);
1236 add_excludes(el
->src
, el
->src
, stk
->baselen
, el
, istate
,
1237 untracked
? &oid_stat
: NULL
);
1240 * NEEDSWORK: when untracked cache is enabled, prep_exclude()
1241 * will first be called in valid_cached_dir() then maybe many
1242 * times more in last_exclude_matching(). When the cache is
1243 * used, last_exclude_matching() will not be called and
1244 * reading .gitignore content will be a waste.
1246 * So when it's called by valid_cached_dir() and we can get
1247 * .gitignore SHA-1 from the index (i.e. .gitignore is not
1248 * modified on work tree), we could delay reading the
1249 * .gitignore content until we absolutely need it in
1250 * last_exclude_matching(). Be careful about ignore rule
1251 * order, though, if you do that.
1254 !oideq(&oid_stat
.oid
, &untracked
->exclude_oid
)) {
1255 invalidate_gitignore(dir
->untracked
, untracked
);
1256 oidcpy(&untracked
->exclude_oid
, &oid_stat
.oid
);
1258 dir
->exclude_stack
= stk
;
1259 current
= stk
->baselen
;
1261 strbuf_setlen(&dir
->basebuf
, baselen
);
1265 * Loads the exclude lists for the directory containing pathname, then
1266 * scans all exclude lists to determine whether pathname is excluded.
1267 * Returns the exclude_list element which matched, or NULL for
1270 struct exclude
*last_exclude_matching(struct dir_struct
*dir
,
1271 struct index_state
*istate
,
1272 const char *pathname
,
1275 int pathlen
= strlen(pathname
);
1276 const char *basename
= strrchr(pathname
, '/');
1277 basename
= (basename
) ? basename
+1 : pathname
;
1279 prep_exclude(dir
, istate
, pathname
, basename
-pathname
);
1282 return dir
->exclude
;
1284 return last_exclude_matching_from_lists(dir
, istate
, pathname
, pathlen
,
1289 * Loads the exclude lists for the directory containing pathname, then
1290 * scans all exclude lists to determine whether pathname is excluded.
1291 * Returns 1 if true, otherwise 0.
1293 int is_excluded(struct dir_struct
*dir
, struct index_state
*istate
,
1294 const char *pathname
, int *dtype_p
)
1296 struct exclude
*exclude
=
1297 last_exclude_matching(dir
, istate
, pathname
, dtype_p
);
1299 return exclude
->flags
& EXC_FLAG_NEGATIVE
? 0 : 1;
1303 static struct dir_entry
*dir_entry_new(const char *pathname
, int len
)
1305 struct dir_entry
*ent
;
1307 FLEX_ALLOC_MEM(ent
, name
, pathname
, len
);
1312 static struct dir_entry
*dir_add_name(struct dir_struct
*dir
,
1313 struct index_state
*istate
,
1314 const char *pathname
, int len
)
1316 if (index_file_exists(istate
, pathname
, len
, ignore_case
))
1319 ALLOC_GROW(dir
->entries
, dir
->nr
+1, dir
->alloc
);
1320 return dir
->entries
[dir
->nr
++] = dir_entry_new(pathname
, len
);
1323 struct dir_entry
*dir_add_ignored(struct dir_struct
*dir
,
1324 struct index_state
*istate
,
1325 const char *pathname
, int len
)
1327 if (!index_name_is_other(istate
, pathname
, len
))
1330 ALLOC_GROW(dir
->ignored
, dir
->ignored_nr
+1, dir
->ignored_alloc
);
1331 return dir
->ignored
[dir
->ignored_nr
++] = dir_entry_new(pathname
, len
);
1335 index_nonexistent
= 0,
1341 * Do not use the alphabetically sorted index to look up
1342 * the directory name; instead, use the case insensitive
1345 static enum exist_status
directory_exists_in_index_icase(struct index_state
*istate
,
1346 const char *dirname
, int len
)
1348 struct cache_entry
*ce
;
1350 if (index_dir_exists(istate
, dirname
, len
))
1351 return index_directory
;
1353 ce
= index_file_exists(istate
, dirname
, len
, ignore_case
);
1354 if (ce
&& S_ISGITLINK(ce
->ce_mode
))
1355 return index_gitdir
;
1357 return index_nonexistent
;
1361 * The index sorts alphabetically by entry name, which
1362 * means that a gitlink sorts as '\0' at the end, while
1363 * a directory (which is defined not as an entry, but as
1364 * the files it contains) will sort with the '/' at the
1367 static enum exist_status
directory_exists_in_index(struct index_state
*istate
,
1368 const char *dirname
, int len
)
1373 return directory_exists_in_index_icase(istate
, dirname
, len
);
1375 pos
= index_name_pos(istate
, dirname
, len
);
1378 while (pos
< istate
->cache_nr
) {
1379 const struct cache_entry
*ce
= istate
->cache
[pos
++];
1380 unsigned char endchar
;
1382 if (strncmp(ce
->name
, dirname
, len
))
1384 endchar
= ce
->name
[len
];
1388 return index_directory
;
1389 if (!endchar
&& S_ISGITLINK(ce
->ce_mode
))
1390 return index_gitdir
;
1392 return index_nonexistent
;
1396 * When we find a directory when traversing the filesystem, we
1397 * have three distinct cases:
1400 * - see it as a directory
1403 * and which one we choose depends on a combination of existing
1404 * git index contents and the flags passed into the directory
1405 * traversal routine.
1407 * Case 1: If we *already* have entries in the index under that
1408 * directory name, we always recurse into the directory to see
1411 * Case 2: If we *already* have that directory name as a gitlink,
1412 * we always continue to see it as a gitlink, regardless of whether
1413 * there is an actual git directory there or not (it might not
1414 * be checked out as a subproject!)
1416 * Case 3: if we didn't have it in the index previously, we
1417 * have a few sub-cases:
1419 * (a) if "show_other_directories" is true, we show it as
1420 * just a directory, unless "hide_empty_directories" is
1421 * also true, in which case we need to check if it contains any
1422 * untracked and / or ignored files.
1423 * (b) if it looks like a git directory, and we don't have
1424 * 'no_gitlinks' set we treat it as a gitlink, and show it
1426 * (c) otherwise, we recurse into it.
1428 static enum path_treatment
treat_directory(struct dir_struct
*dir
,
1429 struct index_state
*istate
,
1430 struct untracked_cache_dir
*untracked
,
1431 const char *dirname
, int len
, int baselen
, int exclude
,
1432 const struct pathspec
*pathspec
)
1434 /* The "len-1" is to strip the final '/' */
1435 switch (directory_exists_in_index(istate
, dirname
, len
-1)) {
1436 case index_directory
:
1437 return path_recurse
;
1442 case index_nonexistent
:
1443 if (dir
->flags
& DIR_SHOW_OTHER_DIRECTORIES
)
1446 (dir
->flags
& DIR_SHOW_IGNORED_TOO
) &&
1447 (dir
->flags
& DIR_SHOW_IGNORED_TOO_MODE_MATCHING
)) {
1450 * This is an excluded directory and we are
1451 * showing ignored paths that match an exclude
1452 * pattern. (e.g. show directory as ignored
1453 * only if it matches an exclude pattern).
1454 * This path will either be 'path_excluded`
1455 * (if we are showing empty directories or if
1456 * the directory is not empty), or will be
1457 * 'path_none' (empty directory, and we are
1458 * not showing empty directories).
1460 if (!(dir
->flags
& DIR_HIDE_EMPTY_DIRECTORIES
))
1461 return path_excluded
;
1463 if (read_directory_recursive(dir
, istate
, dirname
, len
,
1464 untracked
, 1, 1, pathspec
) == path_excluded
)
1465 return path_excluded
;
1469 if (!(dir
->flags
& DIR_NO_GITLINKS
)) {
1470 struct strbuf sb
= STRBUF_INIT
;
1471 strbuf_addstr(&sb
, dirname
);
1472 if (is_nonbare_repository_dir(&sb
))
1473 return exclude
? path_excluded
: path_untracked
;
1474 strbuf_release(&sb
);
1476 return path_recurse
;
1479 /* This is the "show_other_directories" case */
1481 if (!(dir
->flags
& DIR_HIDE_EMPTY_DIRECTORIES
))
1482 return exclude
? path_excluded
: path_untracked
;
1484 untracked
= lookup_untracked(dir
->untracked
, untracked
,
1485 dirname
+ baselen
, len
- baselen
);
1488 * If this is an excluded directory, then we only need to check if
1489 * the directory contains any files.
1491 return read_directory_recursive(dir
, istate
, dirname
, len
,
1492 untracked
, 1, exclude
, pathspec
);
1496 * This is an inexact early pruning of any recursive directory
1497 * reading - if the path cannot possibly be in the pathspec,
1498 * return true, and we'll skip it early.
1500 static int simplify_away(const char *path
, int pathlen
,
1501 const struct pathspec
*pathspec
)
1505 if (!pathspec
|| !pathspec
->nr
)
1508 GUARD_PATHSPEC(pathspec
,
1517 for (i
= 0; i
< pathspec
->nr
; i
++) {
1518 const struct pathspec_item
*item
= &pathspec
->items
[i
];
1519 int len
= item
->nowildcard_len
;
1523 if (!ps_strncmp(item
, item
->match
, path
, len
))
1531 * This function tells us whether an excluded path matches a
1532 * list of "interesting" pathspecs. That is, whether a path matched
1533 * by any of the pathspecs could possibly be ignored by excluding
1534 * the specified path. This can happen if:
1536 * 1. the path is mentioned explicitly in the pathspec
1538 * 2. the path is a directory prefix of some element in the
1541 static int exclude_matches_pathspec(const char *path
, int pathlen
,
1542 const struct pathspec
*pathspec
)
1546 if (!pathspec
|| !pathspec
->nr
)
1549 GUARD_PATHSPEC(pathspec
,
1557 for (i
= 0; i
< pathspec
->nr
; i
++) {
1558 const struct pathspec_item
*item
= &pathspec
->items
[i
];
1559 int len
= item
->nowildcard_len
;
1561 if (len
== pathlen
&&
1562 !ps_strncmp(item
, item
->match
, path
, pathlen
))
1564 if (len
> pathlen
&&
1565 item
->match
[pathlen
] == '/' &&
1566 !ps_strncmp(item
, item
->match
, path
, pathlen
))
1572 static int get_index_dtype(struct index_state
*istate
,
1573 const char *path
, int len
)
1576 const struct cache_entry
*ce
;
1578 ce
= index_file_exists(istate
, path
, len
, 0);
1580 if (!ce_uptodate(ce
))
1582 if (S_ISGITLINK(ce
->ce_mode
))
1585 * Nobody actually cares about the
1586 * difference between DT_LNK and DT_REG
1591 /* Try to look it up as a directory */
1592 pos
= index_name_pos(istate
, path
, len
);
1596 while (pos
< istate
->cache_nr
) {
1597 ce
= istate
->cache
[pos
++];
1598 if (strncmp(ce
->name
, path
, len
))
1600 if (ce
->name
[len
] > '/')
1602 if (ce
->name
[len
] < '/')
1604 if (!ce_uptodate(ce
))
1605 break; /* continue? */
1611 static int get_dtype(struct dirent
*de
, struct index_state
*istate
,
1612 const char *path
, int len
)
1614 int dtype
= de
? DTYPE(de
) : DT_UNKNOWN
;
1617 if (dtype
!= DT_UNKNOWN
)
1619 dtype
= get_index_dtype(istate
, path
, len
);
1620 if (dtype
!= DT_UNKNOWN
)
1622 if (lstat(path
, &st
))
1624 if (S_ISREG(st
.st_mode
))
1626 if (S_ISDIR(st
.st_mode
))
1628 if (S_ISLNK(st
.st_mode
))
1633 static enum path_treatment
treat_one_path(struct dir_struct
*dir
,
1634 struct untracked_cache_dir
*untracked
,
1635 struct index_state
*istate
,
1636 struct strbuf
*path
,
1638 const struct pathspec
*pathspec
,
1639 int dtype
, struct dirent
*de
)
1642 int has_path_in_index
= !!index_file_exists(istate
, path
->buf
, path
->len
, ignore_case
);
1643 enum path_treatment path_treatment
;
1645 if (dtype
== DT_UNKNOWN
)
1646 dtype
= get_dtype(de
, istate
, path
->buf
, path
->len
);
1648 /* Always exclude indexed files */
1649 if (dtype
!= DT_DIR
&& has_path_in_index
)
1653 * When we are looking at a directory P in the working tree,
1654 * there are three cases:
1656 * (1) P exists in the index. Everything inside the directory P in
1657 * the working tree needs to go when P is checked out from the
1660 * (2) P does not exist in the index, but there is P/Q in the index.
1661 * We know P will stay a directory when we check out the contents
1662 * of the index, but we do not know yet if there is a directory
1663 * P/Q in the working tree to be killed, so we need to recurse.
1665 * (3) P does not exist in the index, and there is no P/Q in the index
1666 * to require P to be a directory, either. Only in this case, we
1667 * know that everything inside P will not be killed without
1670 if ((dir
->flags
& DIR_COLLECT_KILLED_ONLY
) &&
1671 (dtype
== DT_DIR
) &&
1672 !has_path_in_index
&&
1673 (directory_exists_in_index(istate
, path
->buf
, path
->len
) == index_nonexistent
))
1676 exclude
= is_excluded(dir
, istate
, path
->buf
, &dtype
);
1679 * Excluded? If we don't explicitly want to show
1680 * ignored files, ignore it
1682 if (exclude
&& !(dir
->flags
& (DIR_SHOW_IGNORED
|DIR_SHOW_IGNORED_TOO
)))
1683 return path_excluded
;
1689 strbuf_addch(path
, '/');
1690 path_treatment
= treat_directory(dir
, istate
, untracked
,
1691 path
->buf
, path
->len
,
1692 baselen
, exclude
, pathspec
);
1694 * If 1) we only want to return directories that
1695 * match an exclude pattern and 2) this directory does
1696 * not match an exclude pattern but all of its
1697 * contents are excluded, then indicate that we should
1698 * recurse into this directory (instead of marking the
1699 * directory itself as an ignored path).
1702 path_treatment
== path_excluded
&&
1703 (dir
->flags
& DIR_SHOW_IGNORED_TOO
) &&
1704 (dir
->flags
& DIR_SHOW_IGNORED_TOO_MODE_MATCHING
))
1705 return path_recurse
;
1706 return path_treatment
;
1709 return exclude
? path_excluded
: path_untracked
;
1713 static enum path_treatment
treat_path_fast(struct dir_struct
*dir
,
1714 struct untracked_cache_dir
*untracked
,
1715 struct cached_dir
*cdir
,
1716 struct index_state
*istate
,
1717 struct strbuf
*path
,
1719 const struct pathspec
*pathspec
)
1721 strbuf_setlen(path
, baselen
);
1723 strbuf_addstr(path
, cdir
->file
);
1724 return path_untracked
;
1726 strbuf_addstr(path
, cdir
->ucd
->name
);
1727 /* treat_one_path() does this before it calls treat_directory() */
1728 strbuf_complete(path
, '/');
1729 if (cdir
->ucd
->check_only
)
1731 * check_only is set as a result of treat_directory() getting
1732 * to its bottom. Verify again the same set of directories
1733 * with check_only set.
1735 return read_directory_recursive(dir
, istate
, path
->buf
, path
->len
,
1736 cdir
->ucd
, 1, 0, pathspec
);
1738 * We get path_recurse in the first run when
1739 * directory_exists_in_index() returns index_nonexistent. We
1740 * are sure that new changes in the index does not impact the
1741 * outcome. Return now.
1743 return path_recurse
;
1746 static enum path_treatment
treat_path(struct dir_struct
*dir
,
1747 struct untracked_cache_dir
*untracked
,
1748 struct cached_dir
*cdir
,
1749 struct index_state
*istate
,
1750 struct strbuf
*path
,
1752 const struct pathspec
*pathspec
)
1755 struct dirent
*de
= cdir
->de
;
1758 return treat_path_fast(dir
, untracked
, cdir
, istate
, path
,
1760 if (is_dot_or_dotdot(de
->d_name
) || !fspathcmp(de
->d_name
, ".git"))
1762 strbuf_setlen(path
, baselen
);
1763 strbuf_addstr(path
, de
->d_name
);
1764 if (simplify_away(path
->buf
, path
->len
, pathspec
))
1768 return treat_one_path(dir
, untracked
, istate
, path
, baselen
, pathspec
, dtype
, de
);
1771 static void add_untracked(struct untracked_cache_dir
*dir
, const char *name
)
1775 ALLOC_GROW(dir
->untracked
, dir
->untracked_nr
+ 1,
1776 dir
->untracked_alloc
);
1777 dir
->untracked
[dir
->untracked_nr
++] = xstrdup(name
);
1780 static int valid_cached_dir(struct dir_struct
*dir
,
1781 struct untracked_cache_dir
*untracked
,
1782 struct index_state
*istate
,
1783 struct strbuf
*path
,
1792 * With fsmonitor, we can trust the untracked cache's valid field.
1794 refresh_fsmonitor(istate
);
1795 if (!(dir
->untracked
->use_fsmonitor
&& untracked
->valid
)) {
1796 if (lstat(path
->len
? path
->buf
: ".", &st
)) {
1797 memset(&untracked
->stat_data
, 0, sizeof(untracked
->stat_data
));
1800 if (!untracked
->valid
||
1801 match_stat_data_racy(istate
, &untracked
->stat_data
, &st
)) {
1802 fill_stat_data(&untracked
->stat_data
, &st
);
1807 if (untracked
->check_only
!= !!check_only
)
1811 * prep_exclude will be called eventually on this directory,
1812 * but it's called much later in last_exclude_matching(). We
1813 * need it now to determine the validity of the cache for this
1814 * path. The next calls will be nearly no-op, the way
1815 * prep_exclude() is designed.
1817 if (path
->len
&& path
->buf
[path
->len
- 1] != '/') {
1818 strbuf_addch(path
, '/');
1819 prep_exclude(dir
, istate
, path
->buf
, path
->len
);
1820 strbuf_setlen(path
, path
->len
- 1);
1822 prep_exclude(dir
, istate
, path
->buf
, path
->len
);
1824 /* hopefully prep_exclude() haven't invalidated this entry... */
1825 return untracked
->valid
;
1828 static int open_cached_dir(struct cached_dir
*cdir
,
1829 struct dir_struct
*dir
,
1830 struct untracked_cache_dir
*untracked
,
1831 struct index_state
*istate
,
1832 struct strbuf
*path
,
1837 memset(cdir
, 0, sizeof(*cdir
));
1838 cdir
->untracked
= untracked
;
1839 if (valid_cached_dir(dir
, untracked
, istate
, path
, check_only
))
1841 c_path
= path
->len
? path
->buf
: ".";
1842 cdir
->fdir
= opendir(c_path
);
1844 warning_errno(_("could not open directory '%s'"), c_path
);
1845 if (dir
->untracked
) {
1846 invalidate_directory(dir
->untracked
, untracked
);
1847 dir
->untracked
->dir_opened
++;
1854 static int read_cached_dir(struct cached_dir
*cdir
)
1857 cdir
->de
= readdir(cdir
->fdir
);
1862 while (cdir
->nr_dirs
< cdir
->untracked
->dirs_nr
) {
1863 struct untracked_cache_dir
*d
= cdir
->untracked
->dirs
[cdir
->nr_dirs
];
1873 if (cdir
->nr_files
< cdir
->untracked
->untracked_nr
) {
1874 struct untracked_cache_dir
*d
= cdir
->untracked
;
1875 cdir
->file
= d
->untracked
[cdir
->nr_files
++];
1881 static void close_cached_dir(struct cached_dir
*cdir
)
1884 closedir(cdir
->fdir
);
1886 * We have gone through this directory and found no untracked
1887 * entries. Mark it valid.
1889 if (cdir
->untracked
) {
1890 cdir
->untracked
->valid
= 1;
1891 cdir
->untracked
->recurse
= 1;
1896 * Read a directory tree. We currently ignore anything but
1897 * directories, regular files and symlinks. That's because git
1898 * doesn't handle them at all yet. Maybe that will change some
1901 * Also, we ignore the name ".git" (even if it is not a directory).
1902 * That likely will not change.
1904 * If 'stop_at_first_file' is specified, 'path_excluded' is returned
1905 * to signal that a file was found. This is the least significant value that
1906 * indicates that a file was encountered that does not depend on the order of
1907 * whether an untracked or exluded path was encountered first.
1909 * Returns the most significant path_treatment value encountered in the scan.
1910 * If 'stop_at_first_file' is specified, `path_excluded` is the most
1911 * significant path_treatment value that will be returned.
1914 static enum path_treatment
read_directory_recursive(struct dir_struct
*dir
,
1915 struct index_state
*istate
, const char *base
, int baselen
,
1916 struct untracked_cache_dir
*untracked
, int check_only
,
1917 int stop_at_first_file
, const struct pathspec
*pathspec
)
1919 struct cached_dir cdir
;
1920 enum path_treatment state
, subdir_state
, dir_state
= path_none
;
1921 struct strbuf path
= STRBUF_INIT
;
1923 strbuf_add(&path
, base
, baselen
);
1925 if (open_cached_dir(&cdir
, dir
, untracked
, istate
, &path
, check_only
))
1929 untracked
->check_only
= !!check_only
;
1931 while (!read_cached_dir(&cdir
)) {
1932 /* check how the file or directory should be treated */
1933 state
= treat_path(dir
, untracked
, &cdir
, istate
, &path
,
1936 if (state
> dir_state
)
1939 /* recurse into subdir if instructed by treat_path */
1940 if ((state
== path_recurse
) ||
1941 ((state
== path_untracked
) &&
1942 (dir
->flags
& DIR_SHOW_IGNORED_TOO
) &&
1943 (get_dtype(cdir
.de
, istate
, path
.buf
, path
.len
) == DT_DIR
))) {
1944 struct untracked_cache_dir
*ud
;
1945 ud
= lookup_untracked(dir
->untracked
, untracked
,
1947 path
.len
- baselen
);
1949 read_directory_recursive(dir
, istate
, path
.buf
,
1951 check_only
, stop_at_first_file
, pathspec
);
1952 if (subdir_state
> dir_state
)
1953 dir_state
= subdir_state
;
1957 if (stop_at_first_file
) {
1959 * If stopping at first file, then
1960 * signal that a file was found by
1961 * returning `path_excluded`. This is
1962 * to return a consistent value
1963 * regardless of whether an ignored or
1964 * excluded file happened to be
1967 * In current usage, the
1968 * `stop_at_first_file` is passed when
1969 * an ancestor directory has matched
1970 * an exclude pattern, so any found
1971 * files will be excluded.
1973 if (dir_state
>= path_excluded
) {
1974 dir_state
= path_excluded
;
1979 /* abort early if maximum state has been reached */
1980 if (dir_state
== path_untracked
) {
1982 add_untracked(untracked
, path
.buf
+ baselen
);
1985 /* skip the dir_add_* part */
1989 /* add the path to the appropriate result list */
1992 if (dir
->flags
& DIR_SHOW_IGNORED
)
1993 dir_add_name(dir
, istate
, path
.buf
, path
.len
);
1994 else if ((dir
->flags
& DIR_SHOW_IGNORED_TOO
) ||
1995 ((dir
->flags
& DIR_COLLECT_IGNORED
) &&
1996 exclude_matches_pathspec(path
.buf
, path
.len
,
1998 dir_add_ignored(dir
, istate
, path
.buf
, path
.len
);
2001 case path_untracked
:
2002 if (dir
->flags
& DIR_SHOW_IGNORED
)
2004 dir_add_name(dir
, istate
, path
.buf
, path
.len
);
2006 add_untracked(untracked
, path
.buf
+ baselen
);
2013 close_cached_dir(&cdir
);
2015 strbuf_release(&path
);
2020 int cmp_dir_entry(const void *p1
, const void *p2
)
2022 const struct dir_entry
*e1
= *(const struct dir_entry
**)p1
;
2023 const struct dir_entry
*e2
= *(const struct dir_entry
**)p2
;
2025 return name_compare(e1
->name
, e1
->len
, e2
->name
, e2
->len
);
2028 /* check if *out lexically strictly contains *in */
2029 int check_dir_entry_contains(const struct dir_entry
*out
, const struct dir_entry
*in
)
2031 return (out
->len
< in
->len
) &&
2032 (out
->name
[out
->len
- 1] == '/') &&
2033 !memcmp(out
->name
, in
->name
, out
->len
);
2036 static int treat_leading_path(struct dir_struct
*dir
,
2037 struct index_state
*istate
,
2038 const char *path
, int len
,
2039 const struct pathspec
*pathspec
)
2041 struct strbuf sb
= STRBUF_INIT
;
2042 int baselen
, rc
= 0;
2044 int old_flags
= dir
->flags
;
2046 while (len
&& path
[len
- 1] == '/')
2051 dir
->flags
&= ~DIR_SHOW_OTHER_DIRECTORIES
;
2053 cp
= path
+ baselen
+ !!baselen
;
2054 cp
= memchr(cp
, '/', path
+ len
- cp
);
2058 baselen
= cp
- path
;
2059 strbuf_setlen(&sb
, 0);
2060 strbuf_add(&sb
, path
, baselen
);
2061 if (!is_directory(sb
.buf
))
2063 if (simplify_away(sb
.buf
, sb
.len
, pathspec
))
2065 if (treat_one_path(dir
, NULL
, istate
, &sb
, baselen
, pathspec
,
2066 DT_DIR
, NULL
) == path_none
)
2067 break; /* do not recurse into it */
2068 if (len
<= baselen
) {
2070 break; /* finished checking */
2073 strbuf_release(&sb
);
2074 dir
->flags
= old_flags
;
2078 static const char *get_ident_string(void)
2080 static struct strbuf sb
= STRBUF_INIT
;
2085 if (uname(&uts
) < 0)
2086 die_errno(_("failed to get kernel name and information"));
2087 strbuf_addf(&sb
, "Location %s, system %s", get_git_work_tree(),
2092 static int ident_in_untracked(const struct untracked_cache
*uc
)
2095 * Previous git versions may have saved many NUL separated
2096 * strings in the "ident" field, but it is insane to manage
2097 * many locations, so just take care of the first one.
2100 return !strcmp(uc
->ident
.buf
, get_ident_string());
2103 static void set_untracked_ident(struct untracked_cache
*uc
)
2105 strbuf_reset(&uc
->ident
);
2106 strbuf_addstr(&uc
->ident
, get_ident_string());
2109 * This strbuf used to contain a list of NUL separated
2110 * strings, so save NUL too for backward compatibility.
2112 strbuf_addch(&uc
->ident
, 0);
2115 static void new_untracked_cache(struct index_state
*istate
)
2117 struct untracked_cache
*uc
= xcalloc(1, sizeof(*uc
));
2118 strbuf_init(&uc
->ident
, 100);
2119 uc
->exclude_per_dir
= ".gitignore";
2120 /* should be the same flags used by git-status */
2121 uc
->dir_flags
= DIR_SHOW_OTHER_DIRECTORIES
| DIR_HIDE_EMPTY_DIRECTORIES
;
2122 set_untracked_ident(uc
);
2123 istate
->untracked
= uc
;
2124 istate
->cache_changed
|= UNTRACKED_CHANGED
;
2127 void add_untracked_cache(struct index_state
*istate
)
2129 if (!istate
->untracked
) {
2130 new_untracked_cache(istate
);
2132 if (!ident_in_untracked(istate
->untracked
)) {
2133 free_untracked_cache(istate
->untracked
);
2134 new_untracked_cache(istate
);
2139 void remove_untracked_cache(struct index_state
*istate
)
2141 if (istate
->untracked
) {
2142 free_untracked_cache(istate
->untracked
);
2143 istate
->untracked
= NULL
;
2144 istate
->cache_changed
|= UNTRACKED_CHANGED
;
2148 static struct untracked_cache_dir
*validate_untracked_cache(struct dir_struct
*dir
,
2150 const struct pathspec
*pathspec
)
2152 struct untracked_cache_dir
*root
;
2153 static int untracked_cache_disabled
= -1;
2155 if (!dir
->untracked
)
2157 if (untracked_cache_disabled
< 0)
2158 untracked_cache_disabled
= git_env_bool("GIT_DISABLE_UNTRACKED_CACHE", 0);
2159 if (untracked_cache_disabled
)
2163 * We only support $GIT_DIR/info/exclude and core.excludesfile
2164 * as the global ignore rule files. Any other additions
2165 * (e.g. from command line) invalidate the cache. This
2166 * condition also catches running setup_standard_excludes()
2167 * before setting dir->untracked!
2169 if (dir
->unmanaged_exclude_files
)
2173 * Optimize for the main use case only: whole-tree git
2174 * status. More work involved in treat_leading_path() if we
2175 * use cache on just a subset of the worktree. pathspec
2176 * support could make the matter even worse.
2178 if (base_len
|| (pathspec
&& pathspec
->nr
))
2181 /* Different set of flags may produce different results */
2182 if (dir
->flags
!= dir
->untracked
->dir_flags
||
2184 * See treat_directory(), case index_nonexistent. Without
2185 * this flag, we may need to also cache .git file content
2186 * for the resolve_gitlink_ref() call, which we don't.
2188 !(dir
->flags
& DIR_SHOW_OTHER_DIRECTORIES
) ||
2189 /* We don't support collecting ignore files */
2190 (dir
->flags
& (DIR_SHOW_IGNORED
| DIR_SHOW_IGNORED_TOO
|
2191 DIR_COLLECT_IGNORED
)))
2195 * If we use .gitignore in the cache and now you change it to
2196 * .gitexclude, everything will go wrong.
2198 if (dir
->exclude_per_dir
!= dir
->untracked
->exclude_per_dir
&&
2199 strcmp(dir
->exclude_per_dir
, dir
->untracked
->exclude_per_dir
))
2203 * EXC_CMDL is not considered in the cache. If people set it,
2206 if (dir
->exclude_list_group
[EXC_CMDL
].nr
)
2209 if (!ident_in_untracked(dir
->untracked
)) {
2210 warning(_("untracked cache is disabled on this system or location"));
2214 if (!dir
->untracked
->root
) {
2215 const int len
= sizeof(*dir
->untracked
->root
);
2216 dir
->untracked
->root
= xmalloc(len
);
2217 memset(dir
->untracked
->root
, 0, len
);
2220 /* Validate $GIT_DIR/info/exclude and core.excludesfile */
2221 root
= dir
->untracked
->root
;
2222 if (!oideq(&dir
->ss_info_exclude
.oid
,
2223 &dir
->untracked
->ss_info_exclude
.oid
)) {
2224 invalidate_gitignore(dir
->untracked
, root
);
2225 dir
->untracked
->ss_info_exclude
= dir
->ss_info_exclude
;
2227 if (!oideq(&dir
->ss_excludes_file
.oid
,
2228 &dir
->untracked
->ss_excludes_file
.oid
)) {
2229 invalidate_gitignore(dir
->untracked
, root
);
2230 dir
->untracked
->ss_excludes_file
= dir
->ss_excludes_file
;
2233 /* Make sure this directory is not dropped out at saving phase */
2238 int read_directory(struct dir_struct
*dir
, struct index_state
*istate
,
2239 const char *path
, int len
, const struct pathspec
*pathspec
)
2241 struct untracked_cache_dir
*untracked
;
2243 trace_performance_enter();
2245 if (has_symlink_leading_path(path
, len
)) {
2246 trace_performance_leave("read directory %.*s", len
, path
);
2250 untracked
= validate_untracked_cache(dir
, len
, pathspec
);
2253 * make sure untracked cache code path is disabled,
2254 * e.g. prep_exclude()
2256 dir
->untracked
= NULL
;
2257 if (!len
|| treat_leading_path(dir
, istate
, path
, len
, pathspec
))
2258 read_directory_recursive(dir
, istate
, path
, len
, untracked
, 0, 0, pathspec
);
2259 QSORT(dir
->entries
, dir
->nr
, cmp_dir_entry
);
2260 QSORT(dir
->ignored
, dir
->ignored_nr
, cmp_dir_entry
);
2263 * If DIR_SHOW_IGNORED_TOO is set, read_directory_recursive() will
2264 * also pick up untracked contents of untracked dirs; by default
2265 * we discard these, but given DIR_KEEP_UNTRACKED_CONTENTS we do not.
2267 if ((dir
->flags
& DIR_SHOW_IGNORED_TOO
) &&
2268 !(dir
->flags
& DIR_KEEP_UNTRACKED_CONTENTS
)) {
2271 /* remove from dir->entries untracked contents of untracked dirs */
2272 for (i
= j
= 0; j
< dir
->nr
; j
++) {
2274 check_dir_entry_contains(dir
->entries
[i
- 1], dir
->entries
[j
])) {
2275 FREE_AND_NULL(dir
->entries
[j
]);
2277 dir
->entries
[i
++] = dir
->entries
[j
];
2284 trace_performance_leave("read directory %.*s", len
, path
);
2285 if (dir
->untracked
) {
2286 static int force_untracked_cache
= -1;
2287 static struct trace_key trace_untracked_stats
= TRACE_KEY_INIT(UNTRACKED_STATS
);
2289 if (force_untracked_cache
< 0)
2290 force_untracked_cache
=
2291 git_env_bool("GIT_FORCE_UNTRACKED_CACHE", 0);
2292 trace_printf_key(&trace_untracked_stats
,
2293 "node creation: %u\n"
2294 "gitignore invalidation: %u\n"
2295 "directory invalidation: %u\n"
2297 dir
->untracked
->dir_created
,
2298 dir
->untracked
->gitignore_invalidated
,
2299 dir
->untracked
->dir_invalidated
,
2300 dir
->untracked
->dir_opened
);
2301 if (force_untracked_cache
&&
2302 dir
->untracked
== istate
->untracked
&&
2303 (dir
->untracked
->dir_opened
||
2304 dir
->untracked
->gitignore_invalidated
||
2305 dir
->untracked
->dir_invalidated
))
2306 istate
->cache_changed
|= UNTRACKED_CHANGED
;
2307 if (dir
->untracked
!= istate
->untracked
) {
2308 FREE_AND_NULL(dir
->untracked
);
2314 int file_exists(const char *f
)
2317 return lstat(f
, &sb
) == 0;
2320 int repo_file_exists(struct repository
*repo
, const char *path
)
2322 if (repo
!= the_repository
)
2323 BUG("do not know how to check file existence in arbitrary repo");
2325 return file_exists(path
);
2328 static int cmp_icase(char a
, char b
)
2333 return toupper(a
) - toupper(b
);
2338 * Given two normalized paths (a trailing slash is ok), if subdir is
2339 * outside dir, return -1. Otherwise return the offset in subdir that
2340 * can be used as relative path to dir.
2342 int dir_inside_of(const char *subdir
, const char *dir
)
2346 assert(dir
&& subdir
&& *dir
&& *subdir
);
2348 while (*dir
&& *subdir
&& !cmp_icase(*dir
, *subdir
)) {
2354 /* hel[p]/me vs hel[l]/yeah */
2355 if (*dir
&& *subdir
)
2359 return !*dir
? offset
: -1; /* same dir */
2361 /* foo/[b]ar vs foo/[] */
2362 if (is_dir_sep(dir
[-1]))
2363 return is_dir_sep(subdir
[-1]) ? offset
: -1;
2365 /* foo[/]bar vs foo[] */
2366 return is_dir_sep(*subdir
) ? offset
+ 1 : -1;
2369 int is_inside_dir(const char *dir
)
2378 rc
= (dir_inside_of(cwd
, dir
) >= 0);
2383 int is_empty_dir(const char *path
)
2385 DIR *dir
= opendir(path
);
2392 while ((e
= readdir(dir
)) != NULL
)
2393 if (!is_dot_or_dotdot(e
->d_name
)) {
2402 static int remove_dir_recurse(struct strbuf
*path
, int flag
, int *kept_up
)
2406 int ret
= 0, original_len
= path
->len
, len
, kept_down
= 0;
2407 int only_empty
= (flag
& REMOVE_DIR_EMPTY_ONLY
);
2408 int keep_toplevel
= (flag
& REMOVE_DIR_KEEP_TOPLEVEL
);
2409 struct object_id submodule_head
;
2411 if ((flag
& REMOVE_DIR_KEEP_NESTED_GIT
) &&
2412 !resolve_gitlink_ref(path
->buf
, "HEAD", &submodule_head
)) {
2413 /* Do not descend and nuke a nested git work tree. */
2419 flag
&= ~REMOVE_DIR_KEEP_TOPLEVEL
;
2420 dir
= opendir(path
->buf
);
2422 if (errno
== ENOENT
)
2423 return keep_toplevel
? -1 : 0;
2424 else if (errno
== EACCES
&& !keep_toplevel
)
2426 * An empty dir could be removable even if it
2429 return rmdir(path
->buf
);
2433 strbuf_complete(path
, '/');
2436 while ((e
= readdir(dir
)) != NULL
) {
2438 if (is_dot_or_dotdot(e
->d_name
))
2441 strbuf_setlen(path
, len
);
2442 strbuf_addstr(path
, e
->d_name
);
2443 if (lstat(path
->buf
, &st
)) {
2444 if (errno
== ENOENT
)
2446 * file disappeared, which is what we
2451 } else if (S_ISDIR(st
.st_mode
)) {
2452 if (!remove_dir_recurse(path
, flag
, &kept_down
))
2453 continue; /* happy */
2454 } else if (!only_empty
&&
2455 (!unlink(path
->buf
) || errno
== ENOENT
)) {
2456 continue; /* happy, too */
2459 /* path too long, stat fails, or non-directory still exists */
2465 strbuf_setlen(path
, original_len
);
2466 if (!ret
&& !keep_toplevel
&& !kept_down
)
2467 ret
= (!rmdir(path
->buf
) || errno
== ENOENT
) ? 0 : -1;
2470 * report the uplevel that it is not an error that we
2471 * did not rmdir() our directory.
2477 int remove_dir_recursively(struct strbuf
*path
, int flag
)
2479 return remove_dir_recurse(path
, flag
, NULL
);
2482 static GIT_PATH_FUNC(git_path_info_exclude
, "info/exclude")
2484 void setup_standard_excludes(struct dir_struct
*dir
)
2486 dir
->exclude_per_dir
= ".gitignore";
2488 /* core.excludesfile defaulting to $XDG_CONFIG_HOME/git/ignore */
2490 excludes_file
= xdg_config_home("ignore");
2491 if (excludes_file
&& !access_or_warn(excludes_file
, R_OK
, 0))
2492 add_excludes_from_file_1(dir
, excludes_file
,
2493 dir
->untracked
? &dir
->ss_excludes_file
: NULL
);
2495 /* per repository user preference */
2496 if (startup_info
->have_repository
) {
2497 const char *path
= git_path_info_exclude();
2498 if (!access_or_warn(path
, R_OK
, 0))
2499 add_excludes_from_file_1(dir
, path
,
2500 dir
->untracked
? &dir
->ss_info_exclude
: NULL
);
2504 int remove_path(const char *name
)
2508 if (unlink(name
) && !is_missing_file_error(errno
))
2511 slash
= strrchr(name
, '/');
2513 char *dirs
= xstrdup(name
);
2514 slash
= dirs
+ (slash
- name
);
2517 } while (rmdir(dirs
) == 0 && (slash
= strrchr(dirs
, '/')));
2524 * Frees memory within dir which was allocated for exclude lists and
2525 * the exclude_stack. Does not free dir itself.
2527 void clear_directory(struct dir_struct
*dir
)
2530 struct exclude_list_group
*group
;
2531 struct exclude_list
*el
;
2532 struct exclude_stack
*stk
;
2534 for (i
= EXC_CMDL
; i
<= EXC_FILE
; i
++) {
2535 group
= &dir
->exclude_list_group
[i
];
2536 for (j
= 0; j
< group
->nr
; j
++) {
2539 free((char *)el
->src
);
2540 clear_exclude_list(el
);
2545 stk
= dir
->exclude_stack
;
2547 struct exclude_stack
*prev
= stk
->prev
;
2551 strbuf_release(&dir
->basebuf
);
2554 struct ondisk_untracked_cache
{
2555 struct stat_data info_exclude_stat
;
2556 struct stat_data excludes_file_stat
;
2560 #define ouc_offset(x) offsetof(struct ondisk_untracked_cache, x)
2563 int index
; /* number of written untracked_cache_dir */
2564 struct ewah_bitmap
*check_only
; /* from untracked_cache_dir */
2565 struct ewah_bitmap
*valid
; /* from untracked_cache_dir */
2566 struct ewah_bitmap
*sha1_valid
; /* set if exclude_sha1 is not null */
2568 struct strbuf sb_stat
;
2569 struct strbuf sb_sha1
;
2572 static void stat_data_to_disk(struct stat_data
*to
, const struct stat_data
*from
)
2574 to
->sd_ctime
.sec
= htonl(from
->sd_ctime
.sec
);
2575 to
->sd_ctime
.nsec
= htonl(from
->sd_ctime
.nsec
);
2576 to
->sd_mtime
.sec
= htonl(from
->sd_mtime
.sec
);
2577 to
->sd_mtime
.nsec
= htonl(from
->sd_mtime
.nsec
);
2578 to
->sd_dev
= htonl(from
->sd_dev
);
2579 to
->sd_ino
= htonl(from
->sd_ino
);
2580 to
->sd_uid
= htonl(from
->sd_uid
);
2581 to
->sd_gid
= htonl(from
->sd_gid
);
2582 to
->sd_size
= htonl(from
->sd_size
);
2585 static void write_one_dir(struct untracked_cache_dir
*untracked
,
2586 struct write_data
*wd
)
2588 struct stat_data stat_data
;
2589 struct strbuf
*out
= &wd
->out
;
2590 unsigned char intbuf
[16];
2591 unsigned int intlen
, value
;
2592 int i
= wd
->index
++;
2595 * untracked_nr should be reset whenever valid is clear, but
2598 if (!untracked
->valid
) {
2599 untracked
->untracked_nr
= 0;
2600 untracked
->check_only
= 0;
2603 if (untracked
->check_only
)
2604 ewah_set(wd
->check_only
, i
);
2605 if (untracked
->valid
) {
2606 ewah_set(wd
->valid
, i
);
2607 stat_data_to_disk(&stat_data
, &untracked
->stat_data
);
2608 strbuf_add(&wd
->sb_stat
, &stat_data
, sizeof(stat_data
));
2610 if (!is_null_oid(&untracked
->exclude_oid
)) {
2611 ewah_set(wd
->sha1_valid
, i
);
2612 strbuf_add(&wd
->sb_sha1
, untracked
->exclude_oid
.hash
,
2613 the_hash_algo
->rawsz
);
2616 intlen
= encode_varint(untracked
->untracked_nr
, intbuf
);
2617 strbuf_add(out
, intbuf
, intlen
);
2619 /* skip non-recurse directories */
2620 for (i
= 0, value
= 0; i
< untracked
->dirs_nr
; i
++)
2621 if (untracked
->dirs
[i
]->recurse
)
2623 intlen
= encode_varint(value
, intbuf
);
2624 strbuf_add(out
, intbuf
, intlen
);
2626 strbuf_add(out
, untracked
->name
, strlen(untracked
->name
) + 1);
2628 for (i
= 0; i
< untracked
->untracked_nr
; i
++)
2629 strbuf_add(out
, untracked
->untracked
[i
],
2630 strlen(untracked
->untracked
[i
]) + 1);
2632 for (i
= 0; i
< untracked
->dirs_nr
; i
++)
2633 if (untracked
->dirs
[i
]->recurse
)
2634 write_one_dir(untracked
->dirs
[i
], wd
);
2637 void write_untracked_extension(struct strbuf
*out
, struct untracked_cache
*untracked
)
2639 struct ondisk_untracked_cache
*ouc
;
2640 struct write_data wd
;
2641 unsigned char varbuf
[16];
2643 const unsigned hashsz
= the_hash_algo
->rawsz
;
2645 ouc
= xcalloc(1, sizeof(*ouc
));
2646 stat_data_to_disk(&ouc
->info_exclude_stat
, &untracked
->ss_info_exclude
.stat
);
2647 stat_data_to_disk(&ouc
->excludes_file_stat
, &untracked
->ss_excludes_file
.stat
);
2648 ouc
->dir_flags
= htonl(untracked
->dir_flags
);
2650 varint_len
= encode_varint(untracked
->ident
.len
, varbuf
);
2651 strbuf_add(out
, varbuf
, varint_len
);
2652 strbuf_addbuf(out
, &untracked
->ident
);
2654 strbuf_add(out
, ouc
, sizeof(*ouc
));
2655 strbuf_add(out
, untracked
->ss_info_exclude
.oid
.hash
, hashsz
);
2656 strbuf_add(out
, untracked
->ss_excludes_file
.oid
.hash
, hashsz
);
2657 strbuf_add(out
, untracked
->exclude_per_dir
, strlen(untracked
->exclude_per_dir
) + 1);
2660 if (!untracked
->root
) {
2661 varint_len
= encode_varint(0, varbuf
);
2662 strbuf_add(out
, varbuf
, varint_len
);
2667 wd
.check_only
= ewah_new();
2668 wd
.valid
= ewah_new();
2669 wd
.sha1_valid
= ewah_new();
2670 strbuf_init(&wd
.out
, 1024);
2671 strbuf_init(&wd
.sb_stat
, 1024);
2672 strbuf_init(&wd
.sb_sha1
, 1024);
2673 write_one_dir(untracked
->root
, &wd
);
2675 varint_len
= encode_varint(wd
.index
, varbuf
);
2676 strbuf_add(out
, varbuf
, varint_len
);
2677 strbuf_addbuf(out
, &wd
.out
);
2678 ewah_serialize_strbuf(wd
.valid
, out
);
2679 ewah_serialize_strbuf(wd
.check_only
, out
);
2680 ewah_serialize_strbuf(wd
.sha1_valid
, out
);
2681 strbuf_addbuf(out
, &wd
.sb_stat
);
2682 strbuf_addbuf(out
, &wd
.sb_sha1
);
2683 strbuf_addch(out
, '\0'); /* safe guard for string lists */
2685 ewah_free(wd
.valid
);
2686 ewah_free(wd
.check_only
);
2687 ewah_free(wd
.sha1_valid
);
2688 strbuf_release(&wd
.out
);
2689 strbuf_release(&wd
.sb_stat
);
2690 strbuf_release(&wd
.sb_sha1
);
2693 static void free_untracked(struct untracked_cache_dir
*ucd
)
2698 for (i
= 0; i
< ucd
->dirs_nr
; i
++)
2699 free_untracked(ucd
->dirs
[i
]);
2700 for (i
= 0; i
< ucd
->untracked_nr
; i
++)
2701 free(ucd
->untracked
[i
]);
2702 free(ucd
->untracked
);
2707 void free_untracked_cache(struct untracked_cache
*uc
)
2710 free_untracked(uc
->root
);
2716 struct untracked_cache_dir
**ucd
;
2717 struct ewah_bitmap
*check_only
;
2718 struct ewah_bitmap
*valid
;
2719 struct ewah_bitmap
*sha1_valid
;
2720 const unsigned char *data
;
2721 const unsigned char *end
;
2724 static void stat_data_from_disk(struct stat_data
*to
, const unsigned char *data
)
2726 memcpy(to
, data
, sizeof(*to
));
2727 to
->sd_ctime
.sec
= ntohl(to
->sd_ctime
.sec
);
2728 to
->sd_ctime
.nsec
= ntohl(to
->sd_ctime
.nsec
);
2729 to
->sd_mtime
.sec
= ntohl(to
->sd_mtime
.sec
);
2730 to
->sd_mtime
.nsec
= ntohl(to
->sd_mtime
.nsec
);
2731 to
->sd_dev
= ntohl(to
->sd_dev
);
2732 to
->sd_ino
= ntohl(to
->sd_ino
);
2733 to
->sd_uid
= ntohl(to
->sd_uid
);
2734 to
->sd_gid
= ntohl(to
->sd_gid
);
2735 to
->sd_size
= ntohl(to
->sd_size
);
2738 static int read_one_dir(struct untracked_cache_dir
**untracked_
,
2739 struct read_data
*rd
)
2741 struct untracked_cache_dir ud
, *untracked
;
2742 const unsigned char *data
= rd
->data
, *end
= rd
->end
;
2743 const unsigned char *eos
;
2747 memset(&ud
, 0, sizeof(ud
));
2749 value
= decode_varint(&data
);
2753 ud
.untracked_alloc
= value
;
2754 ud
.untracked_nr
= value
;
2755 if (ud
.untracked_nr
)
2756 ALLOC_ARRAY(ud
.untracked
, ud
.untracked_nr
);
2758 ud
.dirs_alloc
= ud
.dirs_nr
= decode_varint(&data
);
2761 ALLOC_ARRAY(ud
.dirs
, ud
.dirs_nr
);
2763 eos
= memchr(data
, '\0', end
- data
);
2764 if (!eos
|| eos
== end
)
2767 *untracked_
= untracked
= xmalloc(st_add3(sizeof(*untracked
), eos
- data
, 1));
2768 memcpy(untracked
, &ud
, sizeof(ud
));
2769 memcpy(untracked
->name
, data
, eos
- data
+ 1);
2772 for (i
= 0; i
< untracked
->untracked_nr
; i
++) {
2773 eos
= memchr(data
, '\0', end
- data
);
2774 if (!eos
|| eos
== end
)
2776 untracked
->untracked
[i
] = xmemdupz(data
, eos
- data
);
2780 rd
->ucd
[rd
->index
++] = untracked
;
2783 for (i
= 0; i
< untracked
->dirs_nr
; i
++) {
2784 if (read_one_dir(untracked
->dirs
+ i
, rd
) < 0)
2790 static void set_check_only(size_t pos
, void *cb
)
2792 struct read_data
*rd
= cb
;
2793 struct untracked_cache_dir
*ud
= rd
->ucd
[pos
];
2797 static void read_stat(size_t pos
, void *cb
)
2799 struct read_data
*rd
= cb
;
2800 struct untracked_cache_dir
*ud
= rd
->ucd
[pos
];
2801 if (rd
->data
+ sizeof(struct stat_data
) > rd
->end
) {
2802 rd
->data
= rd
->end
+ 1;
2805 stat_data_from_disk(&ud
->stat_data
, rd
->data
);
2806 rd
->data
+= sizeof(struct stat_data
);
2810 static void read_oid(size_t pos
, void *cb
)
2812 struct read_data
*rd
= cb
;
2813 struct untracked_cache_dir
*ud
= rd
->ucd
[pos
];
2814 if (rd
->data
+ the_hash_algo
->rawsz
> rd
->end
) {
2815 rd
->data
= rd
->end
+ 1;
2818 hashcpy(ud
->exclude_oid
.hash
, rd
->data
);
2819 rd
->data
+= the_hash_algo
->rawsz
;
2822 static void load_oid_stat(struct oid_stat
*oid_stat
, const unsigned char *data
,
2823 const unsigned char *sha1
)
2825 stat_data_from_disk(&oid_stat
->stat
, data
);
2826 hashcpy(oid_stat
->oid
.hash
, sha1
);
2827 oid_stat
->valid
= 1;
2830 struct untracked_cache
*read_untracked_extension(const void *data
, unsigned long sz
)
2832 struct untracked_cache
*uc
;
2833 struct read_data rd
;
2834 const unsigned char *next
= data
, *end
= (const unsigned char *)data
+ sz
;
2838 const char *exclude_per_dir
;
2839 const unsigned hashsz
= the_hash_algo
->rawsz
;
2840 const unsigned offset
= sizeof(struct ondisk_untracked_cache
);
2841 const unsigned exclude_per_dir_offset
= offset
+ 2 * hashsz
;
2843 if (sz
<= 1 || end
[-1] != '\0')
2847 ident_len
= decode_varint(&next
);
2848 if (next
+ ident_len
> end
)
2850 ident
= (const char *)next
;
2853 if (next
+ exclude_per_dir_offset
+ 1 > end
)
2856 uc
= xcalloc(1, sizeof(*uc
));
2857 strbuf_init(&uc
->ident
, ident_len
);
2858 strbuf_add(&uc
->ident
, ident
, ident_len
);
2859 load_oid_stat(&uc
->ss_info_exclude
,
2860 next
+ ouc_offset(info_exclude_stat
),
2862 load_oid_stat(&uc
->ss_excludes_file
,
2863 next
+ ouc_offset(excludes_file_stat
),
2864 next
+ offset
+ hashsz
);
2865 uc
->dir_flags
= get_be32(next
+ ouc_offset(dir_flags
));
2866 exclude_per_dir
= (const char *)next
+ exclude_per_dir_offset
;
2867 uc
->exclude_per_dir
= xstrdup(exclude_per_dir
);
2868 /* NUL after exclude_per_dir is covered by sizeof(*ouc) */
2869 next
+= exclude_per_dir_offset
+ strlen(exclude_per_dir
) + 1;
2873 len
= decode_varint(&next
);
2874 if (next
> end
|| len
== 0)
2877 rd
.valid
= ewah_new();
2878 rd
.check_only
= ewah_new();
2879 rd
.sha1_valid
= ewah_new();
2883 ALLOC_ARRAY(rd
.ucd
, len
);
2885 if (read_one_dir(&uc
->root
, &rd
) || rd
.index
!= len
)
2889 len
= ewah_read_mmap(rd
.valid
, next
, end
- next
);
2894 len
= ewah_read_mmap(rd
.check_only
, next
, end
- next
);
2899 len
= ewah_read_mmap(rd
.sha1_valid
, next
, end
- next
);
2903 ewah_each_bit(rd
.check_only
, set_check_only
, &rd
);
2904 rd
.data
= next
+ len
;
2905 ewah_each_bit(rd
.valid
, read_stat
, &rd
);
2906 ewah_each_bit(rd
.sha1_valid
, read_oid
, &rd
);
2911 ewah_free(rd
.valid
);
2912 ewah_free(rd
.check_only
);
2913 ewah_free(rd
.sha1_valid
);
2916 free_untracked_cache(uc
);
2922 static void invalidate_one_directory(struct untracked_cache
*uc
,
2923 struct untracked_cache_dir
*ucd
)
2925 uc
->dir_invalidated
++;
2927 ucd
->untracked_nr
= 0;
2931 * Normally when an entry is added or removed from a directory,
2932 * invalidating that directory is enough. No need to touch its
2933 * ancestors. When a directory is shown as "foo/bar/" in git-status
2934 * however, deleting or adding an entry may have cascading effect.
2936 * Say the "foo/bar/file" has become untracked, we need to tell the
2937 * untracked_cache_dir of "foo" that "bar/" is not an untracked
2938 * directory any more (because "bar" is managed by foo as an untracked
2941 * Similarly, if "foo/bar/file" moves from untracked to tracked and it
2942 * was the last untracked entry in the entire "foo", we should show
2943 * "foo/" instead. Which means we have to invalidate past "bar" up to
2946 * This function traverses all directories from root to leaf. If there
2947 * is a chance of one of the above cases happening, we invalidate back
2948 * to root. Otherwise we just invalidate the leaf. There may be a more
2949 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to
2950 * detect these cases and avoid unnecessary invalidation, for example,
2951 * checking for the untracked entry named "bar/" in "foo", but for now
2952 * stick to something safe and simple.
2954 static int invalidate_one_component(struct untracked_cache
*uc
,
2955 struct untracked_cache_dir
*dir
,
2956 const char *path
, int len
)
2958 const char *rest
= strchr(path
, '/');
2961 int component_len
= rest
- path
;
2962 struct untracked_cache_dir
*d
=
2963 lookup_untracked(uc
, dir
, path
, component_len
);
2965 invalidate_one_component(uc
, d
, rest
+ 1,
2966 len
- (component_len
+ 1));
2968 invalidate_one_directory(uc
, dir
);
2972 invalidate_one_directory(uc
, dir
);
2973 return uc
->dir_flags
& DIR_SHOW_OTHER_DIRECTORIES
;
2976 void untracked_cache_invalidate_path(struct index_state
*istate
,
2977 const char *path
, int safe_path
)
2979 if (!istate
->untracked
|| !istate
->untracked
->root
)
2981 if (!safe_path
&& !verify_path(path
, 0))
2983 invalidate_one_component(istate
->untracked
, istate
->untracked
->root
,
2984 path
, strlen(path
));
2987 void untracked_cache_remove_from_index(struct index_state
*istate
,
2990 untracked_cache_invalidate_path(istate
, path
, 1);
2993 void untracked_cache_add_to_index(struct index_state
*istate
,
2996 untracked_cache_invalidate_path(istate
, path
, 1);
2999 static void connect_wt_gitdir_in_nested(const char *sub_worktree
,
3000 const char *sub_gitdir
)
3003 struct repository subrepo
;
3004 struct strbuf sub_wt
= STRBUF_INIT
;
3005 struct strbuf sub_gd
= STRBUF_INIT
;
3007 const struct submodule
*sub
;
3009 /* If the submodule has no working tree, we can ignore it. */
3010 if (repo_init(&subrepo
, sub_gitdir
, sub_worktree
))
3013 if (repo_read_index(&subrepo
) < 0)
3014 die(_("index file corrupt in repo %s"), subrepo
.gitdir
);
3016 for (i
= 0; i
< subrepo
.index
->cache_nr
; i
++) {
3017 const struct cache_entry
*ce
= subrepo
.index
->cache
[i
];
3019 if (!S_ISGITLINK(ce
->ce_mode
))
3022 while (i
+ 1 < subrepo
.index
->cache_nr
&&
3023 !strcmp(ce
->name
, subrepo
.index
->cache
[i
+ 1]->name
))
3025 * Skip entries with the same name in different stages
3026 * to make sure an entry is returned only once.
3030 sub
= submodule_from_path(&subrepo
, &null_oid
, ce
->name
);
3031 if (!sub
|| !is_submodule_active(&subrepo
, ce
->name
))
3032 /* .gitmodules broken or inactive sub */
3035 strbuf_reset(&sub_wt
);
3036 strbuf_reset(&sub_gd
);
3037 strbuf_addf(&sub_wt
, "%s/%s", sub_worktree
, sub
->path
);
3038 strbuf_addf(&sub_gd
, "%s/modules/%s", sub_gitdir
, sub
->name
);
3040 connect_work_tree_and_git_dir(sub_wt
.buf
, sub_gd
.buf
, 1);
3042 strbuf_release(&sub_wt
);
3043 strbuf_release(&sub_gd
);
3044 repo_clear(&subrepo
);
3047 void connect_work_tree_and_git_dir(const char *work_tree_
,
3048 const char *git_dir_
,
3049 int recurse_into_nested
)
3051 struct strbuf gitfile_sb
= STRBUF_INIT
;
3052 struct strbuf cfg_sb
= STRBUF_INIT
;
3053 struct strbuf rel_path
= STRBUF_INIT
;
3054 char *git_dir
, *work_tree
;
3056 /* Prepare .git file */
3057 strbuf_addf(&gitfile_sb
, "%s/.git", work_tree_
);
3058 if (safe_create_leading_directories_const(gitfile_sb
.buf
))
3059 die(_("could not create directories for %s"), gitfile_sb
.buf
);
3061 /* Prepare config file */
3062 strbuf_addf(&cfg_sb
, "%s/config", git_dir_
);
3063 if (safe_create_leading_directories_const(cfg_sb
.buf
))
3064 die(_("could not create directories for %s"), cfg_sb
.buf
);
3066 git_dir
= real_pathdup(git_dir_
, 1);
3067 work_tree
= real_pathdup(work_tree_
, 1);
3069 /* Write .git file */
3070 write_file(gitfile_sb
.buf
, "gitdir: %s",
3071 relative_path(git_dir
, work_tree
, &rel_path
));
3072 /* Update core.worktree setting */
3073 git_config_set_in_file(cfg_sb
.buf
, "core.worktree",
3074 relative_path(work_tree
, git_dir
, &rel_path
));
3076 strbuf_release(&gitfile_sb
);
3077 strbuf_release(&cfg_sb
);
3078 strbuf_release(&rel_path
);
3080 if (recurse_into_nested
)
3081 connect_wt_gitdir_in_nested(work_tree
, git_dir
);
3088 * Migrate the git directory of the given path from old_git_dir to new_git_dir.
3090 void relocate_gitdir(const char *path
, const char *old_git_dir
, const char *new_git_dir
)
3092 if (rename(old_git_dir
, new_git_dir
) < 0)
3093 die_errno(_("could not migrate git directory from '%s' to '%s'"),
3094 old_git_dir
, new_git_dir
);
3096 connect_work_tree_and_git_dir(path
, new_git_dir
, 0);