@matheusbsbs / matheus-bagliano
Code Commits Pulls CI/CD 81,295
bisect
bisect jch maint master next seen test todo
c 898 lines 24.9 KB
Raw
1 #define USE_THE_REPOSITORY_VARIABLE
2
3 #include "git-compat-util.h"
4 #include "hex.h"
5 #include "repository.h"
6 #include "tempfile.h"
7 #include "lockfile.h"
8 #include "odb.h"
9 #include "commit.h"
10 #include "tag.h"
11 #include "pkt-line.h"
12 #include "refs.h"
13 #include "oid-array.h"
14 #include "path.h"
15 #include "diff.h"
16 #include "revision.h"
17 #include "commit-slab.h"
18 #include "list-objects.h"
19 #include "commit-reach.h"
20 #include "shallow.h"
21 #include "statinfo.h"
22 #include "trace.h"
23
24 void set_alternate_shallow_file(struct repository *r, const char *path, int override)
25 {
26 if (r->parsed_objects->is_shallow != -1)
27 BUG("is_repository_shallow must not be called before set_alternate_shallow_file");
28 if (r->parsed_objects->alternate_shallow_file && !override)
29 return;
30 free(r->parsed_objects->alternate_shallow_file);
31 r->parsed_objects->alternate_shallow_file = xstrdup_or_null(path);
32 }
33
34 int register_shallow(struct repository *r, const struct object_id *oid)
35 {
36 struct commit_graft *graft =
37 xmalloc(sizeof(struct commit_graft));
38 struct commit *commit = lookup_commit(r, oid);
39
40 oidcpy(&graft->oid, oid);
41 graft->nr_parent = -1;
42 if (commit && commit->object.parsed) {
43 commit_list_free(commit->parents);
44 commit->parents = NULL;
45 }
46 return register_commit_graft(r, graft, 0);
47 }
48
49 int unregister_shallow(const struct object_id *oid)
50 {
51 int pos = commit_graft_pos(the_repository, oid);
52 if (pos < 0)
53 return -1;
54 free(the_repository->parsed_objects->grafts[pos]);
55 if (pos + 1 < the_repository->parsed_objects->grafts_nr)
56 MOVE_ARRAY(the_repository->parsed_objects->grafts + pos,
57 the_repository->parsed_objects->grafts + pos + 1,
58 the_repository->parsed_objects->grafts_nr - pos - 1);
59 the_repository->parsed_objects->grafts_nr--;
60 return 0;
61 }
62
63 int is_repository_shallow(struct repository *r)
64 {
65 FILE *fp;
66 char buf[1024];
67 const char *path = r->parsed_objects->alternate_shallow_file;
68
69 if (r->parsed_objects->is_shallow >= 0)
70 return r->parsed_objects->is_shallow;
71
72 if (!path)
73 path = git_path_shallow(r);
74 /*
75 * fetch-pack sets '--shallow-file ""' as an indicator that no
76 * shallow file should be used. We could just open it and it
77 * will likely fail. But let's do an explicit check instead.
78 */
79 if (!*path || (fp = fopen(path, "r")) == NULL) {
80 stat_validity_clear(r->parsed_objects->shallow_stat);
81 r->parsed_objects->is_shallow = 0;
82 return r->parsed_objects->is_shallow;
83 }
84 stat_validity_update(r->parsed_objects->shallow_stat, fileno(fp));
85 r->parsed_objects->is_shallow = 1;
86
87 while (fgets(buf, sizeof(buf), fp)) {
88 struct object_id oid;
89 if (get_oid_hex(buf, &oid))
90 die("bad shallow line: %s", buf);
91 register_shallow(r, &oid);
92 }
93 fclose(fp);
94 return r->parsed_objects->is_shallow;
95 }
96
97 static void reset_repository_shallow(struct repository *r)
98 {
99 r->parsed_objects->is_shallow = -1;
100 stat_validity_clear(r->parsed_objects->shallow_stat);
101 parsed_object_pool_reset_commit_grafts(r->parsed_objects);
102 }
103
104 int commit_shallow_file(struct repository *r, struct shallow_lock *lk)
105 {
106 int res = commit_lock_file(&lk->lock);
107 reset_repository_shallow(r);
108
109 /*
110 * Update in-memory data structures with the new shallow information,
111 * including unparsing all commits that now have grafts.
112 */
113 is_repository_shallow(r);
114
115 return res;
116 }
117
118 void rollback_shallow_file(struct repository *r, struct shallow_lock *lk)
119 {
120 rollback_lock_file(&lk->lock);
121 reset_repository_shallow(r);
122 }
123
124 /*
125 * TODO: use "int" elemtype instead of "int *" when/if commit-slab
126 * supports a "valid" flag.
127 */
128 define_commit_slab(commit_depth, int *);
129 static void free_depth_in_slab(int **ptr)
130 {
131 FREE_AND_NULL(*ptr);
132 }
133 /*
134 * This is a common internal function that can either return a list of
135 * shallow commits or calculate the current maximum depth of a shallow
136 * repository, depending on the input parameters.
137 *
138 * Depth calculation is triggered by passing the `shallows` parameter.
139 * In this case, the computed depth is stored in `max_cur_depth` (if it is
140 * provided), and the function returns NULL.
141 *
142 * Otherwise, `max_cur_depth` remains unchanged and the function returns
143 * a list of shallow commits.
144 */
145 static struct commit_list *get_shallows_or_depth(struct object_array *heads,
146 struct object_array *shallows, int *max_cur_depth,
147 int depth, int shallow_flag, int not_shallow_flag)
148 {
149 size_t i = 0;
150 int cur_depth = 0, cur_depth_shallow = 0;
151 struct commit_list *result = NULL;
152 struct object_array stack = OBJECT_ARRAY_INIT;
153 struct commit *commit = NULL;
154 struct commit_graft *graft;
155 struct commit_depth depths;
156
157 init_commit_depth(&depths);
158 while (commit || i < heads->nr || stack.nr) {
159 struct commit_list *p;
160 if (!commit) {
161 if (i < heads->nr) {
162 int **depth_slot;
163 commit = (struct commit *)
164 deref_tag(the_repository,
165 heads->objects[i++].item,
166 NULL, 0);
167 if (!commit || commit->object.type != OBJ_COMMIT) {
168 commit = NULL;
169 continue;
170 }
171 depth_slot = commit_depth_at(&depths, commit);
172 if (!*depth_slot)
173 *depth_slot = xmalloc(sizeof(int));
174 **depth_slot = 0;
175 cur_depth = 0;
176 } else {
177 commit = (struct commit *)
178 object_array_pop(&stack);
179 cur_depth = **commit_depth_at(&depths, commit);
180 }
181 }
182 parse_commit_or_die(commit);
183 cur_depth++;
184 if (shallows) {
185 for (size_t j = 0; j < shallows->nr; j++)
186 if (oideq(&commit->object.oid, &shallows->objects[j].item->oid))
187 if (!cur_depth_shallow || cur_depth < cur_depth_shallow)
188 cur_depth_shallow = cur_depth;
189
190 if ((is_repository_shallow(the_repository) && !commit->parents &&
191 (graft = lookup_commit_graft(the_repository, &commit->object.oid)) != NULL &&
192 graft->nr_parent < 0)) {
193 commit = NULL;
194 continue;
195 }
196 } else {
197 if ((depth != INFINITE_DEPTH && cur_depth >= depth) ||
198 (is_repository_shallow(the_repository) && !commit->parents &&
199 (graft = lookup_commit_graft(the_repository, &commit->object.oid)) != NULL &&
200 graft->nr_parent < 0)) {
201 commit_list_insert(commit, &result);
202 commit->object.flags |= shallow_flag;
203 commit = NULL;
204 continue;
205 }
206 commit->object.flags |= not_shallow_flag;
207 }
208 for (p = commit->parents, commit = NULL; p; p = p->next) {
209 int **depth_slot = commit_depth_at(&depths, p->item);
210 if (!*depth_slot) {
211 *depth_slot = xmalloc(sizeof(int));
212 **depth_slot = cur_depth;
213 } else {
214 if (cur_depth >= **depth_slot)
215 continue;
216 **depth_slot = cur_depth;
217 }
218 if (p->next)
219 add_object_array(&p->item->object,
220 NULL, &stack);
221 else {
222 commit = p->item;
223 cur_depth = **commit_depth_at(&depths, commit);
224 }
225 }
226 }
227 deep_clear_commit_depth(&depths, free_depth_in_slab);
228 object_array_clear(&stack);
229
230 if (shallows && max_cur_depth)
231 *max_cur_depth = cur_depth_shallow;
232 return result;
233 }
234
235 int get_shallows_depth(struct object_array *heads, struct object_array *shallows)
236 {
237 int max_cur_depth = 0;
238 get_shallows_or_depth(heads, shallows, &max_cur_depth, 0, 0, 0);
239 return max_cur_depth;
240
241 }
242
243 struct commit_list *get_shallow_commits(struct object_array *heads,
244 struct object_array *shallows, int deepen_relative,
245 int depth, int shallow_flag, int not_shallow_flag)
246 {
247 if (shallows && deepen_relative) {
248 int cur_shallow_depth = get_shallows_depth(heads, shallows);
249 if (cur_shallow_depth)
250 depth += cur_shallow_depth;
251 else
252 return NULL;
253 }
254 return get_shallows_or_depth(heads, NULL, NULL,
255 depth, shallow_flag, not_shallow_flag);
256 }
257
258 static void show_commit(struct commit *commit, void *data)
259 {
260 commit_list_insert(commit, data);
261 }
262
263 /*
264 * Given rev-list arguments, run rev-list. All reachable commits
265 * except border ones are marked with not_shallow_flag. Border commits
266 * are marked with shallow_flag. The list of border/shallow commits
267 * are also returned.
268 */
269 struct commit_list *get_shallow_commits_by_rev_list(struct strvec *argv,
270 int shallow_flag,
271 int not_shallow_flag)
272 {
273 struct commit_list *result = NULL, *p;
274 struct commit_list *not_shallow_list = NULL;
275 struct rev_info revs;
276 int both_flags = shallow_flag | not_shallow_flag;
277
278 /*
279 * SHALLOW (excluded) and NOT_SHALLOW (included) should not be
280 * set at this point. But better be safe than sorry.
281 */
282 clear_object_flags(the_repository, both_flags);
283
284 is_repository_shallow(the_repository); /* make sure shallows are read */
285
286 repo_init_revisions(the_repository, &revs, NULL);
287 save_commit_buffer = 0;
288 setup_revisions_from_strvec(argv, &revs, NULL);
289
290 if (prepare_revision_walk(&revs))
291 die("revision walk setup failed");
292 traverse_commit_list(&revs, show_commit, NULL, &not_shallow_list);
293
294 if (!not_shallow_list)
295 die("no commits selected for shallow requests");
296
297 /* Mark all reachable commits as NOT_SHALLOW */
298 for (p = not_shallow_list; p; p = p->next)
299 p->item->object.flags |= not_shallow_flag;
300
301 /*
302 * mark border commits SHALLOW + NOT_SHALLOW.
303 * We cannot clear NOT_SHALLOW right now. Imagine border
304 * commit A is processed first, then commit B, whose parent is
305 * A, later. If NOT_SHALLOW on A is cleared at step 1, B
306 * itself is considered border at step 2, which is incorrect.
307 */
308 for (p = not_shallow_list; p; p = p->next) {
309 struct commit *c = p->item;
310 struct commit_list *parent;
311
312 if (repo_parse_commit(the_repository, c))
313 die("unable to parse commit %s",
314 oid_to_hex(&c->object.oid));
315
316 for (parent = c->parents; parent; parent = parent->next)
317 if (!(parent->item->object.flags & not_shallow_flag)) {
318 c->object.flags |= shallow_flag;
319 commit_list_insert(c, &result);
320 break;
321 }
322 }
323 commit_list_free(not_shallow_list);
324
325 /*
326 * Now we can clean up NOT_SHALLOW on border commits. Having
327 * both flags set can confuse the caller.
328 */
329 for (p = result; p; p = p->next) {
330 struct object *o = &p->item->object;
331 if ((o->flags & both_flags) == both_flags)
332 o->flags &= ~not_shallow_flag;
333 }
334 release_revisions(&revs);
335 return result;
336 }
337
338 static void check_shallow_file_for_update(struct repository *r)
339 {
340 if (r->parsed_objects->is_shallow == -1)
341 BUG("shallow must be initialized by now");
342
343 if (!stat_validity_check(r->parsed_objects->shallow_stat,
344 git_path_shallow(r)))
345 die("shallow file has changed since we read it");
346 }
347
348 #define SEEN_ONLY 1
349 #define VERBOSE 2
350 #define QUICK 4
351
352 struct write_shallow_data {
353 struct strbuf *out;
354 int use_pack_protocol;
355 int count;
356 unsigned flags;
357 };
358
359 static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
360 {
361 struct write_shallow_data *data = cb_data;
362 const char *hex = oid_to_hex(&graft->oid);
363 if (graft->nr_parent != -1)
364 return 0;
365 if (data->flags & QUICK) {
366 if (!odb_has_object(the_repository->objects, &graft->oid,
367 ODB_HAS_OBJECT_RECHECK_PACKED | ODB_HAS_OBJECT_FETCH_PROMISOR))
368 return 0;
369 } else if (data->flags & SEEN_ONLY) {
370 struct commit *c = lookup_commit(the_repository, &graft->oid);
371 if (!c || !(c->object.flags & SEEN)) {
372 if (data->flags & VERBOSE)
373 printf("Removing %s from .git/shallow\n",
374 oid_to_hex(&c->object.oid));
375 return 0;
376 }
377 }
378 data->count++;
379 if (data->use_pack_protocol)
380 packet_buf_write(data->out, "shallow %s", hex);
381 else {
382 strbuf_addstr(data->out, hex);
383 strbuf_addch(data->out, '\n');
384 }
385 return 0;
386 }
387
388 static int write_shallow_commits_1(struct strbuf *out, int use_pack_protocol,
389 const struct oid_array *extra,
390 unsigned flags)
391 {
392 struct write_shallow_data data = {
393 .out = out,
394 .use_pack_protocol = use_pack_protocol,
395 .flags = flags,
396 };
397
398 for_each_commit_graft(write_one_shallow, &data);
399 if (!extra)
400 return data.count;
401 for (size_t i = 0; i < extra->nr; i++) {
402 strbuf_add_oid_hex(out, extra->oid + i);
403 strbuf_addch(out, '\n');
404 data.count++;
405 }
406 return data.count;
407 }
408
409 int write_shallow_commits(struct strbuf *out, int use_pack_protocol,
410 const struct oid_array *extra)
411 {
412 return write_shallow_commits_1(out, use_pack_protocol, extra, 0);
413 }
414
415 const char *setup_temporary_shallow(const struct oid_array *extra)
416 {
417 struct tempfile *temp;
418 struct strbuf sb = STRBUF_INIT;
419
420 if (write_shallow_commits(&sb, 0, extra)) {
421 char *path = repo_git_path(the_repository, "shallow_XXXXXX");
422 temp = xmks_tempfile(path);
423 free(path);
424
425 if (write_in_full(temp->fd, sb.buf, sb.len) < 0 ||
426 close_tempfile_gently(temp) < 0)
427 die_errno("failed to write to %s",
428 get_tempfile_path(temp));
429 strbuf_release(&sb);
430 return get_tempfile_path(temp);
431 }
432 /*
433 * is_repository_shallow() sees empty string as "no shallow
434 * file".
435 */
436 return "";
437 }
438
439 void setup_alternate_shallow(struct shallow_lock *shallow_lock,
440 const char **alternate_shallow_file,
441 const struct oid_array *extra)
442 {
443 struct strbuf sb = STRBUF_INIT;
444 int fd;
445
446 fd = hold_lock_file_for_update(&shallow_lock->lock,
447 git_path_shallow(the_repository),
448 LOCK_DIE_ON_ERROR);
449 check_shallow_file_for_update(the_repository);
450 if (write_shallow_commits(&sb, 0, extra)) {
451 if (write_in_full(fd, sb.buf, sb.len) < 0)
452 die_errno("failed to write to %s",
453 get_lock_file_path(&shallow_lock->lock));
454 *alternate_shallow_file = get_lock_file_path(&shallow_lock->lock);
455 } else
456 /*
457 * is_repository_shallow() sees empty string as "no
458 * shallow file".
459 */
460 *alternate_shallow_file = "";
461 strbuf_release(&sb);
462 }
463
464 static int advertise_shallow_grafts_cb(const struct commit_graft *graft, void *cb)
465 {
466 int fd = *(int *)cb;
467 if (graft->nr_parent == -1)
468 packet_write_fmt(fd, "shallow %s\n", oid_to_hex(&graft->oid));
469 return 0;
470 }
471
472 void advertise_shallow_grafts(int fd)
473 {
474 if (!is_repository_shallow(the_repository))
475 return;
476 for_each_commit_graft(advertise_shallow_grafts_cb, &fd);
477 }
478
479 /*
480 * mark_reachable_objects() should have been run prior to this and all
481 * reachable commits marked as "SEEN", except when quick_prune is non-zero,
482 * in which case lines are excised from the shallow file if they refer to
483 * commits that do not exist (any longer).
484 */
485 void prune_shallow(unsigned options)
486 {
487 struct shallow_lock shallow_lock = SHALLOW_LOCK_INIT;
488 struct strbuf sb = STRBUF_INIT;
489 unsigned flags = SEEN_ONLY;
490 int fd;
491
492 if (options & PRUNE_QUICK)
493 flags |= QUICK;
494
495 if (options & PRUNE_SHOW_ONLY) {
496 flags |= VERBOSE;
497 write_shallow_commits_1(&sb, 0, NULL, flags);
498 strbuf_release(&sb);
499 return;
500 }
501 fd = hold_lock_file_for_update(&shallow_lock.lock,
502 git_path_shallow(the_repository),
503 LOCK_DIE_ON_ERROR);
504 check_shallow_file_for_update(the_repository);
505 if (write_shallow_commits_1(&sb, 0, NULL, flags)) {
506 if (write_in_full(fd, sb.buf, sb.len) < 0)
507 die_errno("failed to write to %s",
508 get_lock_file_path(&shallow_lock.lock));
509 commit_shallow_file(the_repository, &shallow_lock);
510 } else {
511 unlink(git_path_shallow(the_repository));
512 rollback_shallow_file(the_repository, &shallow_lock);
513 }
514 strbuf_release(&sb);
515 }
516
517 struct trace_key trace_shallow = TRACE_KEY_INIT(SHALLOW);
518
519 /*
520 * Step 1, split sender shallow commits into "ours" and "theirs"
521 * Step 2, clean "ours" based on .git/shallow
522 */
523 void prepare_shallow_info(struct shallow_info *info, struct oid_array *sa)
524 {
525 trace_printf_key(&trace_shallow, "shallow: prepare_shallow_info\n");
526 memset(info, 0, sizeof(*info));
527 commit_stack_init(&info->commits);
528 info->shallow = sa;
529 if (!sa)
530 return;
531 ALLOC_ARRAY(info->ours, sa->nr);
532 ALLOC_ARRAY(info->theirs, sa->nr);
533 for (size_t i = 0; i < sa->nr; i++) {
534 if (odb_has_object(the_repository->objects, sa->oid + i,
535 ODB_HAS_OBJECT_RECHECK_PACKED | ODB_HAS_OBJECT_FETCH_PROMISOR)) {
536 struct commit_graft *graft;
537 graft = lookup_commit_graft(the_repository,
538 &sa->oid[i]);
539 if (graft && graft->nr_parent < 0)
540 continue;
541 info->ours[info->nr_ours++] = i;
542 } else
543 info->theirs[info->nr_theirs++] = i;
544 }
545 }
546
547 void clear_shallow_info(struct shallow_info *info)
548 {
549 if (info->used_shallow) {
550 for (size_t i = 0; i < info->shallow->nr; i++)
551 free(info->used_shallow[i]);
552 free(info->used_shallow);
553 }
554
555 free(info->need_reachability_test);
556 free(info->reachable);
557 free(info->shallow_ref);
558 free(info->ours);
559 free(info->theirs);
560 commit_stack_clear(&info->commits);
561 }
562
563 /* Step 4, remove non-existent ones in "theirs" after getting the pack */
564
565 void remove_nonexistent_theirs_shallow(struct shallow_info *info)
566 {
567 struct object_id *oid = info->shallow->oid;
568 size_t i, dst;
569 trace_printf_key(&trace_shallow, "shallow: remove_nonexistent_theirs_shallow\n");
570 for (i = dst = 0; i < info->nr_theirs; i++) {
571 if (i != dst)
572 info->theirs[dst] = info->theirs[i];
573 if (odb_has_object(the_repository->objects, oid + info->theirs[i],
574 ODB_HAS_OBJECT_RECHECK_PACKED | ODB_HAS_OBJECT_FETCH_PROMISOR))
575 dst++;
576 }
577 info->nr_theirs = dst;
578 }
579
580 define_commit_slab(ref_bitmap, uint32_t *);
581
582 #define POOL_SIZE (512 * 1024)
583
584 struct paint_info {
585 struct ref_bitmap ref_bitmap;
586 unsigned nr_bits;
587 char **pools;
588 char *free, *end;
589 unsigned pool_count;
590 };
591
592 static uint32_t *paint_alloc(struct paint_info *info)
593 {
594 unsigned nr = DIV_ROUND_UP(info->nr_bits, 32);
595 unsigned size = nr * sizeof(uint32_t);
596 void *p;
597 if (!info->pool_count || info->end < info->free + size) {
598 if (size > POOL_SIZE)
599 BUG("pool size too small for %d in paint_alloc()",
600 size);
601 info->pool_count++;
602 REALLOC_ARRAY(info->pools, info->pool_count);
603 info->free = xmalloc(POOL_SIZE);
604 info->pools[info->pool_count - 1] = info->free;
605 info->end = info->free + POOL_SIZE;
606 }
607 p = info->free;
608 info->free += size;
609 return p;
610 }
611
612 /*
613 * Given a commit SHA-1, walk down to parents until either SEEN,
614 * UNINTERESTING or BOTTOM is hit. Set the id-th bit in ref_bitmap for
615 * all walked commits.
616 */
617 static void paint_down(struct paint_info *info, const struct object_id *oid,
618 unsigned int id)
619 {
620 unsigned int i, nr;
621 struct commit_list *head = NULL;
622 size_t bitmap_nr = DIV_ROUND_UP(info->nr_bits, 32);
623 size_t bitmap_size = st_mult(sizeof(uint32_t), bitmap_nr);
624 struct commit *c = lookup_commit_reference_gently(the_repository, oid,
625 1);
626 uint32_t *tmp; /* to be freed before return */
627 uint32_t *bitmap;
628
629 if (!c)
630 return;
631
632 tmp = xmalloc(bitmap_size);
633 bitmap = paint_alloc(info);
634 memset(bitmap, 0, bitmap_size);
635 bitmap[id / 32] |= (1U << (id % 32));
636 commit_list_insert(c, &head);
637 while (head) {
638 struct commit_list *p;
639 struct commit *c = pop_commit(&head);
640 uint32_t **refs = ref_bitmap_at(&info->ref_bitmap, c);
641
642 /* XXX check "UNINTERESTING" from pack bitmaps if available */
643 if (c->object.flags & (SEEN | UNINTERESTING))
644 continue;
645 else
646 c->object.flags |= SEEN;
647
648 if (!*refs)
649 *refs = bitmap;
650 else {
651 memcpy(tmp, *refs, bitmap_size);
652 for (i = 0; i < bitmap_nr; i++)
653 tmp[i] |= bitmap[i];
654 if (memcmp(tmp, *refs, bitmap_size)) {
655 *refs = paint_alloc(info);
656 memcpy(*refs, tmp, bitmap_size);
657 }
658 }
659
660 if (c->object.flags & BOTTOM)
661 continue;
662
663 if (repo_parse_commit(the_repository, c))
664 die("unable to parse commit %s",
665 oid_to_hex(&c->object.oid));
666
667 for (p = c->parents; p; p = p->next) {
668 if (p->item->object.flags & SEEN)
669 continue;
670 commit_list_insert(p->item, &head);
671 }
672 }
673
674 nr = get_max_object_index(the_repository);
675 for (i = 0; i < nr; i++) {
676 struct object *o = get_indexed_object(the_repository, i);
677 if (o && o->type == OBJ_COMMIT)
678 o->flags &= ~SEEN;
679 }
680
681 free(tmp);
682 }
683
684 static int mark_uninteresting(const struct reference *ref, void *cb_data UNUSED)
685 {
686 struct commit *commit = lookup_commit_reference_gently(the_repository,
687 ref->oid, 1);
688 if (!commit)
689 return 0;
690 commit->object.flags |= UNINTERESTING;
691 mark_parents_uninteresting(NULL, commit);
692 return 0;
693 }
694
695 static void post_assign_shallow(struct shallow_info *info,
696 struct ref_bitmap *ref_bitmap,
697 int *ref_status);
698 /*
699 * Step 6(+7), associate shallow commits with new refs
700 *
701 * info->ref must be initialized before calling this function.
702 *
703 * If used is not NULL, it's an array of info->shallow->nr
704 * bitmaps. The n-th bit set in the m-th bitmap if ref[n] needs the
705 * m-th shallow commit from info->shallow.
706 *
707 * If used is NULL, "ours" and "theirs" are updated. And if ref_status
708 * is not NULL it's an array of ref->nr ints. ref_status[i] is true if
709 * the ref needs some shallow commits from either info->ours or
710 * info->theirs.
711 */
712 void assign_shallow_commits_to_refs(struct shallow_info *info,
713 uint32_t **used, int *ref_status)
714 {
715 struct object_id *oid = info->shallow->oid;
716 struct oid_array *ref = info->ref;
717 unsigned int i, nr;
718 size_t *shallow, nr_shallow = 0;
719 struct paint_info pi;
720
721 trace_printf_key(&trace_shallow, "shallow: assign_shallow_commits_to_refs\n");
722 ALLOC_ARRAY(shallow, info->nr_ours + info->nr_theirs);
723 for (i = 0; i < info->nr_ours; i++)
724 shallow[nr_shallow++] = info->ours[i];
725 for (i = 0; i < info->nr_theirs; i++)
726 shallow[nr_shallow++] = info->theirs[i];
727
728 /*
729 * Prepare the commit graph to track what refs can reach what
730 * (new) shallow commits.
731 */
732 nr = get_max_object_index(the_repository);
733 for (i = 0; i < nr; i++) {
734 struct object *o = get_indexed_object(the_repository, i);
735 if (!o || o->type != OBJ_COMMIT)
736 continue;
737
738 o->flags &= ~(UNINTERESTING | BOTTOM | SEEN);
739 }
740
741 memset(&pi, 0, sizeof(pi));
742 init_ref_bitmap(&pi.ref_bitmap);
743 pi.nr_bits = ref->nr;
744
745 /*
746 * "--not --all" to cut short the traversal if new refs
747 * connect to old refs. If not (e.g. force ref updates) it'll
748 * have to go down to the current shallow commits.
749 */
750 refs_head_ref(get_main_ref_store(the_repository), mark_uninteresting,
751 NULL);
752 refs_for_each_ref(get_main_ref_store(the_repository),
753 mark_uninteresting, NULL);
754
755 /* Mark potential bottoms so we won't go out of bound */
756 for (i = 0; i < nr_shallow; i++) {
757 struct commit *c = lookup_commit(the_repository,
758 &oid[shallow[i]]);
759 c->object.flags |= BOTTOM;
760 }
761
762 for (i = 0; i < ref->nr; i++)
763 paint_down(&pi, ref->oid + i, i);
764
765 if (used) {
766 int bitmap_size = DIV_ROUND_UP(pi.nr_bits, 32) * sizeof(uint32_t);
767 MEMZERO_ARRAY(used, info->shallow->nr);
768 for (i = 0; i < nr_shallow; i++) {
769 const struct commit *c = lookup_commit(the_repository,
770 &oid[shallow[i]]);
771 uint32_t **map = ref_bitmap_at(&pi.ref_bitmap, c);
772 if (*map)
773 used[shallow[i]] = xmemdupz(*map, bitmap_size);
774 }
775 /*
776 * unreachable shallow commits are not removed from
777 * "ours" and "theirs". The user is supposed to run
778 * step 7 on every ref separately and not trust "ours"
779 * and "theirs" any more.
780 */
781 } else
782 post_assign_shallow(info, &pi.ref_bitmap, ref_status);
783
784 clear_ref_bitmap(&pi.ref_bitmap);
785 for (i = 0; i < pi.pool_count; i++)
786 free(pi.pools[i]);
787 free(pi.pools);
788 free(shallow);
789 }
790
791 static int add_ref(const struct reference *ref, void *cb_data)
792 {
793 struct commit_stack *cs = cb_data;
794 struct commit *commit = lookup_commit_reference_gently(the_repository,
795 ref->oid, 1);
796 if (commit)
797 commit_stack_push(cs, commit);
798 return 0;
799 }
800
801 static void update_refstatus(int *ref_status, size_t nr, uint32_t *bitmap)
802 {
803 if (!ref_status)
804 return;
805 for (size_t i = 0; i < nr; i++)
806 if (bitmap[i / 32] & (1U << (i % 32)))
807 ref_status[i]++;
808 }
809
810 /*
811 * Step 7, reachability test on "ours" at commit level
812 */
813 static void post_assign_shallow(struct shallow_info *info,
814 struct ref_bitmap *ref_bitmap,
815 int *ref_status)
816 {
817 struct object_id *oid = info->shallow->oid;
818 struct commit *c;
819 uint32_t **bitmap;
820 size_t dst, i, j;
821 size_t bitmap_nr = DIV_ROUND_UP(info->ref->nr, 32);
822 struct commit_stack cs = COMMIT_STACK_INIT;
823
824 trace_printf_key(&trace_shallow, "shallow: post_assign_shallow\n");
825 if (ref_status)
826 MEMZERO_ARRAY(ref_status, info->ref->nr);
827
828 /* Remove unreachable shallow commits from "theirs" */
829 for (i = dst = 0; i < info->nr_theirs; i++) {
830 if (i != dst)
831 info->theirs[dst] = info->theirs[i];
832 c = lookup_commit(the_repository, &oid[info->theirs[i]]);
833 bitmap = ref_bitmap_at(ref_bitmap, c);
834 if (!*bitmap)
835 continue;
836 for (j = 0; j < bitmap_nr; j++)
837 if (bitmap[0][j]) {
838 update_refstatus(ref_status, info->ref->nr, *bitmap);
839 dst++;
840 break;
841 }
842 }
843 info->nr_theirs = dst;
844
845 refs_head_ref(get_main_ref_store(the_repository), add_ref, &cs);
846 refs_for_each_ref(get_main_ref_store(the_repository), add_ref, &cs);
847
848 /* Remove unreachable shallow commits from "ours" */
849 for (i = dst = 0; i < info->nr_ours; i++) {
850 if (i != dst)
851 info->ours[dst] = info->ours[i];
852 c = lookup_commit(the_repository, &oid[info->ours[i]]);
853 bitmap = ref_bitmap_at(ref_bitmap, c);
854 if (!*bitmap)
855 continue;
856 for (j = 0; j < bitmap_nr; j++)
857 if (bitmap[0][j]) {
858 /* Step 7, reachability test at commit level */
859 int ret = repo_in_merge_bases_many(the_repository, c, cs.nr, cs.items, 1);
860 if (ret < 0)
861 exit(128);
862 if (!ret) {
863 update_refstatus(ref_status, info->ref->nr, *bitmap);
864 dst++;
865 break;
866 }
867 }
868 }
869 info->nr_ours = dst;
870
871 commit_stack_clear(&cs);
872 }
873
874 /* (Delayed) step 7, reachability test at commit level */
875 int delayed_reachability_test(struct shallow_info *si, int c)
876 {
877 if (si->need_reachability_test[c]) {
878 struct commit *commit = lookup_commit(the_repository,
879 &si->shallow->oid[c]);
880
881 if (!si->commits.nr) {
882 refs_head_ref(get_main_ref_store(the_repository),
883 add_ref, &si->commits);
884 refs_for_each_ref(get_main_ref_store(the_repository),
885 add_ref, &si->commits);
886 }
887
888 si->reachable[c] = repo_in_merge_bases_many(the_repository,
889 commit,
890 si->commits.nr,
891 si->commits.items,
892 1);
893 if (si->reachable[c] < 0)
894 exit(128);
895 si->need_reachability_test[c] = 0;
896 }
897 return si->reachable[c];
898 }