Merge branch 'sg/cocci-move-array'
[git/git.git] / cache-tree.c
1 #include "cache.h"
2 #include "lockfile.h"
3 #include "tree.h"
4 #include "tree-walk.h"
5 #include "cache-tree.h"
6
7 #ifndef DEBUG
8 #define DEBUG 0
9 #endif
10
11 struct cache_tree *cache_tree(void)
12 {
13 struct cache_tree *it = xcalloc(1, sizeof(struct cache_tree));
14 it->entry_count = -1;
15 return it;
16 }
17
18 void cache_tree_free(struct cache_tree **it_p)
19 {
20 int i;
21 struct cache_tree *it = *it_p;
22
23 if (!it)
24 return;
25 for (i = 0; i < it->subtree_nr; i++)
26 if (it->down[i]) {
27 cache_tree_free(&it->down[i]->cache_tree);
28 free(it->down[i]);
29 }
30 free(it->down);
31 free(it);
32 *it_p = NULL;
33 }
34
35 static int subtree_name_cmp(const char *one, int onelen,
36 const char *two, int twolen)
37 {
38 if (onelen < twolen)
39 return -1;
40 if (twolen < onelen)
41 return 1;
42 return memcmp(one, two, onelen);
43 }
44
45 static int subtree_pos(struct cache_tree *it, const char *path, int pathlen)
46 {
47 struct cache_tree_sub **down = it->down;
48 int lo, hi;
49 lo = 0;
50 hi = it->subtree_nr;
51 while (lo < hi) {
52 int mi = lo + (hi - lo) / 2;
53 struct cache_tree_sub *mdl = down[mi];
54 int cmp = subtree_name_cmp(path, pathlen,
55 mdl->name, mdl->namelen);
56 if (!cmp)
57 return mi;
58 if (cmp < 0)
59 hi = mi;
60 else
61 lo = mi + 1;
62 }
63 return -lo-1;
64 }
65
66 static struct cache_tree_sub *find_subtree(struct cache_tree *it,
67 const char *path,
68 int pathlen,
69 int create)
70 {
71 struct cache_tree_sub *down;
72 int pos = subtree_pos(it, path, pathlen);
73 if (0 <= pos)
74 return it->down[pos];
75 if (!create)
76 return NULL;
77
78 pos = -pos-1;
79 ALLOC_GROW(it->down, it->subtree_nr + 1, it->subtree_alloc);
80 it->subtree_nr++;
81
82 FLEX_ALLOC_MEM(down, name, path, pathlen);
83 down->cache_tree = NULL;
84 down->namelen = pathlen;
85
86 if (pos < it->subtree_nr)
87 MOVE_ARRAY(it->down + pos + 1, it->down + pos,
88 it->subtree_nr - pos - 1);
89 it->down[pos] = down;
90 return down;
91 }
92
93 struct cache_tree_sub *cache_tree_sub(struct cache_tree *it, const char *path)
94 {
95 int pathlen = strlen(path);
96 return find_subtree(it, path, pathlen, 1);
97 }
98
99 static int do_invalidate_path(struct cache_tree *it, const char *path)
100 {
101 /* a/b/c
102 * ==> invalidate self
103 * ==> find "a", have it invalidate "b/c"
104 * a
105 * ==> invalidate self
106 * ==> if "a" exists as a subtree, remove it.
107 */
108 const char *slash;
109 int namelen;
110 struct cache_tree_sub *down;
111
112 #if DEBUG
113 fprintf(stderr, "cache-tree invalidate <%s>\n", path);
114 #endif
115
116 if (!it)
117 return 0;
118 slash = strchrnul(path, '/');
119 namelen = slash - path;
120 it->entry_count = -1;
121 if (!*slash) {
122 int pos;
123 pos = subtree_pos(it, path, namelen);
124 if (0 <= pos) {
125 cache_tree_free(&it->down[pos]->cache_tree);
126 free(it->down[pos]);
127 /* 0 1 2 3 4 5
128 * ^ ^subtree_nr = 6
129 * pos
130 * move 4 and 5 up one place (2 entries)
131 * 2 = 6 - 3 - 1 = subtree_nr - pos - 1
132 */
133 MOVE_ARRAY(it->down + pos, it->down + pos + 1,
134 it->subtree_nr - pos - 1);
135 it->subtree_nr--;
136 }
137 return 1;
138 }
139 down = find_subtree(it, path, namelen, 0);
140 if (down)
141 do_invalidate_path(down->cache_tree, slash + 1);
142 return 1;
143 }
144
145 void cache_tree_invalidate_path(struct index_state *istate, const char *path)
146 {
147 if (do_invalidate_path(istate->cache_tree, path))
148 istate->cache_changed |= CACHE_TREE_CHANGED;
149 }
150
151 static int verify_cache(struct cache_entry **cache,
152 int entries, int flags)
153 {
154 int i, funny;
155 int silent = flags & WRITE_TREE_SILENT;
156
157 /* Verify that the tree is merged */
158 funny = 0;
159 for (i = 0; i < entries; i++) {
160 const struct cache_entry *ce = cache[i];
161 if (ce_stage(ce)) {
162 if (silent)
163 return -1;
164 if (10 < ++funny) {
165 fprintf(stderr, "...\n");
166 break;
167 }
168 fprintf(stderr, "%s: unmerged (%s)\n",
169 ce->name, oid_to_hex(&ce->oid));
170 }
171 }
172 if (funny)
173 return -1;
174
175 /* Also verify that the cache does not have path and path/file
176 * at the same time. At this point we know the cache has only
177 * stage 0 entries.
178 */
179 funny = 0;
180 for (i = 0; i < entries - 1; i++) {
181 /* path/file always comes after path because of the way
182 * the cache is sorted. Also path can appear only once,
183 * which means conflicting one would immediately follow.
184 */
185 const char *this_name = cache[i]->name;
186 const char *next_name = cache[i+1]->name;
187 int this_len = strlen(this_name);
188 if (this_len < strlen(next_name) &&
189 strncmp(this_name, next_name, this_len) == 0 &&
190 next_name[this_len] == '/') {
191 if (10 < ++funny) {
192 fprintf(stderr, "...\n");
193 break;
194 }
195 fprintf(stderr, "You have both %s and %s\n",
196 this_name, next_name);
197 }
198 }
199 if (funny)
200 return -1;
201 return 0;
202 }
203
204 static void discard_unused_subtrees(struct cache_tree *it)
205 {
206 struct cache_tree_sub **down = it->down;
207 int nr = it->subtree_nr;
208 int dst, src;
209 for (dst = src = 0; src < nr; src++) {
210 struct cache_tree_sub *s = down[src];
211 if (s->used)
212 down[dst++] = s;
213 else {
214 cache_tree_free(&s->cache_tree);
215 free(s);
216 it->subtree_nr--;
217 }
218 }
219 }
220
221 int cache_tree_fully_valid(struct cache_tree *it)
222 {
223 int i;
224 if (!it)
225 return 0;
226 if (it->entry_count < 0 || !has_sha1_file(it->oid.hash))
227 return 0;
228 for (i = 0; i < it->subtree_nr; i++) {
229 if (!cache_tree_fully_valid(it->down[i]->cache_tree))
230 return 0;
231 }
232 return 1;
233 }
234
235 static int update_one(struct cache_tree *it,
236 struct cache_entry **cache,
237 int entries,
238 const char *base,
239 int baselen,
240 int *skip_count,
241 int flags)
242 {
243 struct strbuf buffer;
244 int missing_ok = flags & WRITE_TREE_MISSING_OK;
245 int dryrun = flags & WRITE_TREE_DRY_RUN;
246 int repair = flags & WRITE_TREE_REPAIR;
247 int to_invalidate = 0;
248 int i;
249
250 assert(!(dryrun && repair));
251
252 *skip_count = 0;
253
254 if (0 <= it->entry_count && has_sha1_file(it->oid.hash))
255 return it->entry_count;
256
257 /*
258 * We first scan for subtrees and update them; we start by
259 * marking existing subtrees -- the ones that are unmarked
260 * should not be in the result.
261 */
262 for (i = 0; i < it->subtree_nr; i++)
263 it->down[i]->used = 0;
264
265 /*
266 * Find the subtrees and update them.
267 */
268 i = 0;
269 while (i < entries) {
270 const struct cache_entry *ce = cache[i];
271 struct cache_tree_sub *sub;
272 const char *path, *slash;
273 int pathlen, sublen, subcnt, subskip;
274
275 path = ce->name;
276 pathlen = ce_namelen(ce);
277 if (pathlen <= baselen || memcmp(base, path, baselen))
278 break; /* at the end of this level */
279
280 slash = strchr(path + baselen, '/');
281 if (!slash) {
282 i++;
283 continue;
284 }
285 /*
286 * a/bbb/c (base = a/, slash = /c)
287 * ==>
288 * path+baselen = bbb/c, sublen = 3
289 */
290 sublen = slash - (path + baselen);
291 sub = find_subtree(it, path + baselen, sublen, 1);
292 if (!sub->cache_tree)
293 sub->cache_tree = cache_tree();
294 subcnt = update_one(sub->cache_tree,
295 cache + i, entries - i,
296 path,
297 baselen + sublen + 1,
298 &subskip,
299 flags);
300 if (subcnt < 0)
301 return subcnt;
302 if (!subcnt)
303 die("index cache-tree records empty sub-tree");
304 i += subcnt;
305 sub->count = subcnt; /* to be used in the next loop */
306 *skip_count += subskip;
307 sub->used = 1;
308 }
309
310 discard_unused_subtrees(it);
311
312 /*
313 * Then write out the tree object for this level.
314 */
315 strbuf_init(&buffer, 8192);
316
317 i = 0;
318 while (i < entries) {
319 const struct cache_entry *ce = cache[i];
320 struct cache_tree_sub *sub = NULL;
321 const char *path, *slash;
322 int pathlen, entlen;
323 const unsigned char *sha1;
324 unsigned mode;
325 int expected_missing = 0;
326 int contains_ita = 0;
327
328 path = ce->name;
329 pathlen = ce_namelen(ce);
330 if (pathlen <= baselen || memcmp(base, path, baselen))
331 break; /* at the end of this level */
332
333 slash = strchr(path + baselen, '/');
334 if (slash) {
335 entlen = slash - (path + baselen);
336 sub = find_subtree(it, path + baselen, entlen, 0);
337 if (!sub)
338 die("cache-tree.c: '%.*s' in '%s' not found",
339 entlen, path + baselen, path);
340 i += sub->count;
341 sha1 = sub->cache_tree->oid.hash;
342 mode = S_IFDIR;
343 contains_ita = sub->cache_tree->entry_count < 0;
344 if (contains_ita) {
345 to_invalidate = 1;
346 expected_missing = 1;
347 }
348 }
349 else {
350 sha1 = ce->oid.hash;
351 mode = ce->ce_mode;
352 entlen = pathlen - baselen;
353 i++;
354 }
355
356 if (is_null_sha1(sha1) ||
357 (mode != S_IFGITLINK && !missing_ok && !has_sha1_file(sha1))) {
358 strbuf_release(&buffer);
359 if (expected_missing)
360 return -1;
361 return error("invalid object %06o %s for '%.*s'",
362 mode, sha1_to_hex(sha1), entlen+baselen, path);
363 }
364
365 /*
366 * CE_REMOVE entries are removed before the index is
367 * written to disk. Skip them to remain consistent
368 * with the future on-disk index.
369 */
370 if (ce->ce_flags & CE_REMOVE) {
371 *skip_count = *skip_count + 1;
372 continue;
373 }
374
375 /*
376 * CE_INTENT_TO_ADD entries exist on on-disk index but
377 * they are not part of generated trees. Invalidate up
378 * to root to force cache-tree users to read elsewhere.
379 */
380 if (!sub && ce_intent_to_add(ce)) {
381 to_invalidate = 1;
382 continue;
383 }
384
385 /*
386 * "sub" can be an empty tree if all subentries are i-t-a.
387 */
388 if (contains_ita && !hashcmp(sha1, EMPTY_TREE_SHA1_BIN))
389 continue;
390
391 strbuf_grow(&buffer, entlen + 100);
392 strbuf_addf(&buffer, "%o %.*s%c", mode, entlen, path + baselen, '\0');
393 strbuf_add(&buffer, sha1, 20);
394
395 #if DEBUG
396 fprintf(stderr, "cache-tree update-one %o %.*s\n",
397 mode, entlen, path + baselen);
398 #endif
399 }
400
401 if (repair) {
402 unsigned char sha1[20];
403 hash_sha1_file(buffer.buf, buffer.len, tree_type, sha1);
404 if (has_sha1_file(sha1))
405 hashcpy(it->oid.hash, sha1);
406 else
407 to_invalidate = 1;
408 } else if (dryrun)
409 hash_sha1_file(buffer.buf, buffer.len, tree_type,
410 it->oid.hash);
411 else if (write_sha1_file(buffer.buf, buffer.len, tree_type, it->oid.hash)) {
412 strbuf_release(&buffer);
413 return -1;
414 }
415
416 strbuf_release(&buffer);
417 it->entry_count = to_invalidate ? -1 : i - *skip_count;
418 #if DEBUG
419 fprintf(stderr, "cache-tree update-one (%d ent, %d subtree) %s\n",
420 it->entry_count, it->subtree_nr,
421 oid_to_hex(&it->oid));
422 #endif
423 return i;
424 }
425
426 int cache_tree_update(struct index_state *istate, int flags)
427 {
428 struct cache_tree *it = istate->cache_tree;
429 struct cache_entry **cache = istate->cache;
430 int entries = istate->cache_nr;
431 int skip, i = verify_cache(cache, entries, flags);
432
433 if (i)
434 return i;
435 i = update_one(it, cache, entries, "", 0, &skip, flags);
436 if (i < 0)
437 return i;
438 istate->cache_changed |= CACHE_TREE_CHANGED;
439 return 0;
440 }
441
442 static void write_one(struct strbuf *buffer, struct cache_tree *it,
443 const char *path, int pathlen)
444 {
445 int i;
446
447 /* One "cache-tree" entry consists of the following:
448 * path (NUL terminated)
449 * entry_count, subtree_nr ("%d %d\n")
450 * tree-sha1 (missing if invalid)
451 * subtree_nr "cache-tree" entries for subtrees.
452 */
453 strbuf_grow(buffer, pathlen + 100);
454 strbuf_add(buffer, path, pathlen);
455 strbuf_addf(buffer, "%c%d %d\n", 0, it->entry_count, it->subtree_nr);
456
457 #if DEBUG
458 if (0 <= it->entry_count)
459 fprintf(stderr, "cache-tree <%.*s> (%d ent, %d subtree) %s\n",
460 pathlen, path, it->entry_count, it->subtree_nr,
461 oid_to_hex(&it->oid));
462 else
463 fprintf(stderr, "cache-tree <%.*s> (%d subtree) invalid\n",
464 pathlen, path, it->subtree_nr);
465 #endif
466
467 if (0 <= it->entry_count) {
468 strbuf_add(buffer, it->oid.hash, 20);
469 }
470 for (i = 0; i < it->subtree_nr; i++) {
471 struct cache_tree_sub *down = it->down[i];
472 if (i) {
473 struct cache_tree_sub *prev = it->down[i-1];
474 if (subtree_name_cmp(down->name, down->namelen,
475 prev->name, prev->namelen) <= 0)
476 die("fatal - unsorted cache subtree");
477 }
478 write_one(buffer, down->cache_tree, down->name, down->namelen);
479 }
480 }
481
482 void cache_tree_write(struct strbuf *sb, struct cache_tree *root)
483 {
484 write_one(sb, root, "", 0);
485 }
486
487 static struct cache_tree *read_one(const char **buffer, unsigned long *size_p)
488 {
489 const char *buf = *buffer;
490 unsigned long size = *size_p;
491 const char *cp;
492 char *ep;
493 struct cache_tree *it;
494 int i, subtree_nr;
495
496 it = NULL;
497 /* skip name, but make sure name exists */
498 while (size && *buf) {
499 size--;
500 buf++;
501 }
502 if (!size)
503 goto free_return;
504 buf++; size--;
505 it = cache_tree();
506
507 cp = buf;
508 it->entry_count = strtol(cp, &ep, 10);
509 if (cp == ep)
510 goto free_return;
511 cp = ep;
512 subtree_nr = strtol(cp, &ep, 10);
513 if (cp == ep)
514 goto free_return;
515 while (size && *buf && *buf != '\n') {
516 size--;
517 buf++;
518 }
519 if (!size)
520 goto free_return;
521 buf++; size--;
522 if (0 <= it->entry_count) {
523 if (size < 20)
524 goto free_return;
525 hashcpy(it->oid.hash, (const unsigned char*)buf);
526 buf += 20;
527 size -= 20;
528 }
529
530 #if DEBUG
531 if (0 <= it->entry_count)
532 fprintf(stderr, "cache-tree <%s> (%d ent, %d subtree) %s\n",
533 *buffer, it->entry_count, subtree_nr,
534 oid_to_hex(&it->oid));
535 else
536 fprintf(stderr, "cache-tree <%s> (%d subtrees) invalid\n",
537 *buffer, subtree_nr);
538 #endif
539
540 /*
541 * Just a heuristic -- we do not add directories that often but
542 * we do not want to have to extend it immediately when we do,
543 * hence +2.
544 */
545 it->subtree_alloc = subtree_nr + 2;
546 it->down = xcalloc(it->subtree_alloc, sizeof(struct cache_tree_sub *));
547 for (i = 0; i < subtree_nr; i++) {
548 /* read each subtree */
549 struct cache_tree *sub;
550 struct cache_tree_sub *subtree;
551 const char *name = buf;
552
553 sub = read_one(&buf, &size);
554 if (!sub)
555 goto free_return;
556 subtree = cache_tree_sub(it, name);
557 subtree->cache_tree = sub;
558 }
559 if (subtree_nr != it->subtree_nr)
560 die("cache-tree: internal error");
561 *buffer = buf;
562 *size_p = size;
563 return it;
564
565 free_return:
566 cache_tree_free(&it);
567 return NULL;
568 }
569
570 struct cache_tree *cache_tree_read(const char *buffer, unsigned long size)
571 {
572 if (buffer[0])
573 return NULL; /* not the whole tree */
574 return read_one(&buffer, &size);
575 }
576
577 static struct cache_tree *cache_tree_find(struct cache_tree *it, const char *path)
578 {
579 if (!it)
580 return NULL;
581 while (*path) {
582 const char *slash;
583 struct cache_tree_sub *sub;
584
585 slash = strchrnul(path, '/');
586 /*
587 * Between path and slash is the name of the subtree
588 * to look for.
589 */
590 sub = find_subtree(it, path, slash - path, 0);
591 if (!sub)
592 return NULL;
593 it = sub->cache_tree;
594
595 path = slash;
596 while (*path == '/')
597 path++;
598 }
599 return it;
600 }
601
602 int write_index_as_tree(unsigned char *sha1, struct index_state *index_state, const char *index_path, int flags, const char *prefix)
603 {
604 int entries, was_valid;
605 struct lock_file lock_file = LOCK_INIT;
606 int ret = 0;
607
608 hold_lock_file_for_update(&lock_file, index_path, LOCK_DIE_ON_ERROR);
609
610 entries = read_index_from(index_state, index_path, get_git_dir());
611 if (entries < 0) {
612 ret = WRITE_TREE_UNREADABLE_INDEX;
613 goto out;
614 }
615 if (flags & WRITE_TREE_IGNORE_CACHE_TREE)
616 cache_tree_free(&index_state->cache_tree);
617
618 if (!index_state->cache_tree)
619 index_state->cache_tree = cache_tree();
620
621 was_valid = cache_tree_fully_valid(index_state->cache_tree);
622 if (!was_valid) {
623 if (cache_tree_update(index_state, flags) < 0) {
624 ret = WRITE_TREE_UNMERGED_INDEX;
625 goto out;
626 }
627 write_locked_index(index_state, &lock_file, COMMIT_LOCK);
628 /* Not being able to write is fine -- we are only interested
629 * in updating the cache-tree part, and if the next caller
630 * ends up using the old index with unupdated cache-tree part
631 * it misses the work we did here, but that is just a
632 * performance penalty and not a big deal.
633 */
634 }
635
636 if (prefix) {
637 struct cache_tree *subtree;
638 subtree = cache_tree_find(index_state->cache_tree, prefix);
639 if (!subtree) {
640 ret = WRITE_TREE_PREFIX_ERROR;
641 goto out;
642 }
643 hashcpy(sha1, subtree->oid.hash);
644 }
645 else
646 hashcpy(sha1, index_state->cache_tree->oid.hash);
647
648 out:
649 rollback_lock_file(&lock_file);
650 return ret;
651 }
652
653 int write_cache_as_tree(unsigned char *sha1, int flags, const char *prefix)
654 {
655 return write_index_as_tree(sha1, &the_index, get_index_file(), flags, prefix);
656 }
657
658 static void prime_cache_tree_rec(struct cache_tree *it, struct tree *tree)
659 {
660 struct tree_desc desc;
661 struct name_entry entry;
662 int cnt;
663
664 oidcpy(&it->oid, &tree->object.oid);
665 init_tree_desc(&desc, tree->buffer, tree->size);
666 cnt = 0;
667 while (tree_entry(&desc, &entry)) {
668 if (!S_ISDIR(entry.mode))
669 cnt++;
670 else {
671 struct cache_tree_sub *sub;
672 struct tree *subtree = lookup_tree(entry.oid);
673 if (!subtree->object.parsed)
674 parse_tree(subtree);
675 sub = cache_tree_sub(it, entry.path);
676 sub->cache_tree = cache_tree();
677 prime_cache_tree_rec(sub->cache_tree, subtree);
678 cnt += sub->cache_tree->entry_count;
679 }
680 }
681 it->entry_count = cnt;
682 }
683
684 void prime_cache_tree(struct index_state *istate, struct tree *tree)
685 {
686 cache_tree_free(&istate->cache_tree);
687 istate->cache_tree = cache_tree();
688 prime_cache_tree_rec(istate->cache_tree, tree);
689 istate->cache_changed |= CACHE_TREE_CHANGED;
690 }
691
692 /*
693 * find the cache_tree that corresponds to the current level without
694 * exploding the full path into textual form. The root of the
695 * cache tree is given as "root", and our current level is "info".
696 * (1) When at root level, info->prev is NULL, so it is "root" itself.
697 * (2) Otherwise, find the cache_tree that corresponds to one level
698 * above us, and find ourselves in there.
699 */
700 static struct cache_tree *find_cache_tree_from_traversal(struct cache_tree *root,
701 struct traverse_info *info)
702 {
703 struct cache_tree *our_parent;
704
705 if (!info->prev)
706 return root;
707 our_parent = find_cache_tree_from_traversal(root, info->prev);
708 return cache_tree_find(our_parent, info->name.path);
709 }
710
711 int cache_tree_matches_traversal(struct cache_tree *root,
712 struct name_entry *ent,
713 struct traverse_info *info)
714 {
715 struct cache_tree *it;
716
717 it = find_cache_tree_from_traversal(root, info);
718 it = cache_tree_find(it, ent->path);
719 if (it && it->entry_count > 0 && !oidcmp(ent->oid, &it->oid))
720 return it->entry_count;
721 return 0;
722 }
723
724 int update_main_cache_tree(int flags)
725 {
726 if (!the_index.cache_tree)
727 the_index.cache_tree = cache_tree();
728 return cache_tree_update(&the_index, flags);
729 }