kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

Merge branch 'jk/nth-packed-object-id' 

Code cleanup to use "struct object_id" more by replacing use of
"char *sha1"

* jk/nth-packed-object-id:
  packfile: drop nth_packed_object_sha1()
  packed_object_info(): use object_id internally for delta base
  packed_object_info(): use object_id for returning delta base
  pack-check: push oid lookup into loop
  pack-check: convert "internal error" die to a BUG()
  pack-bitmap: use object_id when loading on-disk bitmaps
  pack-objects: use object_id struct in pack-reuse code
  pack-objects: convert oe_set_delta_ext() to use object_id
  pack-objects: read delta base oid into object_id struct
  nth_packed_object_oid(): use customary integer return
maint
Junio C Hamano 2020-03-05 10:43:03 -08:00
parent a0ab37de61 2fecc48cad
commit e8e71848ea
13 changed files with 95 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
builtin/cat-file.c
View File

@ -262,7 +262,7 @@ static void expand_atom(struct strbuf *sb, const char *atom, int len,
strbuf_addstr(sb, data->rest); strbuf_addstr(sb, data->rest);
} else if (is_atom("deltabase", atom, len)) { } else if (is_atom("deltabase", atom, len)) {
if (data->mark_query) if (data->mark_query)
data->info.delta_base_sha1 = data->delta_base_oid.hash; data->info.delta_base_oid = &data->delta_base_oid;
else else
strbuf_addstr(sb, strbuf_addstr(sb,
oid_to_hex(&data->delta_base_oid)); oid_to_hex(&data->delta_base_oid));

48
builtin/pack-objects.c
View File

@ -872,14 +872,15 @@ static void write_reused_pack_one(size_t pos, struct hashfile *out,
/* Convert to REF_DELTA if we must... */ /* Convert to REF_DELTA if we must... */
if (!allow_ofs_delta) { if (!allow_ofs_delta) {
int base_pos = find_revindex_position(reuse_packfile, base_offset); int base_pos = find_revindex_position(reuse_packfile, base_offset);
const unsigned char *base_sha1 = struct object_id base_oid;
nth_packed_object_sha1(reuse_packfile,
reuse_packfile->revindex[base_pos].nr); nth_packed_object_id(&base_oid, reuse_packfile,
reuse_packfile->revindex[base_pos].nr);


len = encode_in_pack_object_header(header, sizeof(header), len = encode_in_pack_object_header(header, sizeof(header),
OBJ_REF_DELTA, size); OBJ_REF_DELTA, size);
hashwrite(out, header, len); hashwrite(out, header, len);
hashwrite(out, base_sha1, 20); hashwrite(out, base_oid.hash, 20);
copy_pack_data(out, reuse_packfile, w_curs, cur, next - cur); copy_pack_data(out, reuse_packfile, w_curs, cur, next - cur);
return; return;
} }
@ -1618,23 +1619,17 @@ static void cleanup_preferred_base(void)
* deltify other objects against, in order to avoid * deltify other objects against, in order to avoid
* circular deltas. * circular deltas.
*/ */
static int can_reuse_delta(const unsigned char *base_sha1, static int can_reuse_delta(const struct object_id *base_oid,
struct object_entry *delta, struct object_entry *delta,
struct object_entry **base_out) struct object_entry **base_out)
{ {
struct object_entry *base; struct object_entry *base;
struct object_id base_oid;

if (!base_sha1)
return 0;

oidread(&base_oid, base_sha1);


/* /*
* First see if we're already sending the base (or it's explicitly in * First see if we're already sending the base (or it's explicitly in
* our "excluded" list). * our "excluded" list).
*/ */
base = packlist_find(&to_pack, &base_oid); base = packlist_find(&to_pack, base_oid);
if (base) { if (base) {
if (!in_same_island(&delta->idx.oid, &base->idx.oid)) if (!in_same_island(&delta->idx.oid, &base->idx.oid))
return 0; return 0;
@ -1647,9 +1642,9 @@ static int can_reuse_delta(const unsigned char *base_sha1,
* even if it was buried too deep in history to make it into the * even if it was buried too deep in history to make it into the
* packing list. * packing list.
*/ */
if (thin && bitmap_has_oid_in_uninteresting(bitmap_git, &base_oid)) { if (thin && bitmap_has_oid_in_uninteresting(bitmap_git, base_oid)) {
if (use_delta_islands) { if (use_delta_islands) {
if (!in_same_island(&delta->idx.oid, &base_oid)) if (!in_same_island(&delta->idx.oid, base_oid))
return 0; return 0;
} }
*base_out = NULL; *base_out = NULL;
@ -1666,7 +1661,8 @@ static void check_object(struct object_entry *entry)
if (IN_PACK(entry)) { if (IN_PACK(entry)) {
struct packed_git *p = IN_PACK(entry); struct packed_git *p = IN_PACK(entry);
struct pack_window *w_curs = NULL; struct pack_window *w_curs = NULL;
const unsigned char *base_ref = NULL; int have_base = 0;
struct object_id base_ref;
struct object_entry *base_entry; struct object_entry *base_entry;
unsigned long used, used_0; unsigned long used, used_0;
unsigned long avail; unsigned long avail;
@ -1707,9 +1703,13 @@ static void check_object(struct object_entry *entry)
unuse_pack(&w_curs); unuse_pack(&w_curs);
return; return;
case OBJ_REF_DELTA: case OBJ_REF_DELTA:
if (reuse_delta && !entry->preferred_base) if (reuse_delta && !entry->preferred_base) {
base_ref = use_pack(p, &w_curs, oidread(&base_ref,
entry->in_pack_offset + used, NULL); use_pack(p, &w_curs,
entry->in_pack_offset + used,
NULL));
have_base = 1;
}
entry->in_pack_header_size = used + the_hash_algo->rawsz; entry->in_pack_header_size = used + the_hash_algo->rawsz;
break; break;
case OBJ_OFS_DELTA: case OBJ_OFS_DELTA:
@ -1739,13 +1739,15 @@ static void check_object(struct object_entry *entry)
revidx = find_pack_revindex(p, ofs); revidx = find_pack_revindex(p, ofs);
if (!revidx) if (!revidx)
goto give_up; goto give_up;
base_ref = nth_packed_object_sha1(p, revidx->nr); if (!nth_packed_object_id(&base_ref, p, revidx->nr))
have_base = 1;
} }
entry->in_pack_header_size = used + used_0; entry->in_pack_header_size = used + used_0;
break; break;
} }


if (can_reuse_delta(base_ref, entry, &base_entry)) { if (have_base &&
can_reuse_delta(&base_ref, entry, &base_entry)) {
oe_set_type(entry, entry->in_pack_type); oe_set_type(entry, entry->in_pack_type);
SET_SIZE(entry, in_pack_size); /* delta size */ SET_SIZE(entry, in_pack_size); /* delta size */
SET_DELTA_SIZE(entry, in_pack_size); SET_DELTA_SIZE(entry, in_pack_size);
@ -1755,7 +1757,7 @@ static void check_object(struct object_entry *entry)
entry->delta_sibling_idx = base_entry->delta_child_idx; entry->delta_sibling_idx = base_entry->delta_child_idx;
SET_DELTA_CHILD(base_entry, entry); SET_DELTA_CHILD(base_entry, entry);
} else { } else {
SET_DELTA_EXT(entry, base_ref); SET_DELTA_EXT(entry, &base_ref);
} }


unuse_pack(&w_curs); unuse_pack(&w_curs);
@ -3053,7 +3055,7 @@ static void add_objects_in_unpacked_packs(void)
in_pack.alloc); in_pack.alloc);


for (i = 0; i < p->num_objects; i++) { for (i = 0; i < p->num_objects; i++) {
nth_packed_object_oid(&oid, p, i); nth_packed_object_id(&oid, p, i);
o = lookup_unknown_object(&oid); o = lookup_unknown_object(&oid);
if (!(o->flags & OBJECT_ADDED)) if (!(o->flags & OBJECT_ADDED))
mark_in_pack_object(o, p, &in_pack); mark_in_pack_object(o, p, &in_pack);
@ -3157,7 +3159,7 @@ static void loosen_unused_packed_objects(void)
die(_("cannot open pack index")); die(_("cannot open pack index"));


for (i = 0; i < p->num_objects; i++) { for (i = 0; i < p->num_objects; i++) {
nth_packed_object_oid(&oid, p, i); nth_packed_object_id(&oid, p, i);
if (!packlist_find(&to_pack, &oid) && if (!packlist_find(&to_pack, &oid) &&
!has_sha1_pack_kept_or_nonlocal(&oid) && !has_sha1_pack_kept_or_nonlocal(&oid) &&
!loosened_object_can_be_discarded(&oid, p->mtime)) !loosened_object_can_be_discarded(&oid, p->mtime))

2
midx.c
View File

@ -534,7 +534,7 @@ static void fill_pack_entry(uint32_t pack_int_id,
uint32_t cur_object, uint32_t cur_object,
struct pack_midx_entry *entry) struct pack_midx_entry *entry)
{ {
if (!nth_packed_object_oid(&entry->oid, p, cur_object)) if (nth_packed_object_id(&entry->oid, p, cur_object) < 0)
die(_("failed to locate object %d in packfile"), cur_object); die(_("failed to locate object %d in packfile"), cur_object);


entry->pack_int_id = pack_int_id; entry->pack_int_id = pack_int_id;

2
object-store.h
View File

@ -300,7 +300,7 @@ struct object_info {
enum object_type *typep; enum object_type *typep;
unsigned long *sizep; unsigned long *sizep;
off_t *disk_sizep; off_t *disk_sizep;
unsigned char *delta_base_sha1; struct object_id *delta_base_oid;
struct strbuf *type_name; struct strbuf *type_name;
void **contentp; void **contentp;



18
pack-bitmap.c
View File

@ -170,7 +170,7 @@ static int load_bitmap_header(struct bitmap_index *index)


static struct stored_bitmap *store_bitmap(struct bitmap_index *index, static struct stored_bitmap *store_bitmap(struct bitmap_index *index,
struct ewah_bitmap *root, struct ewah_bitmap *root,
const unsigned char *hash, const struct object_id *oid,
struct stored_bitmap *xor_with, struct stored_bitmap *xor_with,
int flags) int flags)
{ {
@ -182,7 +182,7 @@ static struct stored_bitmap *store_bitmap(struct bitmap_index *index,
stored->root = root; stored->root = root;
stored->xor = xor_with; stored->xor = xor_with;
stored->flags = flags; stored->flags = flags;
oidread(&stored->oid, hash); oidcpy(&stored->oid, oid);


hash_pos = kh_put_oid_map(index->bitmaps, stored->oid, &ret); hash_pos = kh_put_oid_map(index->bitmaps, stored->oid, &ret);


@ -190,7 +190,7 @@ static struct stored_bitmap *store_bitmap(struct bitmap_index *index,
* because the SHA1 already existed on the map. this is bad, there * because the SHA1 already existed on the map. this is bad, there
* shouldn't be duplicated commits in the index */ * shouldn't be duplicated commits in the index */
if (ret == 0) { if (ret == 0) {
error("Duplicate entry in bitmap index: %s", hash_to_hex(hash)); error("Duplicate entry in bitmap index: %s", oid_to_hex(oid));
return NULL; return NULL;
} }


@ -222,13 +222,13 @@ static int load_bitmap_entries_v1(struct bitmap_index *index)
struct ewah_bitmap *bitmap = NULL; struct ewah_bitmap *bitmap = NULL;
struct stored_bitmap *xor_bitmap = NULL; struct stored_bitmap *xor_bitmap = NULL;
uint32_t commit_idx_pos; uint32_t commit_idx_pos;
const unsigned char *sha1; struct object_id oid;


commit_idx_pos = read_be32(index->map, &index->map_pos); commit_idx_pos = read_be32(index->map, &index->map_pos);
xor_offset = read_u8(index->map, &index->map_pos); xor_offset = read_u8(index->map, &index->map_pos);
flags = read_u8(index->map, &index->map_pos); flags = read_u8(index->map, &index->map_pos);


sha1 = nth_packed_object_sha1(index->pack, commit_idx_pos); nth_packed_object_id(&oid, index->pack, commit_idx_pos);


bitmap = read_bitmap_1(index); bitmap = read_bitmap_1(index);
if (!bitmap) if (!bitmap)
@ -245,7 +245,7 @@ static int load_bitmap_entries_v1(struct bitmap_index *index)
} }


recent_bitmaps[i % MAX_XOR_OFFSET] = store_bitmap( recent_bitmaps[i % MAX_XOR_OFFSET] = store_bitmap(
index, bitmap, sha1, xor_bitmap, flags); index, bitmap, &oid, xor_bitmap, flags);
} }


return 0; return 0;
@ -691,7 +691,7 @@ static void show_objects_for_type(
offset += ewah_bit_ctz64(word >> offset); offset += ewah_bit_ctz64(word >> offset);


entry = &bitmap_git->pack->revindex[pos + offset]; entry = &bitmap_git->pack->revindex[pos + offset];
nth_packed_object_oid(&oid, bitmap_git->pack, entry->nr); nth_packed_object_id(&oid, bitmap_git->pack, entry->nr);


if (bitmap_git->hashes) if (bitmap_git->hashes)
hash = get_be32(bitmap_git->hashes + entry->nr); hash = get_be32(bitmap_git->hashes + entry->nr);
@ -796,7 +796,7 @@ static unsigned long get_size_by_pos(struct bitmap_index *bitmap_git,
if (packed_object_info(the_repository, pack, if (packed_object_info(the_repository, pack,
entry->offset, &oi) < 0) { entry->offset, &oi) < 0) {
struct object_id oid; struct object_id oid;
nth_packed_object_oid(&oid, pack, entry->nr); nth_packed_object_id(&oid, pack, entry->nr);
die(_("unable to get size of %s"), oid_to_hex(&oid)); die(_("unable to get size of %s"), oid_to_hex(&oid));
} }
} else { } else {
@ -1342,7 +1342,7 @@ int rebuild_existing_bitmaps(struct bitmap_index *bitmap_git,
struct object_entry *oe; struct object_entry *oe;


entry = &bitmap_git->pack->revindex[i]; entry = &bitmap_git->pack->revindex[i];
nth_packed_object_oid(&oid, bitmap_git->pack, entry->nr); nth_packed_object_id(&oid, bitmap_git->pack, entry->nr);
oe = packlist_find(mapping, &oid); oe = packlist_find(mapping, &oid);


if (oe) if (oe)

22
pack-check.c
View File

@ -8,10 +8,6 @@


struct idx_entry { struct idx_entry {
off_t offset; off_t offset;
union idx_entry_object {
const unsigned char *hash;
struct object_id *oid;
} oid;
unsigned int nr; unsigned int nr;
}; };


@ -97,9 +93,6 @@ static int verify_packfile(struct repository *r,
entries[nr_objects].offset = pack_sig_ofs; entries[nr_objects].offset = pack_sig_ofs;
/* first sort entries by pack offset, since unpacking them is more efficient that way */ /* first sort entries by pack offset, since unpacking them is more efficient that way */
for (i = 0; i < nr_objects; i++) { for (i = 0; i < nr_objects; i++) {
entries[i].oid.hash = nth_packed_object_sha1(p, i);
if (!entries[i].oid.hash)
die("internal error pack-check nth-packed-object");
entries[i].offset = nth_packed_object_offset(p, i); entries[i].offset = nth_packed_object_offset(p, i);
entries[i].nr = i; entries[i].nr = i;
} }
@ -107,11 +100,16 @@ static int verify_packfile(struct repository *r,


for (i = 0; i < nr_objects; i++) { for (i = 0; i < nr_objects; i++) {
void *data; void *data;
struct object_id oid;
enum object_type type; enum object_type type;
unsigned long size; unsigned long size;
off_t curpos; off_t curpos;
int data_valid; int data_valid;


if (nth_packed_object_id(&oid, p, entries[i].nr) < 0)
BUG("unable to get oid of object %lu from %s",
(unsigned long)entries[i].nr, p->pack_name);

if (p->index_version > 1) { if (p->index_version > 1) {
off_t offset = entries[i].offset; off_t offset = entries[i].offset;
off_t len = entries[i+1].offset - offset; off_t len = entries[i+1].offset - offset;
@ -119,7 +117,7 @@ static int verify_packfile(struct repository *r,
if (check_pack_crc(p, w_curs, offset, len, nr)) if (check_pack_crc(p, w_curs, offset, len, nr))
err = error("index CRC mismatch for object %s " err = error("index CRC mismatch for object %s "
"from %s at offset %"PRIuMAX"", "from %s at offset %"PRIuMAX"",
oid_to_hex(entries[i].oid.oid), oid_to_hex(&oid),
p->pack_name, (uintmax_t)offset); p->pack_name, (uintmax_t)offset);
} }


@ -142,14 +140,14 @@ static int verify_packfile(struct repository *r,


if (data_valid && !data) if (data_valid && !data)
err = error("cannot unpack %s from %s at offset %"PRIuMAX"", err = error("cannot unpack %s from %s at offset %"PRIuMAX"",
oid_to_hex(entries[i].oid.oid), p->pack_name, oid_to_hex(&oid), p->pack_name,
(uintmax_t)entries[i].offset); (uintmax_t)entries[i].offset);
else if (check_object_signature(r, entries[i].oid.oid, data, size, type_name(type))) else if (check_object_signature(r, &oid, data, size, type_name(type)))
err = error("packed %s from %s is corrupt", err = error("packed %s from %s is corrupt",
oid_to_hex(entries[i].oid.oid), p->pack_name); oid_to_hex(&oid), p->pack_name);
else if (fn) { else if (fn) {
int eaten = 0; int eaten = 0;
err |= fn(entries[i].oid.oid, type, size, data, &eaten); err |= fn(&oid, type, size, data, &eaten);
if (eaten) if (eaten)
data = NULL; data = NULL;
} }

4
pack-objects.c
View File

@ -203,14 +203,14 @@ struct object_entry *packlist_alloc(struct packing_data *pdata,


void oe_set_delta_ext(struct packing_data *pdata, void oe_set_delta_ext(struct packing_data *pdata,
struct object_entry *delta, struct object_entry *delta,
const unsigned char *sha1) const struct object_id *oid)
{ {
struct object_entry *base; struct object_entry *base;


ALLOC_GROW(pdata->ext_bases, pdata->nr_ext + 1, pdata->alloc_ext); ALLOC_GROW(pdata->ext_bases, pdata->nr_ext + 1, pdata->alloc_ext);
base = &pdata->ext_bases[pdata->nr_ext++]; base = &pdata->ext_bases[pdata->nr_ext++];
memset(base, 0, sizeof(*base)); memset(base, 0, sizeof(*base));
hashcpy(base->idx.oid.hash, sha1); oidcpy(&base->idx.oid, oid);


/* These flags mark that we are not part of the actual pack output. */ /* These flags mark that we are not part of the actual pack output. */
base->preferred_base = 1; base->preferred_base = 1;

2
pack-objects.h
View File

@ -292,7 +292,7 @@ static inline void oe_set_delta(struct packing_data *pack,


void oe_set_delta_ext(struct packing_data *pack, void oe_set_delta_ext(struct packing_data *pack,
struct object_entry *e, struct object_entry *e,
const unsigned char *sha1); const struct object_id *oid);


static inline struct object_entry *oe_delta_child( static inline struct object_entry *oe_delta_child(
const struct packing_data *pack, const struct packing_data *pack,

69
packfile.c
View File

@ -1225,30 +1225,32 @@ off_t get_delta_base(struct packed_git *p,
* the final object lookup), but more expensive for OFS deltas (we * the final object lookup), but more expensive for OFS deltas (we
* have to load the revidx to convert the offset back into a sha1). * have to load the revidx to convert the offset back into a sha1).
*/ */
static const unsigned char *get_delta_base_sha1(struct packed_git *p, static int get_delta_base_oid(struct packed_git *p,
struct pack_window **w_curs, struct pack_window **w_curs,
off_t curpos, off_t curpos,
enum object_type type, struct object_id *oid,
off_t delta_obj_offset) enum object_type type,
off_t delta_obj_offset)
{ {
if (type == OBJ_REF_DELTA) { if (type == OBJ_REF_DELTA) {
unsigned char *base = use_pack(p, w_curs, curpos, NULL); unsigned char *base = use_pack(p, w_curs, curpos, NULL);
return base; oidread(oid, base);
return 0;
} else if (type == OBJ_OFS_DELTA) { } else if (type == OBJ_OFS_DELTA) {
struct revindex_entry *revidx; struct revindex_entry *revidx;
off_t base_offset = get_delta_base(p, w_curs, &curpos, off_t base_offset = get_delta_base(p, w_curs, &curpos,
type, delta_obj_offset); type, delta_obj_offset);


if (!base_offset) if (!base_offset)
return NULL; return -1;


revidx = find_pack_revindex(p, base_offset); revidx = find_pack_revindex(p, base_offset);
if (!revidx) if (!revidx)
return NULL; return -1;


return nth_packed_object_sha1(p, revidx->nr); return nth_packed_object_id(oid, p, revidx->nr);
} else } else
return NULL; return -1;
} }


static int retry_bad_packed_offset(struct repository *r, static int retry_bad_packed_offset(struct repository *r,
@ -1261,7 +1263,7 @@ static int retry_bad_packed_offset(struct repository *r,
revidx = find_pack_revindex(p, obj_offset); revidx = find_pack_revindex(p, obj_offset);
if (!revidx) if (!revidx)
return OBJ_BAD; return OBJ_BAD;
nth_packed_object_oid(&oid, p, revidx->nr); nth_packed_object_id(&oid, p, revidx->nr);
mark_bad_packed_object(p, oid.hash); mark_bad_packed_object(p, oid.hash);
type = oid_object_info(r, &oid, NULL); type = oid_object_info(r, &oid, NULL);
if (type <= OBJ_NONE) if (type <= OBJ_NONE)
@ -1556,20 +1558,16 @@ int packed_object_info(struct repository *r, struct packed_git *p,
} }
} }


if (oi->delta_base_sha1) { if (oi->delta_base_oid) {
if (type == OBJ_OFS_DELTA || type == OBJ_REF_DELTA) { if (type == OBJ_OFS_DELTA || type == OBJ_REF_DELTA) {
const unsigned char *base; if (get_delta_base_oid(p, &w_curs, curpos,

oi->delta_base_oid,
base = get_delta_base_sha1(p, &w_curs, curpos, type, obj_offset) < 0) {
type, obj_offset);
if (!base) {
type = OBJ_BAD; type = OBJ_BAD;
goto out; goto out;
} }

hashcpy(oi->delta_base_sha1, base);
} else } else
hashclr(oi->delta_base_sha1); oidclr(oi->delta_base_oid);
} }


oi->whence = in_delta_base_cache(p, obj_offset) ? OI_DBCACHED : oi->whence = in_delta_base_cache(p, obj_offset) ? OI_DBCACHED :
@ -1693,7 +1691,7 @@ void *unpack_entry(struct repository *r, struct packed_git *p, off_t obj_offset,
off_t len = revidx[1].offset - obj_offset; off_t len = revidx[1].offset - obj_offset;
if (check_pack_crc(p, &w_curs, obj_offset, len, revidx->nr)) { if (check_pack_crc(p, &w_curs, obj_offset, len, revidx->nr)) {
struct object_id oid; struct object_id oid;
nth_packed_object_oid(&oid, p, revidx->nr); nth_packed_object_id(&oid, p, revidx->nr);
error("bad packed object CRC for %s", error("bad packed object CRC for %s",
oid_to_hex(&oid)); oid_to_hex(&oid));
mark_bad_packed_object(p, oid.hash); mark_bad_packed_object(p, oid.hash);
@ -1782,7 +1780,7 @@ void *unpack_entry(struct repository *r, struct packed_git *p, off_t obj_offset,
struct object_id base_oid; struct object_id base_oid;
revidx = find_pack_revindex(p, obj_offset); revidx = find_pack_revindex(p, obj_offset);
if (revidx) { if (revidx) {
nth_packed_object_oid(&base_oid, p, revidx->nr); nth_packed_object_id(&base_oid, p, revidx->nr);
error("failed to read delta base object %s" error("failed to read delta base object %s"
" at offset %"PRIuMAX" from %s", " at offset %"PRIuMAX" from %s",
oid_to_hex(&base_oid), (uintmax_t)obj_offset, oid_to_hex(&base_oid), (uintmax_t)obj_offset,
@ -1869,36 +1867,27 @@ int bsearch_pack(const struct object_id *oid, const struct packed_git *p, uint32
index_lookup, index_lookup_width, result); index_lookup, index_lookup_width, result);
} }


const unsigned char *nth_packed_object_sha1(struct packed_git *p, int nth_packed_object_id(struct object_id *oid,
uint32_t n) struct packed_git *p,
uint32_t n)
{ {
const unsigned char *index = p->index_data; const unsigned char *index = p->index_data;
const unsigned int hashsz = the_hash_algo->rawsz; const unsigned int hashsz = the_hash_algo->rawsz;
if (!index) { if (!index) {
if (open_pack_index(p)) if (open_pack_index(p))
return NULL; return -1;
index = p->index_data; index = p->index_data;
} }
if (n >= p->num_objects) if (n >= p->num_objects)
return NULL; return -1;
index += 4 * 256; index += 4 * 256;
if (p->index_version == 1) { if (p->index_version == 1) {
return index + (hashsz + 4) * n + 4; oidread(oid, index + (hashsz + 4) * n + 4);
} else { } else {
index += 8; index += 8;
return index + hashsz * n; oidread(oid, index + hashsz * n);
} }
} return 0;

const struct object_id *nth_packed_object_oid(struct object_id *oid,
struct packed_git *p,
uint32_t n)
{
const unsigned char *hash = nth_packed_object_sha1(p, n);
if (!hash)
return NULL;
hashcpy(oid->hash, hash);
return oid;
} }


void check_pack_index_ptr(const struct packed_git *p, const void *vptr) void check_pack_index_ptr(const struct packed_git *p, const void *vptr)
@ -2077,7 +2066,7 @@ int for_each_object_in_pack(struct packed_git *p,
else else
pos = i; pos = i;


if (!nth_packed_object_oid(&oid, p, pos)) if (nth_packed_object_id(&oid, p, pos) < 0)
return error("unable to get sha1 of object %u in %s", return error("unable to get sha1 of object %u in %s",
pos, p->pack_name); pos, p->pack_name);



15
packfile.h
View File

@ -121,18 +121,11 @@ void check_pack_index_ptr(const struct packed_git *p, const void *ptr);
int bsearch_pack(const struct object_id *oid, const struct packed_git *p, uint32_t *result); int bsearch_pack(const struct object_id *oid, const struct packed_git *p, uint32_t *result);


/* /*
* Return the SHA-1 of the nth object within the specified packfile. * Write the oid of the nth object within the specified packfile into the first
* Open the index if it is not already open. The return value points * parameter. Open the index if it is not already open. Returns 0 on success,
* at the SHA-1 within the mmapped index. Return NULL if there is an * negative otherwise.
* error.
*/ */
const unsigned char *nth_packed_object_sha1(struct packed_git *, uint32_t n); int nth_packed_object_id(struct object_id *, struct packed_git *, uint32_t n);
/*
* Like nth_packed_object_sha1, but write the data into the object specified by
* the the first argument. Returns the first argument on success, and NULL on
* error.
*/
const struct object_id *nth_packed_object_oid(struct object_id *, struct packed_git *, uint32_t n);


/* /*
* Return the offset of the nth object within the specified packfile. * Return the offset of the nth object within the specified packfile.

4
ref-filter.c
View File

@ -279,9 +279,9 @@ static int deltabase_atom_parser(const struct ref_format *format, struct used_at
if (arg) if (arg)
return strbuf_addf_ret(err, -1, _("%%(deltabase) does not take arguments")); return strbuf_addf_ret(err, -1, _("%%(deltabase) does not take arguments"));
if (*atom->name == '*') if (*atom->name == '*')
oi_deref.info.delta_base_sha1 = oi_deref.delta_base_oid.hash; oi_deref.info.delta_base_oid = &oi_deref.delta_base_oid;
else else
oi.info.delta_base_sha1 = oi.delta_base_oid.hash; oi.info.delta_base_oid = &oi.delta_base_oid;
return 0; return 0;
} }



8
sha1-file.c
View File

@ -1354,8 +1354,8 @@ static int loose_object_info(struct repository *r,
struct strbuf hdrbuf = STRBUF_INIT; struct strbuf hdrbuf = STRBUF_INIT;
unsigned long size_scratch; unsigned long size_scratch;


if (oi->delta_base_sha1) if (oi->delta_base_oid)
hashclr(oi->delta_base_sha1); oidclr(oi->delta_base_oid);


/* /*
* If we don't care about type or size, then we don't * If we don't care about type or size, then we don't
@ -1474,8 +1474,8 @@ static int do_oid_object_info_extended(struct repository *r,
*(oi->sizep) = co->size; *(oi->sizep) = co->size;
if (oi->disk_sizep) if (oi->disk_sizep)
*(oi->disk_sizep) = 0; *(oi->disk_sizep) = 0;
if (oi->delta_base_sha1) if (oi->delta_base_oid)
hashclr(oi->delta_base_sha1); oidclr(oi->delta_base_oid);
if (oi->type_name) if (oi->type_name)
strbuf_addstr(oi->type_name, type_name(co->type)); strbuf_addstr(oi->type_name, type_name(co->type));
if (oi->contentp) if (oi->contentp)

13
sha1-name.c
View File

@ -155,7 +155,6 @@ static void unique_in_pack(struct packed_git *p,
struct disambiguate_state *ds) struct disambiguate_state *ds)
{ {
uint32_t num, i, first = 0; uint32_t num, i, first = 0;
const struct object_id *current = NULL;


if (p->multi_pack_index) if (p->multi_pack_index)
return; return;
@ -173,10 +172,10 @@ static void unique_in_pack(struct packed_git *p,
*/ */
for (i = first; i < num && !ds->ambiguous; i++) { for (i = first; i < num && !ds->ambiguous; i++) {
struct object_id oid; struct object_id oid;
current = nth_packed_object_oid(&oid, p, i); nth_packed_object_id(&oid, p, i);
if (!match_sha(ds->len, ds->bin_pfx.hash, current->hash)) if (!match_sha(ds->len, ds->bin_pfx.hash, oid.hash))
break; break;
update_candidates(ds, current); update_candidates(ds, &oid);
} }
} }


@ -643,14 +642,14 @@ static void find_abbrev_len_for_pack(struct packed_git *p,
*/ */
mad->init_len = 0; mad->init_len = 0;
if (!match) { if (!match) {
if (nth_packed_object_oid(&oid, p, first)) if (!nth_packed_object_id(&oid, p, first))
extend_abbrev_len(&oid, mad); extend_abbrev_len(&oid, mad);
} else if (first < num - 1) { } else if (first < num - 1) {
if (nth_packed_object_oid(&oid, p, first + 1)) if (!nth_packed_object_id(&oid, p, first + 1))
extend_abbrev_len(&oid, mad); extend_abbrev_len(&oid, mad);
} }
if (first > 0) { if (first > 0) {
if (nth_packed_object_oid(&oid, p, first - 1)) if (!nth_packed_object_id(&oid, p, first - 1))
extend_abbrev_len(&oid, mad); extend_abbrev_len(&oid, mad);
} }
mad->init_len = mad->cur_len; mad->init_len = mad->cur_len;