pu c0f7ae5a7ea5cf8246270fcf1853726167ca8ef4 jch fffcd002d6befa77784a44046b986934b87e6c3b next 55c56c9c57da646085d27e61a3420043978ab4a1 master 07d8ea56f2ecb64b75b92264770c0a664231ce17 master@{1} 86ab15cb154862b6fa5cc646dac27532f881e1fb Uncovered code in 'pu' not in 'jch' -------------------------------------------------------- builtin/bisect--helper.c 9aadf776 91) return error_errno(_("cannot open file '%s' in mode '%s'"), path, mode); 9aadf776 96) fclose(fp); 9aadf776 97) return error_errno(_("could not write to file '%s'"), path); 587c9fac 493) return error_errno(_("failed to write to '%s'"), git_path_bisect_log()); 587c9fac 522) return error_errno(_("could not open '%s' for appending"), f0bf9482 730) return BISECT_FAILED; f0bf9482 751) res = BISECT_FAILED; f0bf9482 763) res = BISECT_FAILED; f0bf9482 775) res = BISECT_FAILED; 05a69202 818) fprintf(stderr, _("You need to start by \"git bisect " 05a69202 821) if (!isatty(STDIN_FILENO)) 05a69202 822) return 1; 05a69202 829) yesno = git_prompt(_("Do you want me to do it for you " 05a69202 831) if (starts_with(yesno, _("n")) || starts_with(yesno, _("N"))) 05a69202 832) return 1; 05a69202 834) return bisect_start(terms, 0, NULL, 0); 10520dbf 869) return BISECT_FAILED; 10520dbf 885) oid_array_clear(&revs); 10520dbf 886) return BISECT_FAILED; builtin/commit-graph.c 199d758e 244) progress = start_delayed_progress( builtin/receive-pack.c 7e70e854 239) return config_error_nonbool(var); ad8697b0 1045) return code; ad8697b0 1048) proc.err = 0; ad8697b0 1053) if (use_sideband) ad8697b0 1054) finish_async(&muxer); ad8697b0 1055) return code; ad8697b0 1541) cmd->report.error_message = "broken symref"; ad8697b0 1726) cmd->report.error_message = "transaction failed to start"; 7e70e854 1838) continue; ad8697b0 1865) if (!cmd->report.error_message) ad8697b0 1866) cmd->report.error_message = "unable to migrate objects to permanent storage"; 38a81b4e 2265) packet_buf_write(&buf, "ng %s %s\n", ad8697b0 2266) cmd->ref_name, cmd->report.error_message); 38a81b4e 2271) send_sideband(1, 1, buf.buf, buf.len, use_sideband); line-log.c 78a1541e 1159) return 1; 78a1541e 1166) return 0; refs/reftable-backend.c e0271b93 131) ref_type(ri->base.refname) != REF_TYPE_PER_WORKTREE) e0271b93 132) continue; e0271b93 137) } else if (ri->ref.target != NULL) { e0271b93 138) int out_flags = 0; e0271b93 139) const char *resolved = refs_resolve_ref_unsafe( e0271b93 140) ri->ref_store, ri->ref.ref_name, e0271b93 142) ri->base.flags = out_flags; e0271b93 143) if (resolved == NULL && e0271b93 144) !(ri->flags & DO_FOR_EACH_INCLUDE_BROKEN) && e0271b93 145) (ri->base.flags & REF_ISBROKEN)) { e0271b93 146) continue; e0271b93 154) continue; e0271b93 164) return ITER_ERROR; e0271b93 183) static int reftable_ref_iterator_abort(struct ref_iterator *ref_iterator) e0271b93 185) struct git_reftable_iterator *ri = e0271b93 187) reftable_ref_record_clear(&ri->ref); e0271b93 188) reftable_iterator_destroy(&ri->iter); e0271b93 189) return 0; e0271b93 207) ri->err = refs->err; e0271b93 228) static int reftable_transaction_abort(struct ref_store *ref_store, e0271b93 232) struct git_reftable_ref_store *refs = e0271b93 235) return 0; e0271b93 246) return REFTABLE_LOCK_ERROR; e0271b93 256) static int ref_update_cmp(const void *a, const void *b) e0271b93 258) return strcmp(((struct ref_update *)a)->refname, e0271b93 259) ((struct ref_update *)b)->refname); e0271b93 334) goto exit; e0271b93 352) return refs->err; e0271b93 380) static int write_delete_refs_table(struct reftable_writer *writer, void *argv) e0271b93 382) struct write_delete_refs_arg *arg = e0271b93 384) uint64_t ts = reftable_stack_next_update_index(arg->stack); e0271b93 385) int err = 0; e0271b93 386) int i = 0; e0271b93 388) reftable_writer_set_limits(writer, ts, ts); e0271b93 389) for (i = 0; i < arg->refnames->nr; i++) { e0271b93 390) struct reftable_ref_record ref = { e0271b93 391) .ref_name = (char *)arg->refnames->items[i].string, e0271b93 394) err = reftable_writer_add_ref(writer, &ref); e0271b93 395) if (err < 0) { e0271b93 396) return err; e0271b93 400) for (i = 0; i < arg->refnames->nr; i++) { e0271b93 401) struct reftable_log_record log = { NULL }; e0271b93 402) struct reftable_ref_record current = { NULL }; e0271b93 403) fill_reftable_log_record(&log); e0271b93 404) log.message = xstrdup(arg->logmsg); e0271b93 405) log.new_hash = NULL; e0271b93 406) log.old_hash = NULL; e0271b93 407) log.update_index = ts; e0271b93 408) log.ref_name = (char *)arg->refnames->items[i].string; e0271b93 410) if (reftable_stack_read_ref(arg->stack, log.ref_name, e0271b93 412) log.old_hash = current.value; e0271b93 414) err = reftable_writer_add_log(writer, &log); e0271b93 415) log.old_hash = NULL; e0271b93 416) reftable_ref_record_clear(¤t); e0271b93 418) clear_reftable_log_record(&log); e0271b93 419) if (err < 0) { e0271b93 420) return err; e0271b93 423) return 0; e0271b93 426) static int reftable_delete_refs(struct ref_store *ref_store, const char *msg, e0271b93 430) struct git_reftable_ref_store *refs = e0271b93 432) struct write_delete_refs_arg arg = { e0271b93 433) .stack = refs->stack, e0271b93 438) if (refs->err < 0) { e0271b93 439) return refs->err; e0271b93 442) return reftable_stack_add(refs->stack, &write_delete_refs_table, &arg); e0271b93 450) return refs->err; e0271b93 477) return err; e0271b93 493) log.old_hash = old_oid.hash; e0271b93 499) log.new_hash = new_oid.hash; e0271b93 503) reftable_writer_add_log(writer, &log); e0271b93 524) return refs->err; e0271b93 537) static int write_rename_table(struct reftable_writer *writer, void *argv) e0271b93 539) struct write_rename_arg *arg = (struct write_rename_arg *)argv; e0271b93 540) uint64_t ts = reftable_stack_next_update_index(arg->stack); e0271b93 541) struct reftable_ref_record ref = { NULL }; e0271b93 542) int err = reftable_stack_read_ref(arg->stack, arg->oldname, &ref); e0271b93 544) if (err) { e0271b93 545) goto exit; e0271b93 549) if (reftable_stack_read_ref(arg->stack, arg->newname, &ref) == 0) { e0271b93 550) goto exit; e0271b93 553) free(ref.ref_name); e0271b93 554) ref.ref_name = strdup(arg->newname); e0271b93 555) reftable_writer_set_limits(writer, ts, ts); e0271b93 556) ref.update_index = ts; e0271b93 559) struct reftable_ref_record todo[2] = { { NULL } }; e0271b93 560) todo[0].ref_name = (char *)arg->oldname; e0271b93 561) todo[0].update_index = ts; e0271b93 563) todo[1] = ref; e0271b93 564) todo[1].update_index = ts; e0271b93 566) err = reftable_writer_add_refs(writer, todo, 2); e0271b93 567) if (err < 0) { e0271b93 568) goto exit; e0271b93 572) if (ref.value != NULL) { e0271b93 573) struct reftable_log_record todo[2] = { { NULL } }; e0271b93 574) fill_reftable_log_record(&todo[0]); e0271b93 575) fill_reftable_log_record(&todo[1]); e0271b93 577) todo[0].ref_name = (char *)arg->oldname; e0271b93 578) todo[0].update_index = ts; e0271b93 579) todo[0].message = (char *)arg->logmsg; e0271b93 580) todo[0].old_hash = ref.value; e0271b93 581) todo[0].new_hash = NULL; e0271b93 583) todo[1].ref_name = (char *)arg->newname; e0271b93 584) todo[1].update_index = ts; e0271b93 585) todo[1].old_hash = NULL; e0271b93 586) todo[1].new_hash = ref.value; e0271b93 587) todo[1].message = (char *)arg->logmsg; e0271b93 589) err = reftable_writer_add_logs(writer, todo, 2); e0271b93 591) clear_reftable_log_record(&todo[0]); e0271b93 592) clear_reftable_log_record(&todo[1]); e0271b93 594) if (err < 0) { e0271b93 595) goto exit; e0271b93 603) reftable_ref_record_clear(&ref); e0271b93 604) return err; e0271b93 607) static int reftable_rename_ref(struct ref_store *ref_store, e0271b93 611) struct git_reftable_ref_store *refs = e0271b93 613) struct write_rename_arg arg = { e0271b93 614) .stack = refs->stack, e0271b93 619) if (refs->err < 0) { e0271b93 620) return refs->err; e0271b93 623) return reftable_stack_add(refs->stack, &write_rename_table, &arg); e0271b93 626) static int reftable_copy_ref(struct ref_store *ref_store, e0271b93 653) return ITER_ERROR; e0271b93 674) static int reftable_reflog_ref_iterator_peel(struct ref_iterator *ref_iterator, e0271b93 681) static int reftable_reflog_ref_iterator_abort(struct ref_iterator *ref_iterator) e0271b93 683) struct reftable_reflog_ref_iterator *ri = e0271b93 685) reftable_log_record_clear(&ri->log); e0271b93 686) reftable_iterator_destroy(&ri->iter); e0271b93 687) return 0; e0271b93 706) free(ri); e0271b93 707) return NULL; e0271b93 730) return refs->err; e0271b93 759) err = -1; e0271b93 774) reftable_for_each_reflog_ent_oldest_first(struct ref_store *ref_store, e0271b93 778) struct reftable_iterator it = { NULL }; e0271b93 779) struct git_reftable_ref_store *refs = e0271b93 781) struct reftable_merged_table *mt = NULL; e0271b93 782) struct reftable_log_record *logs = NULL; e0271b93 783) int cap = 0; e0271b93 784) int len = 0; e0271b93 785) int err = 0; e0271b93 786) int i = 0; e0271b93 788) if (refs->err < 0) { e0271b93 789) return refs->err; e0271b93 791) mt = reftable_stack_merged_table(refs->stack); e0271b93 792) err = reftable_merged_table_seek_log(mt, &it, refname); e0271b93 794) while (err == 0) { e0271b93 795) struct reftable_log_record log = { NULL }; e0271b93 796) err = reftable_iterator_next_log(it, &log); e0271b93 797) if (err != 0) { e0271b93 798) break; e0271b93 801) if (strcmp(log.ref_name, refname)) { e0271b93 802) break; e0271b93 805) if (len == cap) { e0271b93 806) cap = 2 * cap + 1; e0271b93 807) logs = realloc(logs, cap * sizeof(*logs)); e0271b93 810) logs[len++] = log; e0271b93 813) for (i = len; i--;) { e0271b93 814) struct reftable_log_record *log = &logs[i]; e0271b93 817) const char *full_committer = ""; e0271b93 819) hashcpy(old_oid.hash, log->old_hash); e0271b93 820) hashcpy(new_oid.hash, log->new_hash); e0271b93 822) full_committer = fmt_ident(log->name, log->email, e0271b93 825) if (!fn(&old_oid, &new_oid, full_committer, log->time, e0271b93 826) log->tz_offset, log->message, cb_data)) { e0271b93 827) err = -1; e0271b93 828) break; e0271b93 832) for (i = 0; i < len; i++) { e0271b93 833) reftable_log_record_clear(&logs[i]); e0271b93 835) free(logs); e0271b93 837) reftable_iterator_destroy(&it); e0271b93 838) if (err > 0) { e0271b93 839) err = 0; e0271b93 841) return err; e0271b93 851) static int reftable_create_reflog(struct ref_store *ref_store, e0271b93 855) return 0; e0271b93 858) static int reftable_delete_reflog(struct ref_store *ref_store, e0271b93 861) return 0; e0271b93 905) return err; e0271b93 942) return refs->err; e0271b93 948) return err; e0271b93 957) return err; e0271b93 988) return refs->err; e0271b93 998) errno = reftable_error_to_errno(err); e0271b93 999) err = -1; e0271b93 1000) goto exit; e0271b93 1010) *type |= REF_ISBROKEN; e0271b93 1011) errno = EINVAL; e0271b93 1012) err = -1; reftable/basics.c f6f05f35 99) next = end; f6f05f35 121) int names_equal(char **a, char **b) f6f05f35 123) while (*a && *b) { f6f05f35 124) if (strcmp(*a, *b)) { f6f05f35 125) return 0; f6f05f35 128) a++; f6f05f35 129) b++; f6f05f35 132) return *a == *b; f6f05f35 140) return "I/O error"; f6f05f35 142) return "corrupt reftable file"; f6f05f35 144) return "file does not exist"; f6f05f35 148) return "misuse of the reftable API"; f6f05f35 150) return "zlib failure"; f6f05f35 154) return "invalid refname"; f6f05f35 156) return "general error"; f6f05f35 158) snprintf(buf, sizeof(buf), "unknown error code %d", err); f6f05f35 159) return buf; f6f05f35 163) int reftable_error_to_errno(int err) f6f05f35 165) switch (err) { f6f05f35 167) return EIO; f6f05f35 169) return EFAULT; f6f05f35 171) return ENOENT; f6f05f35 173) return EBUSY; f6f05f35 175) return EINVAL; f6f05f35 177) return EDOM; f6f05f35 179) return ERANGE; f6f05f35 209) void reftable_set_alloc(void *(*malloc)(size_t), f6f05f35 212) reftable_malloc_ptr = malloc; f6f05f35 213) reftable_realloc_ptr = realloc; f6f05f35 214) reftable_free_ptr = free; f6f05f35 215) } reftable/block.c f6f05f35 27) abort(); f6f05f35 36) return 72; f6f05f35 38) abort(); f6f05f35 85) goto err; f6f05f35 91) goto err; f6f05f35 97) goto err; f6f05f35 104) slice_clear(&key); f6f05f35 113) restart = false; f6f05f35 120) return -1; f6f05f35 169) slice_clear(&compressed); f6f05f35 170) return REFTABLE_ZLIB_ERROR; f6f05f35 197) return REFTABLE_FORMAT_ERROR; f6f05f35 219) slice_clear(&uncompressed); f6f05f35 220) return REFTABLE_ZLIB_ERROR; f6f05f35 224) return REFTABLE_FORMAT_ERROR; f6f05f35 234) full_block_size = sz; f6f05f35 299) a->error = 1; f6f05f35 300) return -1; f6f05f35 333) return -1; f6f05f35 339) return -1; f6f05f35 350) int block_reader_first_key(struct block_reader *br, struct slice *key) f6f05f35 352) struct slice empty = { 0 }; f6f05f35 353) int off = br->header_off + 4; f6f05f35 354) struct slice in = { f6f05f35 355) .buf = br->block.data + off, f6f05f35 356) .len = br->block_len - off, f6f05f35 359) byte extra = 0; f6f05f35 360) int n = decode_key(key, &extra, empty, in); f6f05f35 361) if (n < 0) { f6f05f35 362) return n; f6f05f35 364) return 0; f6f05f35 387) return -1; f6f05f35 409) result = -1; f6f05f35 410) goto exit; reftable/file.c f6f05f35 51) return -1; f6f05f35 71) if (errno == ENOENT) { f6f05f35 72) return REFTABLE_NOT_EXIST_ERROR; f6f05f35 74) return -1; f6f05f35 79) return -1; reftable/iter.c f6f05f35 75) static void filtering_ref_iterator_close(void *iter_arg) f6f05f35 77) struct filtering_ref_iterator *fri = f6f05f35 79) slice_clear(&fri->oid); f6f05f35 80) reftable_iterator_destroy(&fri->it); f6f05f35 81) } f6f05f35 83) static int filtering_ref_iterator_next(void *iter_arg, struct record rec) f6f05f35 85) struct filtering_ref_iterator *fri = f6f05f35 87) struct reftable_ref_record *ref = f6f05f35 89) int err = 0; f6f05f35 91) err = reftable_iterator_next_ref(fri->it, ref); f6f05f35 92) if (err != 0) { f6f05f35 93) break; f6f05f35 96) if (fri->double_check) { f6f05f35 97) struct reftable_iterator it = { 0 }; f6f05f35 99) err = reftable_reader_seek_ref(fri->r, &it, f6f05f35 100) ref->ref_name); f6f05f35 101) if (err == 0) { f6f05f35 102) err = reftable_iterator_next_ref(it, ref); f6f05f35 105) reftable_iterator_destroy(&it); f6f05f35 107) if (err < 0) { f6f05f35 108) break; f6f05f35 111) if (err > 0) { f6f05f35 112) continue; f6f05f35 116) if ((ref->target_value != NULL && f6f05f35 117) !memcmp(fri->oid.buf, ref->target_value, fri->oid.len)) || f6f05f35 118) (ref->value != NULL && f6f05f35 119) !memcmp(fri->oid.buf, ref->value, fri->oid.len))) { f6f05f35 120) return 0; f6f05f35 122) } f6f05f35 124) reftable_ref_record_clear(ref); f6f05f35 125) return err; f6f05f35 133) void iterator_from_filtering_ref_iterator(struct reftable_iterator *it, f6f05f35 136) assert(it->ops == NULL); f6f05f35 137) it->iter_arg = fri; f6f05f35 138) it->ops = &filtering_ref_iterator_vtable; f6f05f35 139) } f6f05f35 141) static void indexed_table_ref_iter_close(void *p) f6f05f35 143) struct indexed_table_ref_iter *it = (struct indexed_table_ref_iter *)p; f6f05f35 144) block_iter_close(&it->cur); f6f05f35 145) reader_return_block(it->r, &it->block_reader.block); f6f05f35 146) slice_clear(&it->oid); f6f05f35 147) } f6f05f35 149) static int indexed_table_ref_iter_next_block(struct indexed_table_ref_iter *it) f6f05f35 151) if (it->offset_idx == it->offset_len) { f6f05f35 152) it->finished = true; f6f05f35 153) return 1; f6f05f35 156) reader_return_block(it->r, &it->block_reader.block); f6f05f35 159) uint64_t off = it->offsets[it->offset_idx++]; f6f05f35 160) int err = reader_init_block_reader(it->r, &it->block_reader, f6f05f35 162) if (err < 0) { f6f05f35 163) return err; f6f05f35 165) if (err > 0) { f6f05f35 167) return REFTABLE_FORMAT_ERROR; f6f05f35 170) block_reader_start(&it->block_reader, &it->cur); f6f05f35 171) return 0; f6f05f35 174) static int indexed_table_ref_iter_next(void *p, struct record rec) f6f05f35 176) struct indexed_table_ref_iter *it = (struct indexed_table_ref_iter *)p; f6f05f35 177) struct reftable_ref_record *ref = f6f05f35 181) int err = block_iter_next(&it->cur, rec); f6f05f35 182) if (err < 0) { f6f05f35 183) return err; f6f05f35 186) if (err > 0) { f6f05f35 187) err = indexed_table_ref_iter_next_block(it); f6f05f35 188) if (err < 0) { f6f05f35 189) return err; f6f05f35 192) if (it->finished) { f6f05f35 193) return 1; f6f05f35 195) continue; f6f05f35 198) if (!memcmp(it->oid.buf, ref->target_value, it->oid.len) || f6f05f35 199) !memcmp(it->oid.buf, ref->value, it->oid.len)) { f6f05f35 200) return 0; f6f05f35 202) } f6f05f35 205) int new_indexed_table_ref_iter(struct indexed_table_ref_iter **dest, f6f05f35 209) struct indexed_table_ref_iter *itr = f6f05f35 211) int err = 0; f6f05f35 213) itr->r = r; f6f05f35 214) slice_resize(&itr->oid, oid_len); f6f05f35 215) memcpy(itr->oid.buf, oid, oid_len); f6f05f35 217) itr->offsets = offsets; f6f05f35 218) itr->offset_len = offset_len; f6f05f35 220) err = indexed_table_ref_iter_next_block(itr); f6f05f35 221) if (err < 0) { f6f05f35 222) reftable_free(itr); f6f05f35 224) *dest = itr; f6f05f35 226) return err; f6f05f35 234) void iterator_from_indexed_table_ref_iter(struct reftable_iterator *it, f6f05f35 237) assert(it->ops == NULL); f6f05f35 238) it->iter_arg = itr; f6f05f35 239) it->ops = &indexed_table_ref_iter_vtable; f6f05f35 240) } reftable/merged.c f6f05f35 25) return err; f6f05f35 57) return 0; f6f05f35 95) return err; f6f05f35 124) return err; f6f05f35 183) return REFTABLE_FORMAT_ERROR; f6f05f35 186) return REFTABLE_FORMAT_ERROR; f6f05f35 210) void reftable_merged_table_close(struct reftable_merged_table *mt) f6f05f35 212) int i = 0; f6f05f35 213) for (i = 0; i < mt->stack_len; i++) { f6f05f35 214) reftable_reader_free(mt->stack[i]); f6f05f35 216) FREE_AND_NULL(mt->stack); f6f05f35 217) mt->stack_len = 0; f6f05f35 218) } f6f05f35 230) return; f6f05f35 237) reftable_merged_table_max_update_index(struct reftable_merged_table *mt) f6f05f35 239) return mt->max; f6f05f35 243) reftable_merged_table_min_update_index(struct reftable_merged_table *mt) f6f05f35 245) return mt->min; f6f05f35 265) err = e; f6f05f35 272) int i = 0; f6f05f35 273) for (i = 0; i < n; i++) { f6f05f35 274) reftable_iterator_destroy(&iters[i]); f6f05f35 276) reftable_free(iters); f6f05f35 277) return err; f6f05f35 283) merged_iter_close(&merged); f6f05f35 284) return err; reftable/pq.c f6f05f35 43) void merged_iter_pqueue_check(struct merged_iter_pqueue pq) f6f05f35 45) int i = 0; f6f05f35 46) for (i = 1; i < pq.len; i++) { f6f05f35 47) int parent = (i - 1) / 2; f6f05f35 49) assert(pq_less(pq.heap[parent], pq.heap[i])); f6f05f35 51) } reftable/reader.c f6f05f35 63) return &r->obj_offsets; f6f05f35 65) abort(); f6f05f35 73) return 0; f6f05f35 88) uint32_t reftable_reader_hash_id(struct reftable_reader *r) f6f05f35 90) return r->hash_id; f6f05f35 103) err = REFTABLE_FORMAT_ERROR; f6f05f35 104) goto exit; f6f05f35 109) err = REFTABLE_FORMAT_ERROR; f6f05f35 110) goto exit; f6f05f35 125) r->hash_id = get_be32(f); f6f05f35 126) switch (r->hash_id) { f6f05f35 128) break; f6f05f35 130) break; f6f05f35 132) err = REFTABLE_FORMAT_ERROR; f6f05f35 133) goto exit; f6f05f35 135) f += 4; f6f05f35 159) err = REFTABLE_FORMAT_ERROR; f6f05f35 160) goto exit; f6f05f35 189) err = REFTABLE_IO_ERROR; f6f05f35 190) goto exit; f6f05f35 194) err = REFTABLE_FORMAT_ERROR; f6f05f35 195) goto exit; f6f05f35 199) err = REFTABLE_FORMAT_ERROR; f6f05f35 200) goto exit; f6f05f35 211) err = REFTABLE_IO_ERROR; f6f05f35 212) goto exit; f6f05f35 230) static void table_iter_copy_from(struct table_iter *dest, f6f05f35 233) dest->r = src->r; f6f05f35 234) dest->typ = src->typ; f6f05f35 235) dest->block_off = src->block_off; f6f05f35 236) dest->finished = src->finished; f6f05f35 237) block_iter_copy_from(&dest->bi, &src->bi); f6f05f35 238) } f6f05f35 296) return err; f6f05f35 302) return block_size; f6f05f35 311) reader_return_block(r, &block); f6f05f35 312) err = reader_get_block(r, &block, next_off, block_size); f6f05f35 313) if (err < 0) { f6f05f35 314) return err; f6f05f35 338) if (err != 0) { f6f05f35 339) return err; f6f05f35 343) struct block_reader *brp = f6f05f35 345) *brp = br; f6f05f35 347) dest->finished = false; f6f05f35 348) block_reader_start(brp, &dest->bi); f6f05f35 356) return REFTABLE_API_ERROR; f6f05f35 379) table_iter_copy_from(ti, &next); f6f05f35 380) block_iter_close(&next.bi); f6f05f35 381) } f6f05f35 417) return err; f6f05f35 435) off = offs->index_offset; f6f05f35 436) if (off == 0) { f6f05f35 437) return 1; f6f05f35 439) typ = BLOCK_TYPE_INDEX; f6f05f35 458) goto exit; f6f05f35 465) err = block_reader_first_key(next.bi.br, &got_key); f6f05f35 466) if (err < 0) { f6f05f35 467) goto exit; f6f05f35 470) int cmp = slice_compare(got_key, want_key); f6f05f35 471) if (cmp > 0) { f6f05f35 472) table_iter_block_done(&next); f6f05f35 473) break; f6f05f35 477) table_iter_block_done(ti); f6f05f35 478) table_iter_copy_from(ti, &next); f6f05f35 479) } f6f05f35 483) goto exit; f6f05f35 495) static int reader_seek_indexed(struct reftable_reader *r, f6f05f35 498) struct index_record want_index = { 0 }; f6f05f35 499) struct record want_index_rec = { 0 }; f6f05f35 500) struct index_record index_result = { 0 }; f6f05f35 501) struct record index_result_rec = { 0 }; f6f05f35 502) struct table_iter index_iter = { 0 }; f6f05f35 503) struct table_iter next = { 0 }; f6f05f35 504) int err = 0; f6f05f35 506) record_key(rec, &want_index.last_key); f6f05f35 507) record_from_index(&want_index_rec, &want_index); f6f05f35 508) record_from_index(&index_result_rec, &index_result); f6f05f35 510) err = reader_start(r, &index_iter, record_type(rec), true); f6f05f35 511) if (err < 0) { f6f05f35 512) goto exit; f6f05f35 515) err = reader_seek_linear(r, &index_iter, want_index_rec); f6f05f35 517) err = table_iter_next(&index_iter, index_result_rec); f6f05f35 518) table_iter_block_done(&index_iter); f6f05f35 519) if (err != 0) { f6f05f35 520) goto exit; f6f05f35 523) err = reader_table_iter_at(r, &next, index_result.offset, 0); f6f05f35 524) if (err != 0) { f6f05f35 525) goto exit; f6f05f35 528) err = block_iter_seek(&next.bi, want_index.last_key); f6f05f35 529) if (err < 0) { f6f05f35 530) goto exit; f6f05f35 533) if (next.typ == record_type(rec)) { f6f05f35 534) err = 0; f6f05f35 535) break; f6f05f35 538) if (next.typ != BLOCK_TYPE_INDEX) { f6f05f35 539) err = REFTABLE_FORMAT_ERROR; f6f05f35 540) break; f6f05f35 543) table_iter_copy_from(&index_iter, &next); f6f05f35 544) } f6f05f35 546) if (err == 0) { f6f05f35 547) struct table_iter *malloced = f6f05f35 549) table_iter_copy_from(malloced, &next); f6f05f35 550) iterator_from_table_iter(it, malloced); f6f05f35 553) block_iter_close(&next.bi); f6f05f35 554) table_iter_close(&index_iter); f6f05f35 555) record_clear(want_index_rec); f6f05f35 556) record_clear(index_result_rec); f6f05f35 557) return err; f6f05f35 569) return reader_seek_indexed(r, it, rec); f6f05f35 574) return err; f6f05f35 578) return err; f6f05f35 616) int reftable_reader_seek_log_at(struct reftable_reader *r, f6f05f35 620) struct reftable_log_record log = { f6f05f35 624) struct record rec = { 0 }; f6f05f35 625) record_from_log(&rec, &log); f6f05f35 626) return reader_seek(r, it, rec); f6f05f35 629) int reftable_reader_seek_log(struct reftable_reader *r, f6f05f35 632) uint64_t max = ~((uint64_t)0); f6f05f35 633) return reftable_reader_seek_log_at(r, it, name, max); f6f05f35 651) block_source_close(&src); f6f05f35 652) reftable_free(rd); f6f05f35 663) static int reftable_reader_refs_for_indexed(struct reftable_reader *r, f6f05f35 667) struct obj_record want = { f6f05f35 669) .hash_prefix_len = r->object_id_len, f6f05f35 671) struct record want_rec = { 0 }; f6f05f35 672) struct reftable_iterator oit = { 0 }; f6f05f35 673) struct obj_record got = { 0 }; f6f05f35 674) struct record got_rec = { 0 }; f6f05f35 675) int err = 0; f6f05f35 678) record_from_obj(&want_rec, &want); f6f05f35 679) err = reader_seek(r, &oit, want_rec); f6f05f35 680) if (err != 0) { f6f05f35 681) goto exit; f6f05f35 685) record_from_obj(&got_rec, &got); f6f05f35 686) err = iterator_next(oit, got_rec); f6f05f35 687) if (err < 0) { f6f05f35 688) goto exit; f6f05f35 691) if (err > 0 || f6f05f35 692) memcmp(want.hash_prefix, got.hash_prefix, r->object_id_len)) { f6f05f35 694) iterator_set_empty(it); f6f05f35 695) err = 0; f6f05f35 696) goto exit; f6f05f35 700) struct indexed_table_ref_iter *itr = NULL; f6f05f35 701) err = new_indexed_table_ref_iter(&itr, r, oid, f6f05f35 704) if (err < 0) { f6f05f35 705) goto exit; f6f05f35 707) got.offsets = NULL; f6f05f35 708) iterator_from_indexed_table_ref_iter(it, itr); f6f05f35 712) reftable_iterator_destroy(&oit); f6f05f35 713) record_clear(got_rec); f6f05f35 714) return err; f6f05f35 717) static int reftable_reader_refs_for_unindexed(struct reftable_reader *r, f6f05f35 721) struct table_iter *ti = reftable_calloc(sizeof(struct table_iter)); f6f05f35 722) struct filtering_ref_iterator *filter = NULL; f6f05f35 723) int err = reader_start(r, ti, BLOCK_TYPE_REF, false); f6f05f35 724) if (err < 0) { f6f05f35 725) reftable_free(ti); f6f05f35 726) return err; f6f05f35 729) filter = reftable_calloc(sizeof(struct filtering_ref_iterator)); f6f05f35 730) slice_resize(&filter->oid, oid_len); f6f05f35 731) memcpy(filter->oid.buf, oid, oid_len); f6f05f35 732) filter->r = r; f6f05f35 733) filter->double_check = false; f6f05f35 734) iterator_from_table_iter(&filter->it, ti); f6f05f35 736) iterator_from_filtering_ref_iterator(it, filter); f6f05f35 737) return 0; f6f05f35 740) int reftable_reader_refs_for(struct reftable_reader *r, f6f05f35 744) if (r->obj_offsets.present) { f6f05f35 745) return reftable_reader_refs_for_indexed(r, it, oid); f6f05f35 747) return reftable_reader_refs_for_unindexed(r, it, oid, oid_len); reftable/record.c f6f05f35 24) return -1; f6f05f35 31) return -1; f6f05f35 59) return -1; f6f05f35 75) return false; f6f05f35 84) return -1; f6f05f35 88) return -1; f6f05f35 105) return -1; f6f05f35 109) return -1; f6f05f35 125) return -1; f6f05f35 133) return -1; f6f05f35 138) return -1; f6f05f35 154) return -1; f6f05f35 159) return -1; f6f05f35 164) return -1; f6f05f35 172) return -1; f6f05f35 221) static char hexdigit(int c) f6f05f35 223) if (c <= 9) { f6f05f35 224) return '0' + c; f6f05f35 226) return 'a' + (c - 10); f6f05f35 229) static void hex_format(char *dest, byte *src, int hash_size) f6f05f35 231) assert(hash_size > 0); f6f05f35 232) if (src != NULL) { f6f05f35 233) int i = 0; f6f05f35 234) for (i = 0; i < hash_size; i++) { f6f05f35 235) dest[2 * i] = hexdigit(src[i] >> 4); f6f05f35 236) dest[2 * i + 1] = hexdigit(src[i] & 0xf); f6f05f35 238) dest[2 * hash_size] = 0; f6f05f35 240) } f6f05f35 242) void reftable_ref_record_print(struct reftable_ref_record *ref, f6f05f35 245) char hex[SHA256_SIZE + 1] = { 0 }; f6f05f35 246) printf("ref{%s(%" PRIu64 ") ", ref->ref_name, ref->update_index); f6f05f35 247) if (ref->value != NULL) { f6f05f35 248) hex_format(hex, ref->value, hash_size(hash_id)); f6f05f35 249) printf("%s", hex); f6f05f35 251) if (ref->target_value != NULL) { f6f05f35 252) hex_format(hex, ref->target_value, hash_size(hash_id)); f6f05f35 253) printf(" (T %s)", hex); f6f05f35 255) if (ref->target != NULL) { f6f05f35 256) printf("=> %s", ref->target); f6f05f35 258) printf("}\n"); f6f05f35 259) } f6f05f35 300) return -1; f6f05f35 306) return -1; f6f05f35 314) return -1; f6f05f35 323) return -1; f6f05f35 343) return n; f6f05f35 357) return -1; f6f05f35 380) return -1; f6f05f35 390) abort(); f6f05f35 398) FREE_AND_NULL(r->target_value); f6f05f35 401) FREE_AND_NULL(r->value); f6f05f35 424) static void obj_record_key(const void *r, struct slice *dest) f6f05f35 426) const struct obj_record *rec = (const struct obj_record *)r; f6f05f35 427) slice_resize(dest, rec->hash_prefix_len); f6f05f35 428) memcpy(dest->buf, rec->hash_prefix, rec->hash_prefix_len); f6f05f35 429) } f6f05f35 431) static void obj_record_copy_from(void *rec, const void *src_rec, int hash_size) f6f05f35 433) struct obj_record *ref = (struct obj_record *)rec; f6f05f35 434) const struct obj_record *src = (const struct obj_record *)src_rec; f6f05f35 436) *ref = *src; f6f05f35 437) ref->hash_prefix = reftable_malloc(ref->hash_prefix_len); f6f05f35 438) memcpy(ref->hash_prefix, src->hash_prefix, ref->hash_prefix_len); f6f05f35 441) int olen = ref->offset_len * sizeof(uint64_t); f6f05f35 442) ref->offsets = reftable_malloc(olen); f6f05f35 443) memcpy(ref->offsets, src->offsets, olen); f6f05f35 445) } f6f05f35 447) static void obj_record_clear(void *rec) f6f05f35 449) struct obj_record *ref = (struct obj_record *)rec; f6f05f35 450) FREE_AND_NULL(ref->hash_prefix); f6f05f35 451) FREE_AND_NULL(ref->offsets); f6f05f35 452) memset(ref, 0, sizeof(struct obj_record)); f6f05f35 453) } f6f05f35 455) static byte obj_record_val_type(const void *rec) f6f05f35 457) struct obj_record *r = (struct obj_record *)rec; f6f05f35 458) if (r->offset_len > 0 && r->offset_len < 8) { f6f05f35 459) return r->offset_len; f6f05f35 461) return 0; f6f05f35 464) static int obj_record_encode(const void *rec, struct slice s, int hash_size) f6f05f35 466) struct obj_record *r = (struct obj_record *)rec; f6f05f35 467) struct slice start = s; f6f05f35 468) int n = 0; f6f05f35 469) if (r->offset_len == 0 || r->offset_len >= 8) { f6f05f35 470) n = put_var_int(s, r->offset_len); f6f05f35 471) if (n < 0) { f6f05f35 472) return -1; f6f05f35 474) slice_consume(&s, n); f6f05f35 476) if (r->offset_len == 0) { f6f05f35 477) return start.len - s.len; f6f05f35 479) n = put_var_int(s, r->offsets[0]); f6f05f35 480) if (n < 0) { f6f05f35 481) return -1; f6f05f35 483) slice_consume(&s, n); f6f05f35 486) uint64_t last = r->offsets[0]; f6f05f35 487) int i = 0; f6f05f35 488) for (i = 1; i < r->offset_len; i++) { f6f05f35 489) int n = put_var_int(s, r->offsets[i] - last); f6f05f35 490) if (n < 0) { f6f05f35 491) return -1; f6f05f35 493) slice_consume(&s, n); f6f05f35 494) last = r->offsets[i]; f6f05f35 497) return start.len - s.len; f6f05f35 500) static int obj_record_decode(void *rec, struct slice key, byte val_type, f6f05f35 503) struct slice start = in; f6f05f35 504) struct obj_record *r = (struct obj_record *)rec; f6f05f35 505) uint64_t count = val_type; f6f05f35 506) int n = 0; f6f05f35 507) r->hash_prefix = reftable_malloc(key.len); f6f05f35 508) memcpy(r->hash_prefix, key.buf, key.len); f6f05f35 509) r->hash_prefix_len = key.len; f6f05f35 511) if (val_type == 0) { f6f05f35 512) n = get_var_int(&count, in); f6f05f35 513) if (n < 0) { f6f05f35 514) return n; f6f05f35 517) slice_consume(&in, n); f6f05f35 520) r->offsets = NULL; f6f05f35 521) r->offset_len = 0; f6f05f35 522) if (count == 0) { f6f05f35 523) return start.len - in.len; f6f05f35 526) r->offsets = reftable_malloc(count * sizeof(uint64_t)); f6f05f35 527) r->offset_len = count; f6f05f35 529) n = get_var_int(&r->offsets[0], in); f6f05f35 530) if (n < 0) { f6f05f35 531) return n; f6f05f35 533) slice_consume(&in, n); f6f05f35 536) uint64_t last = r->offsets[0]; f6f05f35 537) int j = 1; f6f05f35 538) while (j < count) { f6f05f35 539) uint64_t delta = 0; f6f05f35 540) int n = get_var_int(&delta, in); f6f05f35 541) if (n < 0) { f6f05f35 542) return n; f6f05f35 544) slice_consume(&in, n); f6f05f35 546) last = r->offsets[j] = (delta + last); f6f05f35 547) j++; f6f05f35 550) return start.len - in.len; f6f05f35 553) static bool not_a_deletion(const void *p) f6f05f35 555) return false; f6f05f35 569) void reftable_log_record_print(struct reftable_log_record *log, f6f05f35 572) char hex[SHA256_SIZE + 1] = { 0 }; f6f05f35 574) printf("log{%s(%" PRIu64 ") %s <%s> %" PRIu64 " %04d\n", log->ref_name, f6f05f35 576) log->tz_offset); f6f05f35 577) hex_format(hex, log->old_hash, hash_size(hash_id)); f6f05f35 578) printf("%s => ", hex); f6f05f35 579) hex_format(hex, log->new_hash, hash_size(hash_id)); f6f05f35 580) printf("%s\n\n%s\n}\n", hex, log->message); f6f05f35 581) } f6f05f35 666) oldh = zero; f6f05f35 669) newh = zero; f6f05f35 673) return -1; f6f05f35 682) return -1; f6f05f35 688) return -1; f6f05f35 694) return -1; f6f05f35 699) return -1; f6f05f35 707) return -1; f6f05f35 726) return REFTABLE_FORMAT_ERROR; f6f05f35 740) return REFTABLE_FORMAT_ERROR; f6f05f35 753) goto error; f6f05f35 764) goto error; f6f05f35 775) goto error; f6f05f35 780) goto error; f6f05f35 789) goto error; f6f05f35 801) slice_clear(&dest); f6f05f35 805) static bool null_streq(char *a, char *b) f6f05f35 807) char *empty = ""; f6f05f35 808) if (a == NULL) { f6f05f35 809) a = empty; f6f05f35 811) if (b == NULL) { f6f05f35 812) b = empty; f6f05f35 814) return 0 == strcmp(a, b); f6f05f35 817) static bool zero_hash_eq(byte *a, byte *b, int sz) f6f05f35 819) if (a == NULL) { f6f05f35 820) a = zero; f6f05f35 822) if (b == NULL) { f6f05f35 823) b = zero; f6f05f35 825) return !memcmp(a, b, sz); f6f05f35 828) bool reftable_log_record_equal(struct reftable_log_record *a, f6f05f35 831) return null_streq(a->name, b->name) && null_streq(a->email, b->email) && f6f05f35 832) null_streq(a->message, b->message) && f6f05f35 833) zero_hash_eq(a->old_hash, b->old_hash, hash_size) && f6f05f35 834) zero_hash_eq(a->new_hash, b->new_hash, hash_size) && f6f05f35 835) a->time == b->time && a->tz_offset == b->tz_offset && f6f05f35 836) a->update_index == b->update_index; f6f05f35 868) struct obj_record *r = f6f05f35 870) record_from_obj(&rec, r); f6f05f35 871) return rec; f6f05f35 880) struct index_record *r = f6f05f35 882) record_from_index(&rec, r); f6f05f35 883) return rec; f6f05f35 903) static void index_record_key(const void *r, struct slice *dest) f6f05f35 905) struct index_record *rec = (struct index_record *)r; f6f05f35 906) slice_copy(dest, rec->last_key); f6f05f35 907) } f6f05f35 909) static void index_record_copy_from(void *rec, const void *src_rec, f6f05f35 912) struct index_record *dst = (struct index_record *)rec; f6f05f35 913) struct index_record *src = (struct index_record *)src_rec; f6f05f35 915) slice_copy(&dst->last_key, src->last_key); f6f05f35 916) dst->offset = src->offset; f6f05f35 917) } f6f05f35 919) static void index_record_clear(void *rec) f6f05f35 921) struct index_record *idx = (struct index_record *)rec; f6f05f35 922) slice_clear(&idx->last_key); f6f05f35 923) } f6f05f35 925) static byte index_record_val_type(const void *rec) f6f05f35 927) return 0; f6f05f35 930) static int index_record_encode(const void *rec, struct slice out, int hash_size) f6f05f35 932) const struct index_record *r = (const struct index_record *)rec; f6f05f35 933) struct slice start = out; f6f05f35 935) int n = put_var_int(out, r->offset); f6f05f35 936) if (n < 0) { f6f05f35 937) return n; f6f05f35 940) slice_consume(&out, n); f6f05f35 942) return start.len - out.len; f6f05f35 945) static int index_record_decode(void *rec, struct slice key, byte val_type, f6f05f35 948) struct slice start = in; f6f05f35 949) struct index_record *r = (struct index_record *)rec; f6f05f35 950) int n = 0; f6f05f35 952) slice_copy(&r->last_key, key); f6f05f35 954) n = get_var_int(&r->offset, in); f6f05f35 955) if (n < 0) { f6f05f35 956) return n; f6f05f35 959) slice_consume(&in, n); f6f05f35 960) return start.len - in.len; f6f05f35 1024) void record_from_obj(struct record *rec, struct obj_record *obj_rec) f6f05f35 1026) assert(rec->ops == NULL); f6f05f35 1027) rec->data = obj_rec; f6f05f35 1028) rec->ops = &obj_record_vtable; f6f05f35 1029) } f6f05f35 1031) void record_from_index(struct record *rec, struct index_record *index_rec) f6f05f35 1033) assert(rec->ops == NULL); f6f05f35 1034) rec->data = index_rec; f6f05f35 1035) rec->ops = &index_record_vtable; f6f05f35 1036) } f6f05f35 1045) struct reftable_ref_record *record_as_ref(struct record rec) f6f05f35 1047) assert(record_type(rec) == BLOCK_TYPE_REF); f6f05f35 1048) return (struct reftable_ref_record *)rec.data; f6f05f35 1051) struct reftable_log_record *record_as_log(struct record rec) f6f05f35 1053) assert(record_type(rec) == BLOCK_TYPE_LOG); f6f05f35 1054) return (struct reftable_log_record *)rec.data; f6f05f35 1057) static bool hash_equal(byte *a, byte *b, int hash_size) f6f05f35 1059) if (a != NULL && b != NULL) { f6f05f35 1060) return !memcmp(a, b, hash_size); f6f05f35 1063) return a == b; f6f05f35 1066) static bool str_equal(char *a, char *b) f6f05f35 1068) if (a != NULL && b != NULL) { f6f05f35 1069) return 0 == strcmp(a, b); f6f05f35 1072) return a == b; f6f05f35 1075) bool reftable_ref_record_equal(struct reftable_ref_record *a, f6f05f35 1078) assert(hash_size > 0); f6f05f35 1079) return 0 == strcmp(a->ref_name, b->ref_name) && f6f05f35 1080) a->update_index == b->update_index && f6f05f35 1081) hash_equal(a->value, b->value, hash_size) && f6f05f35 1082) hash_equal(a->target_value, b->target_value, hash_size) && f6f05f35 1083) str_equal(a->target, b->target); f6f05f35 1086) int reftable_ref_record_compare_name(const void *a, const void *b) f6f05f35 1088) return strcmp(((struct reftable_ref_record *)a)->ref_name, f6f05f35 1089) ((struct reftable_ref_record *)b)->ref_name); f6f05f35 1098) int reftable_log_record_compare_key(const void *a, const void *b) f6f05f35 1100) struct reftable_log_record *la = (struct reftable_log_record *)a; f6f05f35 1101) struct reftable_log_record *lb = (struct reftable_log_record *)b; f6f05f35 1103) int cmp = strcmp(la->ref_name, lb->ref_name); f6f05f35 1104) if (cmp) { f6f05f35 1105) return cmp; f6f05f35 1107) if (la->update_index > lb->update_index) { f6f05f35 1108) return -1; f6f05f35 1110) return (la->update_index < lb->update_index) ? 1 : 0; f6f05f35 1128) return SHA256_SIZE; f6f05f35 1130) abort(); reftable/refname.c f6f05f35 44) struct find_arg arg = { f6f05f35 45) .names = mod->del, f6f05f35 48) int idx = binsearch(mod->del_len, find_name, &arg); f6f05f35 49) if (idx < mod->del_len && !strcmp(mod->del[idx], name)) { f6f05f35 50) return 1; f6f05f35 81) !strncmp(prefix, mod->add[idx], strlen(prefix))) { f6f05f35 88) goto exit; f6f05f35 98) struct find_arg arg = { f6f05f35 99) .names = mod->del, f6f05f35 100) .want = ref.ref_name, f6f05f35 102) int idx = binsearch(mod->del_len, find_name, &arg); f6f05f35 103) if (idx < mod->del_len && f6f05f35 104) !strcmp(ref.ref_name, mod->del[idx])) { f6f05f35 105) continue; f6f05f35 113) err = 0; f6f05f35 114) goto exit; f6f05f35 115) } f6f05f35 128) return REFTABLE_REFNAME_ERROR; f6f05f35 134) (next - name == 2 && name[0] == '.' && name[1] == '.')) f6f05f35 135) return REFTABLE_REFNAME_ERROR; f6f05f35 182) goto exit; f6f05f35 190) err = REFTABLE_NAME_CONFLICT; f6f05f35 191) goto exit; f6f05f35 194) goto exit; f6f05f35 207) goto exit; reftable/reftable.c f6f05f35 18) static int reftable_reader_seek_void(void *tab, struct reftable_iterator *it, f6f05f35 21) return reader_seek((struct reftable_reader *)tab, it, rec); f6f05f35 51) void reftable_table_from_reader(struct reftable_table *tab, f6f05f35 54) assert(tab->ops == NULL); f6f05f35 55) tab->ops = &reader_vtable; f6f05f35 56) tab->table_arg = reader; f6f05f35 57) } f6f05f35 73) goto exit; reftable/slice.c f6f05f35 18) s->len = 0; f6f05f35 19) return; f6f05f35 109) bool slice_equal(struct slice a, struct slice b) f6f05f35 111) if (a.len != b.len) { f6f05f35 112) return 0; f6f05f35 114) return memcmp(a.buf, b.buf, a.len) == 0; f6f05f35 133) int slice_write(struct slice *b, byte *data, size_t sz) f6f05f35 135) if (b->len + sz > b->cap) { f6f05f35 136) int newcap = 2 * b->cap + 1; f6f05f35 137) if (newcap < b->len + sz) { f6f05f35 138) newcap = (b->len + sz); f6f05f35 140) b->buf = reftable_realloc(b->buf, newcap); f6f05f35 141) b->cap = newcap; f6f05f35 144) memcpy(b->buf + b->len, data, sz); f6f05f35 145) b->len += sz; f6f05f35 146) return sz; f6f05f35 149) int slice_write_void(void *b, byte *data, size_t sz) f6f05f35 151) return slice_write((struct slice *)b, data, sz); f6f05f35 154) static uint64_t slice_size(void *b) f6f05f35 156) return ((struct slice *)b)->len; f6f05f35 159) static void slice_return_block(void *b, struct reftable_block *dest) f6f05f35 161) memset(dest->data, 0xff, dest->len); f6f05f35 162) reftable_free(dest->data); f6f05f35 163) } f6f05f35 165) static void slice_close(void *b) f6f05f35 167) } f6f05f35 169) static int slice_read_block(void *v, struct reftable_block *dest, uint64_t off, f6f05f35 172) struct slice *b = (struct slice *)v; f6f05f35 173) assert(off + size <= b->len); f6f05f35 174) dest->data = reftable_calloc(size); f6f05f35 175) memcpy(dest->data, b->buf + off, size); f6f05f35 176) dest->len = size; f6f05f35 177) return size; f6f05f35 187) void block_source_from_slice(struct reftable_block_source *bs, f6f05f35 190) assert(bs->ops == NULL); f6f05f35 191) bs->ops = &slice_vtable; f6f05f35 192) bs->arg = buf; f6f05f35 193) } f6f05f35 195) static void malloc_return_block(void *b, struct reftable_block *dest) f6f05f35 197) memset(dest->data, 0xff, dest->len); f6f05f35 198) reftable_free(dest->data); f6f05f35 199) } reftable/stack.c f6f05f35 27) config.hash_id = SHA1_ID; f6f05f35 42) reftable_stack_destroy(p); f6f05f35 55) err = REFTABLE_IO_ERROR; f6f05f35 56) goto exit; f6f05f35 60) err = REFTABLE_IO_ERROR; f6f05f35 61) goto exit; f6f05f35 66) err = REFTABLE_IO_ERROR; f6f05f35 67) goto exit; f6f05f35 88) return REFTABLE_IO_ERROR; f6f05f35 102) void reftable_stack_destroy(struct reftable_stack *st) f6f05f35 104) if (st->merged == NULL) { f6f05f35 105) return; f6f05f35 108) reftable_merged_table_close(st->merged); f6f05f35 109) reftable_merged_table_free(st->merged); f6f05f35 110) st->merged = NULL; f6f05f35 112) FREE_AND_NULL(st->list_file); f6f05f35 113) FREE_AND_NULL(st->reftable_dir); f6f05f35 114) reftable_free(st); f6f05f35 167) goto exit; f6f05f35 183) goto exit; f6f05f35 210) reader_close(new_tables[i]); f6f05f35 219) static int tv_cmp(struct timeval *a, struct timeval *b) f6f05f35 221) time_t diff = a->tv_sec - b->tv_sec; f6f05f35 222) int udiff = a->tv_usec - b->tv_usec; f6f05f35 224) if (diff != 0) { f6f05f35 225) return diff; f6f05f35 228) return udiff; f6f05f35 239) return err; f6f05f35 250) return err; f6f05f35 257) break; f6f05f35 262) free_names(names); f6f05f35 263) return err; f6f05f35 270) if (err != REFTABLE_NOT_EXIST_ERROR) { f6f05f35 271) free_names(names); f6f05f35 272) return err; f6f05f35 279) err2 = read_lines(st->list_file, &names_after); f6f05f35 280) if (err2 < 0) { f6f05f35 281) free_names(names); f6f05f35 282) return err2; f6f05f35 285) if (names_equal(names_after, names)) { f6f05f35 286) free_names(names); f6f05f35 287) free_names(names_after); f6f05f35 288) return err; f6f05f35 290) free_names(names); f6f05f35 291) free_names(names_after); f6f05f35 293) delay = delay + (delay * rand()) / RAND_MAX + 1; f6f05f35 294) sleep_millisec(delay); f6f05f35 295) } f6f05f35 314) return err; f6f05f35 319) err = 1; f6f05f35 320) goto exit; f6f05f35 324) err = 1; f6f05f35 325) goto exit; f6f05f35 330) err = 1; f6f05f35 331) goto exit; f6f05f35 358) return 0; f6f05f35 390) if (errno == EEXIST) { f6f05f35 391) err = REFTABLE_LOCK_ERROR; f6f05f35 393) err = REFTABLE_IO_ERROR; f6f05f35 395) goto exit; f6f05f35 399) goto exit; f6f05f35 403) err = REFTABLE_LOCK_ERROR; f6f05f35 404) goto exit; f6f05f35 410) reftable_addition_close(add); f6f05f35 451) goto exit; f6f05f35 467) err = REFTABLE_IO_ERROR; f6f05f35 468) goto exit; f6f05f35 474) err = REFTABLE_IO_ERROR; f6f05f35 475) goto exit; f6f05f35 481) err = REFTABLE_IO_ERROR; f6f05f35 482) goto exit; f6f05f35 492) int reftable_stack_new_addition(struct reftable_addition **dest, f6f05f35 495) int err = 0; f6f05f35 496) *dest = reftable_malloc(sizeof(**dest)); f6f05f35 497) err = reftable_stack_init_addition(*dest, st); f6f05f35 498) if (err) { f6f05f35 499) reftable_free(*dest); f6f05f35 500) *dest = NULL; f6f05f35 502) return err; f6f05f35 512) goto exit; f6f05f35 548) err = REFTABLE_IO_ERROR; f6f05f35 549) goto exit; f6f05f35 561) err = 0; f6f05f35 562) goto exit; f6f05f35 565) goto exit; f6f05f35 571) err = REFTABLE_IO_ERROR; f6f05f35 572) goto exit; f6f05f35 582) err = REFTABLE_API_ERROR; f6f05f35 583) goto exit; f6f05f35 596) err = REFTABLE_IO_ERROR; f6f05f35 597) goto exit; f6f05f35 655) goto exit; f6f05f35 659) goto exit; f6f05f35 668) close(tab_fd); f6f05f35 669) tab_fd = 0; f6f05f35 672) unlink(slice_as_string(temp_tab)); f6f05f35 673) slice_clear(temp_tab); f6f05f35 707) reftable_free(subtabs); f6f05f35 708) goto exit; f6f05f35 713) goto exit; f6f05f35 723) break; f6f05f35 726) continue; f6f05f35 731) break; f6f05f35 739) goto exit; f6f05f35 749) break; f6f05f35 752) continue; f6f05f35 756) log.time < config->time) { f6f05f35 757) continue; f6f05f35 761) log.update_index < config->min_update_index) { f6f05f35 762) continue; f6f05f35 767) break; f6f05f35 818) if (errno == EEXIST) { f6f05f35 819) err = 1; f6f05f35 821) err = REFTABLE_IO_ERROR; f6f05f35 823) goto exit; f6f05f35 832) goto exit; f6f05f35 852) } else if (sublock_file_fd < 0) { f6f05f35 853) if (errno == EEXIST) { f6f05f35 854) err = 1; f6f05f35 856) err = REFTABLE_IO_ERROR; f6f05f35 867) goto exit; f6f05f35 873) goto exit; f6f05f35 883) err = 0; f6f05f35 886) goto exit; f6f05f35 892) if (errno == EEXIST) { f6f05f35 893) err = 1; f6f05f35 895) err = REFTABLE_IO_ERROR; f6f05f35 897) goto exit; f6f05f35 914) err = REFTABLE_IO_ERROR; f6f05f35 915) goto exit; f6f05f35 929) slice_append_string(&ref_list_contents, f6f05f35 930) st->merged->stack[i]->name); f6f05f35 931) slice_append_string(&ref_list_contents, "\n"); f6f05f35 936) err = REFTABLE_IO_ERROR; f6f05f35 937) unlink(slice_as_string(&new_table_path)); f6f05f35 938) goto exit; f6f05f35 943) err = REFTABLE_IO_ERROR; f6f05f35 944) unlink(slice_as_string(&new_table_path)); f6f05f35 945) goto exit; f6f05f35 950) err = REFTABLE_IO_ERROR; f6f05f35 951) unlink(slice_as_string(&new_table_path)); f6f05f35 952) goto exit; f6f05f35 982) close(lock_file_fd); f6f05f35 983) lock_file_fd = 0; f6f05f35 986) unlink(slice_as_string(&lock_file_name)); f6f05f35 1008) st->stats.failures++; f6f05f35 1022) return 0; f6f05f35 1038) *seglen = 0; f6f05f35 1039) return segs; f6f05f35 1121) reftable_stack_compaction_stats(struct reftable_stack *st) f6f05f35 1123) return &st->stats; f6f05f35 1134) int reftable_stack_read_log(struct reftable_stack *st, const char *refname, f6f05f35 1137) struct reftable_iterator it = { 0 }; f6f05f35 1138) struct reftable_merged_table *mt = reftable_stack_merged_table(st); f6f05f35 1139) int err = reftable_merged_table_seek_log(mt, &it, refname); f6f05f35 1140) if (err) { f6f05f35 1141) goto exit; f6f05f35 1144) err = reftable_iterator_next_log(it, log); f6f05f35 1145) if (err) { f6f05f35 1146) goto exit; f6f05f35 1149) if (strcmp(log->ref_name, refname) || f6f05f35 1150) reftable_log_record_is_deletion(log)) { f6f05f35 1151) err = 1; f6f05f35 1152) goto exit; f6f05f35 1156) if (err) { f6f05f35 1157) reftable_log_record_clear(log); f6f05f35 1159) reftable_iterator_destroy(&it); f6f05f35 1160) return err; f6f05f35 1176) return 0; f6f05f35 1181) goto exit; f6f05f35 1186) goto exit; f6f05f35 1191) err = 0; f6f05f35 1192) goto exit; f6f05f35 1195) goto exit; f6f05f35 1205) goto exit; reftable/tree.c f6f05f35 58) return; reftable/writer.c f6f05f35 26) return &w->stats.obj_stats; f6f05f35 28) return &w->stats.idx_stats; f6f05f35 32) assert(false); f6f05f35 43) byte *zeroed = reftable_calloc(w->pending_padding); f6f05f35 44) int n = w->write(w->write_arg, zeroed, w->pending_padding); f6f05f35 45) if (n < 0) { f6f05f35 46) return n; f6f05f35 49) w->pending_padding = 0; f6f05f35 50) reftable_free(zeroed); f6f05f35 56) return n; f6f05f35 69) opts->hash_id = SHA1_ID; f6f05f35 72) opts->block_size = DEFAULT_BLOCK_SIZE; f6f05f35 91) put_be32(dest + 24, w->opts.hash_id); f6f05f35 119) abort(); f6f05f35 194) goto exit; f6f05f35 209) err = writer_flush_block(w); f6f05f35 210) if (err < 0) { f6f05f35 211) result = err; f6f05f35 212) goto exit; f6f05f35 215) writer_reinit_block_writer(w, record_type(rec)); f6f05f35 216) err = block_writer_add(w->block_writer, rec); f6f05f35 217) if (err < 0) { f6f05f35 218) result = err; f6f05f35 219) goto exit; f6f05f35 222) result = 0; f6f05f35 236) return REFTABLE_API_ERROR; f6f05f35 240) return REFTABLE_API_ERROR; f6f05f35 247) return err; f6f05f35 268) int reftable_writer_add_refs(struct reftable_writer *w, f6f05f35 271) int err = 0; f6f05f35 272) int i = 0; f6f05f35 273) QSORT(refs, n, reftable_ref_record_compare_name); f6f05f35 274) for (i = 0; err == 0 && i < n; i++) { f6f05f35 275) err = reftable_writer_add_ref(w, &refs[i]); f6f05f35 277) return err; f6f05f35 284) return REFTABLE_API_ERROR; f6f05f35 291) return err; f6f05f35 307) int reftable_writer_add_logs(struct reftable_writer *w, f6f05f35 310) int err = 0; f6f05f35 311) int i = 0; f6f05f35 312) QSORT(logs, n, reftable_log_record_compare_key); f6f05f35 313) for (i = 0; err == 0 && i < n; i++) { f6f05f35 314) err = reftable_writer_add_log(w, &logs[i]); f6f05f35 316) return err; f6f05f35 329) return err; f6f05f35 333) struct index_record *idx = NULL; f6f05f35 334) int idx_len = 0; f6f05f35 336) max_level++; f6f05f35 337) index_start = w->next; f6f05f35 338) writer_reinit_block_writer(w, BLOCK_TYPE_INDEX); f6f05f35 340) idx = w->index; f6f05f35 341) idx_len = w->index_len; f6f05f35 343) w->index = NULL; f6f05f35 344) w->index_len = 0; f6f05f35 345) w->index_cap = 0; f6f05f35 346) for (i = 0; i < idx_len; i++) { f6f05f35 347) struct record rec = { 0 }; f6f05f35 348) record_from_index(&rec, idx + i); f6f05f35 349) if (block_writer_add(w->block_writer, rec) == 0) { f6f05f35 350) continue; f6f05f35 354) int err = writer_flush_block(w); f6f05f35 355) if (err < 0) { f6f05f35 356) return err; f6f05f35 360) writer_reinit_block_writer(w, BLOCK_TYPE_INDEX); f6f05f35 362) err = block_writer_add(w->block_writer, rec); f6f05f35 363) assert(err == 0); f6f05f35 365) for (i = 0; i < idx_len; i++) { f6f05f35 366) slice_clear(&idx[i].last_key); f6f05f35 368) reftable_free(idx); f6f05f35 375) return err; f6f05f35 398) static void update_common(void *void_arg, void *key) f6f05f35 400) struct common_prefix_arg *arg = (struct common_prefix_arg *)void_arg; f6f05f35 401) struct obj_index_tree_node *entry = (struct obj_index_tree_node *)key; f6f05f35 402) if (arg->last != NULL) { f6f05f35 403) int n = common_prefix_size(entry->hash, *arg->last); f6f05f35 404) if (n > arg->max) { f6f05f35 405) arg->max = n; f6f05f35 408) arg->last = &entry->hash; f6f05f35 409) } f6f05f35 416) static void write_object_record(void *void_arg, void *key) f6f05f35 418) struct write_record_arg *arg = (struct write_record_arg *)void_arg; f6f05f35 419) struct obj_index_tree_node *entry = (struct obj_index_tree_node *)key; f6f05f35 420) struct obj_record obj_rec = { f6f05f35 421) .hash_prefix = entry->hash.buf, f6f05f35 422) .hash_prefix_len = arg->w->stats.object_id_len, f6f05f35 423) .offsets = entry->offsets, f6f05f35 424) .offset_len = entry->offset_len, f6f05f35 426) struct record rec = { 0 }; f6f05f35 427) if (arg->err < 0) { f6f05f35 428) goto exit; f6f05f35 431) record_from_obj(&rec, &obj_rec); f6f05f35 432) arg->err = block_writer_add(arg->w->block_writer, rec); f6f05f35 433) if (arg->err == 0) { f6f05f35 434) goto exit; f6f05f35 437) arg->err = writer_flush_block(arg->w); f6f05f35 438) if (arg->err < 0) { f6f05f35 439) goto exit; f6f05f35 442) writer_reinit_block_writer(arg->w, BLOCK_TYPE_OBJ); f6f05f35 443) arg->err = block_writer_add(arg->w->block_writer, rec); f6f05f35 444) if (arg->err == 0) { f6f05f35 445) goto exit; f6f05f35 447) obj_rec.offset_len = 0; f6f05f35 448) arg->err = block_writer_add(arg->w->block_writer, rec); f6f05f35 451) assert(arg->err == 0); f6f05f35 454) } f6f05f35 465) static int writer_dump_object_index(struct reftable_writer *w) f6f05f35 467) struct write_record_arg closure = { .w = w }; f6f05f35 468) struct common_prefix_arg common = { 0 }; f6f05f35 469) if (w->obj_index_tree != NULL) { f6f05f35 470) infix_walk(w->obj_index_tree, &update_common, &common); f6f05f35 472) w->stats.object_id_len = common.max + 1; f6f05f35 474) writer_reinit_block_writer(w, BLOCK_TYPE_OBJ); f6f05f35 476) if (w->obj_index_tree != NULL) { f6f05f35 477) infix_walk(w->obj_index_tree, &write_object_record, &closure); f6f05f35 480) if (closure.err < 0) { f6f05f35 481) return closure.err; f6f05f35 483) return writer_finish_section(w); f6f05f35 492) return 0; f6f05f35 498) return err; f6f05f35 502) err = writer_dump_object_index(w); f6f05f35 503) if (err < 0) { f6f05f35 504) return err; f6f05f35 525) goto exit; f6f05f35 531) int n = writer_write_header(w, header); f6f05f35 532) err = padded_write(w, header, n, 0); f6f05f35 533) if (err < 0) { f6f05f35 534) goto exit; f6f05f35 556) goto exit; f6f05f35 560) err = REFTABLE_EMPTY_TABLE_ERROR; f6f05f35 561) goto exit; f6f05f35 596) return raw_bytes; f6f05f35 613) fprintf(stderr, "block %c off %" PRIu64 " sz %d (%d)\n", typ, f6f05f35 615) get_be24(w->block + w->block_writer->header_off + 1)); f6f05f35 624) return err; f6f05f35 658) const struct reftable_stats *writer_stats(struct reftable_writer *w) f6f05f35 660) return &w->stats; reftable/zlib-compat.c f6f05f35 53) left = 1; f6f05f35 54) dest = buf; f6f05f35 84) else if (stream.total_out && err == Z_BUF_ERROR) f6f05f35 85) left = 1; f6f05f35 89) err == Z_NEED_DICT ? Z_DATA_ERROR : f6f05f35 90) err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR : send-pack.c 1b722303 183) if (new_options) { 1b722303 185) new_options = 0; 1b722303 187) ret = -1; 1b722303 188) continue; 1b722303 228) ret = -1; 1b722303 229) break; 1b722303 243) hint->status != REF_STATUS_OK && 1b722303 244) hint->status != REF_STATUS_REMOTE_REJECT) { sequencer.c 30b22821 893) return NULL; 66f46e74 1395) goto out; 66f46e74 1399) goto out; 30b22821 1475) res = -1; 30b22821 1476) goto out; t/helper/test-proc-receive.c ad8697b0 134) usage_msg_opt("Too many arguments.", proc_receive_usage, options); transport-helper.c 1b722303 833) hint = NULL; 1b722303 852) (*ref)->report.message = msg; Commits introducing uncovered code: Derrick Stolee 78a1541e line-log: integrate with changed-path Bloom filters Han-Wen Nienhuys e0271b93 Reftable support for git-core Han-Wen Nienhuys f6f05f35 Add reftable library Jiang Xin 7e70e854 receive-pack: new config receive.procReceiveRefs Jiang Xin ad8697b0 receive-pack: add new proc-receive hook Jiang Xin 1b722303 New capability "report-status-v2" for git-push Miriam Rubio 9aadf776 bisect--helper: introduce new `write_in_file()` function Miriam Rubio 36b543b5 bisect--helper: fix `cmd_*()` function switch default return Phillip Wood 30b22821 rebase -i: support --ignore-date Phillip Wood 66f46e74 rebase -i: support --committer-date-is-author-date Pranit Bauva 587c9fac bisect--helper: reimplement `bisect_next` and `bisect_auto_next` shell functions in C Pranit Bauva f0bf9482 bisect--helper: finish porting `bisect_start()` to C Pranit Bauva 05a69202 bisect--helper: reimplement `bisect_autostart` shell function in C Pranit Bauva 10520dbf bisect--helper: reimplement `bisect_state` & `bisect_head` shell functions in C Shawn O. Pearce 38a81b4e receive-pack: Wrap status reports inside side-band-64k Taylor Blau 199d758e builtin/commit-graph.c: dereference tags in builtin Uncovered code in 'jch' not in 'next' -------------------------------------------------------- commit-graph.c fbda77c6 296) goto free_and_return; fbda77c6 363) goto free_and_return; pack-bitmap.c remote.c 812a5889 1638) return NULL; 812a5889 1645) return branch->refname; 812a5889 1660) return NULL; 812a5889 1774) return NULL; Commits introducing uncovered code: Damien Robert 812a5889 remote.c: fix handling of %(push:remoteref) Jonathan Tan fbda77c6 commit-graph: avoid memory leaks Uncovered code in 'next' not in 'master' -------------------------------------------------------- Commits introducing uncovered code: Uncovered code in 'master' not in 'master@{1}' -------------------------------------------------------- blame.c 0906ac2b 1281) return 1; 0906ac2b 1302) bd->alloc *= 2; 0906ac2b 1303) REALLOC_ARRAY(bd->keys, bd->alloc); 0906ac2b 2899) return; bloom.c ed591feb 172) return NULL; ed591feb 246) for (i = 0; i < diff_queued_diff.nr; i++) ed591feb 247) diff_free_filepair(diff_queued_diff.queue[i]); ed591feb 248) filter->data = NULL; ed591feb 249) filter->len = 0; a56b9464 266) return -1; bugreport.c 1411914a 18) strbuf_addf(sys_info, _("uname() failed with error '%s' (%d)\n"), 1411914a 20) errno); builtin/commit-graph.c builtin/help.c 709df95b 123) puts(var); 709df95b 124) continue; builtin/rebase.c efcf6cf0 625) } else if (!read_oneliner(&buf, state_dir_path("head", opts), f213f069 880) reset_head(the_repository, &opts->orig_head, "checkout", f213f069 881) opts->head_name, 0, 86ed00af 1041) apply_autostash(state_dir_path("autostash", opts)); builtin/receive-pack.c 37b9dcab 896) rollback_shallow_file(the_repository, &shallow_lock); builtin/update-ref.c a65b8ac2 419) continue; commit-graph.c d21ee7d1 76) return; /* should never happen, but be lenient */ d21ee7d1 81) static int commit_pos_cmp(const void *va, const void *vb) d21ee7d1 83) const struct commit *a = *(const struct commit **)va; d21ee7d1 84) const struct commit *b = *(const struct commit **)vb; d21ee7d1 85) return commit_pos_at(&commit_pos, a) - d21ee7d1 86) commit_pos_at(&commit_pos, b); 76ffbca7 338) chunk_repeated = 1; 76ffbca7 345) chunk_repeated = 1; 76ffbca7 352) break; 76ffbca7 1094) progress = start_delayed_progress( 76ffbca7 1096) ctx->commits.nr); 76ffbca7 1119) progress = start_delayed_progress( 76ffbca7 1121) ctx->commits.nr); f97b9325 1298) progress = start_delayed_progress( f97b9325 1300) ctx->commits.nr); 3d112755 1306) QSORT(sorted_commits, ctx->commits.nr, commit_pos_cmp); 6c622f9f 1585) return -1; fdbde82f 1788) break; date.c c933b28d 521) return -1; c933b28d 532) return -1; 4f89f4fc 553) return -1; dir.c 16846444 1924) FREE_AND_NULL(dir->entries[i]); defd7c7b 2177) return path_none; help.c 617d5719 641) strbuf_addstr(buf, "no commit associated with this build\n"); refs/files-backend.c edc30691 2572) strbuf_release(&err); reset.c b309a971 37) ret = -1; b309a971 38) goto leave_reset_head; b309a971 43) goto leave_reset_head; b309a971 66) goto leave_reset_head; b309a971 72) goto leave_reset_head; b309a971 77) goto leave_reset_head; b309a971 81) ret = -1; b309a971 82) goto leave_reset_head; b309a971 90) goto leave_reset_head; b309a971 109) } else if (old_orig) b309a971 110) delete_ref(NULL, "ORIG_HEAD", old_orig, 0); revision.c 8918e379 658) return 1; 8918e379 662) return 1; a56b9464 721) return -1; sequencer.c 5b2f6d9c 431) warning_errno(_("could not read '%s'"), path); 65c425a2 2557) goto done_rebase_i; be1bb600 5203) apply_autostash(rebase_path_autostash()); t/helper/test-bloom.c f1294eaf 25) printf("No filter.\n"); f1294eaf 26) return; 1b4c57fa 54) usage(bloom_usage); 1b4c57fa 59) usage(bloom_usage); 1b4c57fa 71) usage(bloom_usage); 1b4c57fa 85) usage(bloom_usage); tree-diff.c e3696980 438) break; unpack-trees.c 7af7a258 1846) ret = UPDATE_SPARSITY_WORKTREE_UPDATE_FAILURES; urlmatch.c 12294990 581) retval = 0; Commits introducing uncovered code: Denton Liu be1bb600 sequencer: make apply_autostash() accept a path Denton Liu 65c425a2 sequencer: stop leaking buf Denton Liu 5b2f6d9c sequencer: make file exists check more efficient Denton Liu efcf6cf0 rebase: use read_oneliner() Denton Liu f213f069 rebase: generify reset_head() Denton Liu 86ed00af rebase: use apply_autostash() from sequencer.c Denton Liu b309a971 reset: extract reset_head() from rebase Derrick Stolee e3696980 diff: halt tree-diff early after max_changes Derrick Stolee 8918e379 revision: complicated pathspecs disable filters Derrick Stolee 0bbd0e8b dir: refactor treat_directory to clarify control flow Derrick Stolee 6c622f9f commit-graph: write commit-graph chains Derrick Stolee 0906ac2b blame: use changed-path Bloom filters Đoàn Trần Công Danh 4f89f4fc date.c: validate and set time in a helper function Đoàn Trần Công Danh c933b28d date.c: s/is_date/set_date/ Elijah Newren 7af7a258 unpack-trees: add a new update_sparsity() function Elijah Newren a35413c3 rebase: display an error if --root and --fork-point are both provided Elijah Newren 16846444 dir: include DIR_KEEP_UNTRACKED_CONTENTS handling in treat_directory() Emily Shaffer 1411914a bugreport: add uname info Emily Shaffer 238b439d bugreport: add tool to generate debugging info Emily Shaffer 617d5719 bugreport: gather git version and build info Emily Shaffer 709df95b help: move list_config_help to builtin/help Garima Singh ed591feb bloom.c: core Bloom filter implementation for changed paths. Garima Singh 76ffbca7 commit-graph: write Bloom filters to commit graph file Garima Singh a56b9464 revision.c: use Bloom filters to speed up path based revision walks Garima Singh f1294eaf bloom.c: introduce core Bloom filter constructs Garima Singh f97b9325 commit-graph: compute Bloom filters for changed paths Garima Singh 3d112755 commit-graph: examine commits by generation number Jeff King 1b4c57fa test-bloom: check that we have expected arguments Jeff King d21ee7d1 commit-graph: examine changed-path objects in pack order Johannes Schindelin 12294990 credential: handle `credential..` again Karsten Blees defd7c7b dir.c: git-status --ignored: don't scan the work tree three times Patrick Steinhardt a65b8ac2 update-ref: organize commands in an array Patrick Steinhardt de0e0d65 update-ref: move transaction handling into `update_refs_stdin()` Patrick Steinhardt edc30691 refs: fix segfault when aborting empty transaction Patrick Steinhardt e48cf33b update-ref: implement interactive transaction handling Taylor Blau 37b9dcab shallow.c: use '{commit,rollback}_shallow_file' Taylor Blau fdbde82f builtin/commit-graph.c: introduce split strategy 'no-merge'