mirrors/git
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'tl/pack-bitmap-error-messages'

Browse Source 
Tweak various messages that come from the pack-bitmap codepaths.

* tl/pack-bitmap-error-messages:
  pack-bitmap.c: continue looping when first MIDX bitmap is found
  pack-bitmap.c: using error() instead of silently returning -1
  pack-bitmap.c: do not ignore error when opening a bitmap file
  pack-bitmap.c: rename "idx_name" to "bitmap_name"
  pack-bitmap.c: mark more strings for translations
  pack-bitmap.c: fix formatting of error messages
This commit is contained in:
Junio C Hamano
2022-07-27 09:16:52 -07:00
parent 7c7719ac0e 5dcee7c705
commit cc29f89032
1 changed files with 58 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
pack-bitmap.c
View File

@ -1,5 +1,6 @@
#include "cache.h" #include "cache.h"
#include "commit.h" #include "commit.h"
#include "strbuf.h"
#include "tag.h" #include "tag.h"
#include "diff.h" #include "diff.h"
#include "revision.h" #include "revision.h"
@ -138,7 +139,7 @@ static struct ewah_bitmap *read_bitmap_1(struct bitmap_index *index)
index->map_size - index->map_pos); index->map_size - index->map_pos);
if (bitmap_size < 0) { if (bitmap_size < 0) {
error("Failed to load bitmap index (corrupted?)"); error(_("failed to load bitmap index (corrupted?)"));
ewah_pool_free(b); ewah_pool_free(b);
return NULL; return NULL;
} }
@ -160,14 +161,14 @@ static int load_bitmap_header(struct bitmap_index *index)
size_t header_size = sizeof(*header) - GIT_MAX_RAWSZ + the_hash_algo->rawsz; size_t header_size = sizeof(*header) - GIT_MAX_RAWSZ + the_hash_algo->rawsz;
if (index->map_size < header_size + the_hash_algo->rawsz) if (index->map_size < header_size + the_hash_algo->rawsz)
return error("Corrupted bitmap index (too small)"); return error(_("corrupted bitmap index (too small)"));
if (memcmp(header->magic, BITMAP_IDX_SIGNATURE, sizeof(BITMAP_IDX_SIGNATURE)) != 0) if (memcmp(header->magic, BITMAP_IDX_SIGNATURE, sizeof(BITMAP_IDX_SIGNATURE)) != 0)
return error("Corrupted bitmap index file (wrong header)"); return error(_("corrupted bitmap index file (wrong header)"));
index->version = ntohs(header->version); index->version = ntohs(header->version);
if (index->version != 1) if (index->version != 1)
return error("Unsupported version for bitmap index file (%d)", index->version); return error(_("unsupported version '%d' for bitmap index file"), index->version);
/* Parse known bitmap format options */ /* Parse known bitmap format options */
{ {
@ -176,12 +177,12 @@ static int load_bitmap_header(struct bitmap_index *index)
unsigned char *index_end = index->map + index->map_size - the_hash_algo->rawsz; unsigned char *index_end = index->map + index->map_size - the_hash_algo->rawsz;
if ((flags & BITMAP_OPT_FULL_DAG) == 0) if ((flags & BITMAP_OPT_FULL_DAG) == 0)
return error("Unsupported options for bitmap index file " BUG("unsupported options for bitmap index file "
"(Git requires BITMAP_OPT_FULL_DAG)"); "(Git requires BITMAP_OPT_FULL_DAG)");
if (flags & BITMAP_OPT_HASH_CACHE) { if (flags & BITMAP_OPT_HASH_CACHE) {
if (cache_size > index_end - index->map - header_size) if (cache_size > index_end - index->map - header_size)
return error("corrupted bitmap index file (too short to fit hash cache)"); return error(_("corrupted bitmap index file (too short to fit hash cache)"));
index->hashes = (void *)(index_end - cache_size); index->hashes = (void *)(index_end - cache_size);
index_end -= cache_size; index_end -= cache_size;
} }
@ -215,7 +216,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", oid_to_hex(oid)); error(_("duplicate entry in bitmap index: '%s'"), oid_to_hex(oid));
return NULL; return NULL;
} }
@ -259,14 +260,14 @@ static int load_bitmap_entries_v1(struct bitmap_index *index)
struct object_id oid; struct object_id oid;
if (index->map_size - index->map_pos < 6) if (index->map_size - index->map_pos < 6)
return error("corrupt ewah bitmap: truncated header for entry %d", i); return error(_("corrupt ewah bitmap: truncated header for entry %d"), i);
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);
if (nth_bitmap_object_oid(index, &oid, commit_idx_pos) < 0) if (nth_bitmap_object_oid(index, &oid, commit_idx_pos) < 0)
return error("corrupt ewah bitmap: commit index %u out of range", return error(_("corrupt ewah bitmap: commit index %u out of range"),
(unsigned)commit_idx_pos); (unsigned)commit_idx_pos);
bitmap = read_bitmap_1(index); bitmap = read_bitmap_1(index);
@ -274,13 +275,13 @@ static int load_bitmap_entries_v1(struct bitmap_index *index)
return -1; return -1;
if (xor_offset > MAX_XOR_OFFSET || xor_offset > i) if (xor_offset > MAX_XOR_OFFSET || xor_offset > i)
return error("Corrupted bitmap pack index"); return error(_("corrupted bitmap pack index"));
if (xor_offset > 0) { if (xor_offset > 0) {
xor_bitmap = recent_bitmaps[(i - xor_offset) % MAX_XOR_OFFSET]; xor_bitmap = recent_bitmaps[(i - xor_offset) % MAX_XOR_OFFSET];
if (!xor_bitmap) if (!xor_bitmap)
return error("Invalid XOR offset in bitmap pack index"); return error(_("invalid XOR offset in bitmap pack index"));
} }
recent_bitmaps[i % MAX_XOR_OFFSET] = store_bitmap( recent_bitmaps[i % MAX_XOR_OFFSET] = store_bitmap(
@ -313,17 +314,21 @@ static int open_midx_bitmap_1(struct bitmap_index *bitmap_git,
struct multi_pack_index *midx) struct multi_pack_index *midx)
{ {
struct stat st; struct stat st;
char *idx_name = midx_bitmap_filename(midx); char *bitmap_name = midx_bitmap_filename(midx);
int fd = git_open(idx_name); int fd = git_open(bitmap_name);
uint32_t i; uint32_t i;
struct packed_git *preferred; struct packed_git *preferred;
free(idx_name); if (fd < 0) {
if (errno != ENOENT)
if (fd < 0) warning_errno("cannot open '%s'", bitmap_name);
free(bitmap_name);
return -1; return -1;
}
free(bitmap_name);
if (fstat(fd, &st)) { if (fstat(fd, &st)) {
error_errno(_("cannot fstat bitmap file"));
close(fd); close(fd);
return -1; return -1;
} }
@ -332,7 +337,7 @@ static int open_midx_bitmap_1(struct bitmap_index *bitmap_git,
struct strbuf buf = STRBUF_INIT; struct strbuf buf = STRBUF_INIT;
get_midx_filename(&buf, midx->object_dir); get_midx_filename(&buf, midx->object_dir);
/* ignore extra bitmap file; we can only handle one */ /* ignore extra bitmap file; we can only handle one */
warning("ignoring extra bitmap file: %s", buf.buf); warning(_("ignoring extra bitmap file: '%s'"), buf.buf);
close(fd); close(fd);
strbuf_release(&buf); strbuf_release(&buf);
return -1; return -1;
@ -348,8 +353,10 @@ static int open_midx_bitmap_1(struct bitmap_index *bitmap_git,
if (load_bitmap_header(bitmap_git) < 0) if (load_bitmap_header(bitmap_git) < 0)
goto cleanup; goto cleanup;
if (!hasheq(get_midx_checksum(bitmap_git->midx), bitmap_git->checksum)) if (!hasheq(get_midx_checksum(bitmap_git->midx), bitmap_git->checksum)) {
error(_("checksum doesn't match in MIDX and bitmap"));
goto cleanup; goto cleanup;
}
if (load_midx_revindex(bitmap_git->midx) < 0) { if (load_midx_revindex(bitmap_git->midx) < 0) {
warning(_("multi-pack bitmap is missing required reverse index")); warning(_("multi-pack bitmap is missing required reverse index"));
@ -384,26 +391,31 @@ static int open_pack_bitmap_1(struct bitmap_index *bitmap_git, struct packed_git
{ {
int fd; int fd;
struct stat st; struct stat st;
char *idx_name; char *bitmap_name;
if (open_pack_index(packfile)) if (open_pack_index(packfile))
return -1; return -1;
idx_name = pack_bitmap_filename(packfile); bitmap_name = pack_bitmap_filename(packfile);
fd = git_open(idx_name); fd = git_open(bitmap_name);
free(idx_name);
if (fd < 0) if (fd < 0) {
if (errno != ENOENT)
warning_errno("cannot open '%s'", bitmap_name);
free(bitmap_name);
return -1; return -1;
}
free(bitmap_name);
if (fstat(fd, &st)) { if (fstat(fd, &st)) {
error_errno(_("cannot fstat bitmap file"));
close(fd); close(fd);
return -1; return -1;
} }
if (bitmap_git->pack || bitmap_git->midx) { if (bitmap_git->pack || bitmap_git->midx) {
/* ignore extra bitmap file; we can only handle one */ /* ignore extra bitmap file; we can only handle one */
warning("ignoring extra bitmap file: %s", packfile->pack_name); warning(_("ignoring extra bitmap file: '%s'"), packfile->pack_name);
close(fd); close(fd);
return -1; return -1;
} }
@ -508,15 +520,16 @@ static int open_pack_bitmap(struct repository *r,
static int open_midx_bitmap(struct repository *r, static int open_midx_bitmap(struct repository *r,
struct bitmap_index *bitmap_git) struct bitmap_index *bitmap_git)
{ {
int ret = -1;
struct multi_pack_index *midx; struct multi_pack_index *midx;
assert(!bitmap_git->map); assert(!bitmap_git->map);
for (midx = get_multi_pack_index(r); midx; midx = midx->next) { for (midx = get_multi_pack_index(r); midx; midx = midx->next) {
if (!open_midx_bitmap_1(bitmap_git, midx)) if (!open_midx_bitmap_1(bitmap_git, midx))
return 0; ret = 0;
} }
return -1; return ret;
} }
static int open_bitmap(struct repository *r, static int open_bitmap(struct repository *r,
@ -831,7 +844,7 @@ static struct bitmap *find_objects(struct bitmap_index *bitmap_git,
revs->include_check_data = &incdata; revs->include_check_data = &incdata;
if (prepare_revision_walk(revs)) if (prepare_revision_walk(revs))
die("revision walk setup failed"); die(_("revision walk setup failed"));
show_data.bitmap_git = bitmap_git; show_data.bitmap_git = bitmap_git;
show_data.base = base; show_data.base = base;
@ -1640,15 +1653,15 @@ static void test_bitmap_type(struct bitmap_test_data *tdata,
} }
if (bitmap_type == OBJ_NONE) if (bitmap_type == OBJ_NONE)
die("object %s not found in type bitmaps", die(_("object '%s' not found in type bitmaps"),
oid_to_hex(&obj->oid)); oid_to_hex(&obj->oid));
if (bitmaps_nr > 1) if (bitmaps_nr > 1)
die("object %s does not have a unique type", die(_("object '%s' does not have a unique type"),
oid_to_hex(&obj->oid)); oid_to_hex(&obj->oid));
if (bitmap_type != obj->type) if (bitmap_type != obj->type)
die("object %s: real type %s, expected: %s", die(_("object '%s': real type '%s', expected: '%s'"),
oid_to_hex(&obj->oid), oid_to_hex(&obj->oid),
type_name(obj->type), type_name(obj->type),
type_name(bitmap_type)); type_name(bitmap_type));
@ -1662,7 +1675,7 @@ static void test_show_object(struct object *object, const char *name,
bitmap_pos = bitmap_position(tdata->bitmap_git, &object->oid); bitmap_pos = bitmap_position(tdata->bitmap_git, &object->oid);
if (bitmap_pos < 0) if (bitmap_pos < 0)
die("Object not in bitmap: %s\n", oid_to_hex(&object->oid)); die(_("object not in bitmap: '%s'"), oid_to_hex(&object->oid));
test_bitmap_type(tdata, object, bitmap_pos); test_bitmap_type(tdata, object, bitmap_pos);
bitmap_set(tdata->base, bitmap_pos); bitmap_set(tdata->base, bitmap_pos);
@ -1677,7 +1690,7 @@ static void test_show_commit(struct commit *commit, void *data)
bitmap_pos = bitmap_position(tdata->bitmap_git, bitmap_pos = bitmap_position(tdata->bitmap_git,
&commit->object.oid); &commit->object.oid);
if (bitmap_pos < 0) if (bitmap_pos < 0)
die("Object not in bitmap: %s\n", oid_to_hex(&commit->object.oid)); die(_("object not in bitmap: '%s'"), oid_to_hex(&commit->object.oid));
test_bitmap_type(tdata, &commit->object, bitmap_pos); test_bitmap_type(tdata, &commit->object, bitmap_pos);
bitmap_set(tdata->base, bitmap_pos); bitmap_set(tdata->base, bitmap_pos);
@ -1694,26 +1707,26 @@ void test_bitmap_walk(struct rev_info *revs)
struct ewah_bitmap *bm; struct ewah_bitmap *bm;
if (!(bitmap_git = prepare_bitmap_git(revs->repo))) if (!(bitmap_git = prepare_bitmap_git(revs->repo)))
die("failed to load bitmap indexes"); die(_("failed to load bitmap indexes"));
if (revs->pending.nr != 1) if (revs->pending.nr != 1)
die("you must specify exactly one commit to test"); die(_("you must specify exactly one commit to test"));
fprintf(stderr, "Bitmap v%d test (%d entries loaded)\n", fprintf_ln(stderr, "Bitmap v%d test (%d entries loaded)",
bitmap_git->version, bitmap_git->entry_count); bitmap_git->version, bitmap_git->entry_count);
root = revs->pending.objects[0].item; root = revs->pending.objects[0].item;
bm = bitmap_for_commit(bitmap_git, (struct commit *)root); bm = bitmap_for_commit(bitmap_git, (struct commit *)root);
if (bm) { if (bm) {
fprintf(stderr, "Found bitmap for %s. %d bits / %08x checksum\n", fprintf_ln(stderr, "Found bitmap for '%s'. %d bits / %08x checksum",
oid_to_hex(&root->oid), (int)bm->bit_size, ewah_checksum(bm)); oid_to_hex(&root->oid), (int)bm->bit_size, ewah_checksum(bm));
result = ewah_to_bitmap(bm); result = ewah_to_bitmap(bm);
} }
if (!result) if (!result)
die("Commit %s doesn't have an indexed bitmap", oid_to_hex(&root->oid)); die(_("commit '%s' doesn't have an indexed bitmap"), oid_to_hex(&root->oid));
revs->tag_objects = 1; revs->tag_objects = 1;
revs->tree_objects = 1; revs->tree_objects = 1;
@ -1722,7 +1735,7 @@ void test_bitmap_walk(struct rev_info *revs)
result_popcnt = bitmap_popcount(result); result_popcnt = bitmap_popcount(result);
if (prepare_revision_walk(revs)) if (prepare_revision_walk(revs))
die("revision walk setup failed"); die(_("revision walk setup failed"));
tdata.bitmap_git = bitmap_git; tdata.bitmap_git = bitmap_git;
tdata.base = bitmap_new(); tdata.base = bitmap_new();
@ -1738,9 +1751,9 @@ void test_bitmap_walk(struct rev_info *revs)
stop_progress(&tdata.prg); stop_progress(&tdata.prg);
if (bitmap_equals(result, tdata.base)) if (bitmap_equals(result, tdata.base))
fprintf(stderr, "OK!\n"); fprintf_ln(stderr, "OK!");
else else
die("mismatch in bitmap results"); die(_("mismatch in bitmap results"));
bitmap_free(result); bitmap_free(result);
bitmap_free(tdata.base); bitmap_free(tdata.base);
@ -1758,10 +1771,10 @@ int test_bitmap_commits(struct repository *r)
MAYBE_UNUSED void *value; MAYBE_UNUSED void *value;
if (!bitmap_git) if (!bitmap_git)
die("failed to load bitmap indexes"); die(_("failed to load bitmap indexes"));
kh_foreach(bitmap_git->bitmaps, oid, value, { kh_foreach(bitmap_git->bitmaps, oid, value, {
printf("%s\n", oid_to_hex(&oid)); printf_ln("%s", oid_to_hex(&oid));
}); });
free_bitmap_index(bitmap_git); free_bitmap_index(bitmap_git);
@ -1786,7 +1799,7 @@ int test_bitmap_hashes(struct repository *r)
nth_bitmap_object_oid(bitmap_git, &oid, index_pos); nth_bitmap_object_oid(bitmap_git, &oid, index_pos);
printf("%s %"PRIu32"\n", printf_ln("%s %"PRIu32"",
oid_to_hex(&oid), get_be32(bitmap_git->hashes + index_pos)); oid_to_hex(&oid), get_be32(bitmap_git->hashes + index_pos));
} }
@ -1948,7 +1961,7 @@ static off_t get_disk_usage_for_type(struct bitmap_index *bitmap_git,
struct object_id oid; struct object_id oid;
nth_midxed_object_oid(&oid, bitmap_git->midx, midx_pos); nth_midxed_object_oid(&oid, bitmap_git->midx, midx_pos);
die(_("could not find %s in pack %s at offset %"PRIuMAX), die(_("could not find '%s' in pack '%s' at offset %"PRIuMAX),
oid_to_hex(&oid), oid_to_hex(&oid),
pack->pack_name, pack->pack_name,
(uintmax_t)offset); (uintmax_t)offset);
@ -1984,7 +1997,7 @@ static off_t get_disk_usage_for_extended(struct bitmap_index *bitmap_git)
continue; continue;
if (oid_object_info_extended(the_repository, &obj->oid, &oi, 0) < 0) if (oid_object_info_extended(the_repository, &obj->oid, &oi, 0) < 0)
die(_("unable to get disk usage of %s"), die(_("unable to get disk usage of '%s'"),
oid_to_hex(&obj->oid)); oid_to_hex(&obj->oid));
total += object_size; total += object_size;