mirror of
https://github.com/git/git.git
synced 2024-06-03 14:36:10 +02:00
2ba582ba4c
We pass our prune expiration to mark_reachable_objects(), which will traverse not only the reachable objects, but consider any recent ones as tips for reachability; seed3038d22f9
(prune: keep objects reachable from recent objects, 2014-10-15) for details. However, this interacts badly with the bitmap code path added infde67d6896
(prune: use bitmaps for reachability traversal, 2019-02-13). If we hit the bitmap-optimized path, we return immediately to avoid the regular traversal, accidentally skipping the "also traverse recent" code. Instead, we should do an if-else for the bitmap versus regular traversal, and then follow up with the "recent" traversal in either case. This reuses the "rev_info" for a bitmap and then a regular traversal, but that should work OK (the bitmap code clears the pending array in the usual way, just like a regular traversal would). Note that I dropped the comment above the regular traversal here. It has little explanatory value, and makes the if-else logic much harder to read. Here are a few variants that I rejected: - it seems like both the reachability and recent traversals could be done in a single traversal. This was rejected byd3038d22f9
(prune: keep objects reachable from recent objects, 2014-10-15), though the balance may be different when using bitmaps. However, there's a subtle correctness issue, too: we use revs->ignore_missing_links for the recent traversal, but not the reachability one. - we could try using bitmaps for the recent traversal, too, which could possibly improve performance. But it would require some fixes in the bitmap code, which uses ignore_missing_links for its own purposes. Plus it would probably not help all that much in practice. We use the reachable tips to generate bitmaps, so those objects are likely not covered by bitmaps (unless they just became unreachable). And in general, we expect the set of unreachable objects to be much smaller anyway, so there's less to gain. The test in t5304 detects the bug and confirms the fix. I also beefed up the tests in t6501, which covers the mtime-checking code more thoroughly, to handle the bitmap case (in addition to just "loose" and "packed" cases). Interestingly, this test doesn't actually detect the bug, because it is running "git gc", and not "prune" directly. And "gc" will call "repack" first, which does not suffer the same bug. So the old-but-reachable-from-recent objects get scooped up into the new pack along with the actually-recent objects, which gives both a recent mtime. But it seemed prudent to get more coverage of the bitmap case for related code. Reported-by: David Emett <dave@sp4m.net> Signed-off-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>
247 lines
5.8 KiB
C
247 lines
5.8 KiB
C
#include "cache.h"
|
|
#include "refs.h"
|
|
#include "tag.h"
|
|
#include "commit.h"
|
|
#include "blob.h"
|
|
#include "diff.h"
|
|
#include "revision.h"
|
|
#include "reachable.h"
|
|
#include "cache-tree.h"
|
|
#include "progress.h"
|
|
#include "list-objects.h"
|
|
#include "packfile.h"
|
|
#include "worktree.h"
|
|
#include "object-store.h"
|
|
#include "pack-bitmap.h"
|
|
|
|
struct connectivity_progress {
|
|
struct progress *progress;
|
|
unsigned long count;
|
|
};
|
|
|
|
static void update_progress(struct connectivity_progress *cp)
|
|
{
|
|
cp->count++;
|
|
if ((cp->count & 1023) == 0)
|
|
display_progress(cp->progress, cp->count);
|
|
}
|
|
|
|
static int add_one_ref(const char *path, const struct object_id *oid,
|
|
int flag, void *cb_data)
|
|
{
|
|
struct rev_info *revs = (struct rev_info *)cb_data;
|
|
struct object *object;
|
|
|
|
if ((flag & REF_ISSYMREF) && (flag & REF_ISBROKEN)) {
|
|
warning("symbolic ref is dangling: %s", path);
|
|
return 0;
|
|
}
|
|
|
|
object = parse_object_or_die(oid, path);
|
|
add_pending_object(revs, object, "");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* The traversal will have already marked us as SEEN, so we
|
|
* only need to handle any progress reporting here.
|
|
*/
|
|
static void mark_object(struct object *obj, const char *name, void *data)
|
|
{
|
|
update_progress(data);
|
|
}
|
|
|
|
static void mark_commit(struct commit *c, void *data)
|
|
{
|
|
mark_object(&c->object, NULL, data);
|
|
}
|
|
|
|
struct recent_data {
|
|
struct rev_info *revs;
|
|
timestamp_t timestamp;
|
|
};
|
|
|
|
static void add_recent_object(const struct object_id *oid,
|
|
timestamp_t mtime,
|
|
struct recent_data *data)
|
|
{
|
|
struct object *obj;
|
|
enum object_type type;
|
|
|
|
if (mtime <= data->timestamp)
|
|
return;
|
|
|
|
/*
|
|
* We do not want to call parse_object here, because
|
|
* inflating blobs and trees could be very expensive.
|
|
* However, we do need to know the correct type for
|
|
* later processing, and the revision machinery expects
|
|
* commits and tags to have been parsed.
|
|
*/
|
|
type = oid_object_info(the_repository, oid, NULL);
|
|
if (type < 0)
|
|
die("unable to get object info for %s", oid_to_hex(oid));
|
|
|
|
switch (type) {
|
|
case OBJ_TAG:
|
|
case OBJ_COMMIT:
|
|
obj = parse_object_or_die(oid, NULL);
|
|
break;
|
|
case OBJ_TREE:
|
|
obj = (struct object *)lookup_tree(the_repository, oid);
|
|
break;
|
|
case OBJ_BLOB:
|
|
obj = (struct object *)lookup_blob(the_repository, oid);
|
|
break;
|
|
default:
|
|
die("unknown object type for %s: %s",
|
|
oid_to_hex(oid), type_name(type));
|
|
}
|
|
|
|
if (!obj)
|
|
die("unable to lookup %s", oid_to_hex(oid));
|
|
|
|
add_pending_object(data->revs, obj, "");
|
|
}
|
|
|
|
static int add_recent_loose(const struct object_id *oid,
|
|
const char *path, void *data)
|
|
{
|
|
struct stat st;
|
|
struct object *obj = lookup_object(the_repository, oid);
|
|
|
|
if (obj && obj->flags & SEEN)
|
|
return 0;
|
|
|
|
if (stat(path, &st) < 0) {
|
|
/*
|
|
* It's OK if an object went away during our iteration; this
|
|
* could be due to a simultaneous repack. But anything else
|
|
* we should abort, since we might then fail to mark objects
|
|
* which should not be pruned.
|
|
*/
|
|
if (errno == ENOENT)
|
|
return 0;
|
|
return error_errno("unable to stat %s", oid_to_hex(oid));
|
|
}
|
|
|
|
add_recent_object(oid, st.st_mtime, data);
|
|
return 0;
|
|
}
|
|
|
|
static int add_recent_packed(const struct object_id *oid,
|
|
struct packed_git *p, uint32_t pos,
|
|
void *data)
|
|
{
|
|
struct object *obj = lookup_object(the_repository, oid);
|
|
|
|
if (obj && obj->flags & SEEN)
|
|
return 0;
|
|
add_recent_object(oid, p->mtime, data);
|
|
return 0;
|
|
}
|
|
|
|
int add_unseen_recent_objects_to_traversal(struct rev_info *revs,
|
|
timestamp_t timestamp)
|
|
{
|
|
struct recent_data data;
|
|
int r;
|
|
|
|
data.revs = revs;
|
|
data.timestamp = timestamp;
|
|
|
|
r = for_each_loose_object(add_recent_loose, &data,
|
|
FOR_EACH_OBJECT_LOCAL_ONLY);
|
|
if (r)
|
|
return r;
|
|
return for_each_packed_object(add_recent_packed, &data,
|
|
FOR_EACH_OBJECT_LOCAL_ONLY);
|
|
}
|
|
|
|
static void *lookup_object_by_type(struct repository *r,
|
|
const struct object_id *oid,
|
|
enum object_type type)
|
|
{
|
|
switch (type) {
|
|
case OBJ_COMMIT:
|
|
return lookup_commit(r, oid);
|
|
case OBJ_TREE:
|
|
return lookup_tree(r, oid);
|
|
case OBJ_TAG:
|
|
return lookup_tag(r, oid);
|
|
case OBJ_BLOB:
|
|
return lookup_blob(r, oid);
|
|
default:
|
|
die("BUG: unknown object type %d", type);
|
|
}
|
|
}
|
|
|
|
static int mark_object_seen(const struct object_id *oid,
|
|
enum object_type type,
|
|
int exclude,
|
|
uint32_t name_hash,
|
|
struct packed_git *found_pack,
|
|
off_t found_offset)
|
|
{
|
|
struct object *obj = lookup_object_by_type(the_repository, oid, type);
|
|
if (!obj)
|
|
die("unable to create object '%s'", oid_to_hex(oid));
|
|
|
|
obj->flags |= SEEN;
|
|
return 0;
|
|
}
|
|
|
|
void mark_reachable_objects(struct rev_info *revs, int mark_reflog,
|
|
timestamp_t mark_recent, struct progress *progress)
|
|
{
|
|
struct connectivity_progress cp;
|
|
struct bitmap_index *bitmap_git;
|
|
|
|
/*
|
|
* Set up revision parsing, and mark us as being interested
|
|
* in all object types, not just commits.
|
|
*/
|
|
revs->tag_objects = 1;
|
|
revs->blob_objects = 1;
|
|
revs->tree_objects = 1;
|
|
|
|
/* Add all refs from the index file */
|
|
add_index_objects_to_pending(revs, 0);
|
|
|
|
/* Add all external refs */
|
|
for_each_ref(add_one_ref, revs);
|
|
|
|
/* detached HEAD is not included in the list above */
|
|
head_ref(add_one_ref, revs);
|
|
other_head_refs(add_one_ref, revs);
|
|
|
|
/* Add all reflog info */
|
|
if (mark_reflog)
|
|
add_reflogs_to_pending(revs, 0);
|
|
|
|
cp.progress = progress;
|
|
cp.count = 0;
|
|
|
|
bitmap_git = prepare_bitmap_walk(revs, NULL);
|
|
if (bitmap_git) {
|
|
traverse_bitmap_commit_list(bitmap_git, revs, mark_object_seen);
|
|
free_bitmap_index(bitmap_git);
|
|
} else {
|
|
if (prepare_revision_walk(revs))
|
|
die("revision walk setup failed");
|
|
traverse_commit_list(revs, mark_commit, mark_object, &cp);
|
|
}
|
|
|
|
if (mark_recent) {
|
|
revs->ignore_missing_links = 1;
|
|
if (add_unseen_recent_objects_to_traversal(revs, mark_recent))
|
|
die("unable to mark recent objects");
|
|
if (prepare_revision_walk(revs))
|
|
die("revision walk setup failed");
|
|
traverse_commit_list(revs, mark_commit, mark_object, &cp);
|
|
}
|
|
|
|
display_progress(cp.progress, cp.count);
|
|
}
|