Future callers will want a function to fill a 'struct pack_entry' for a
given object id but _only_ from its position in any kept pack(s). They
could accomplish this by calling 'find_pack_entry()' and checking
whether the found pack is kept or not, but this is insufficient, since
there may be duplicate objects (and the mru cache makes it unpredictable
which variant we'll get).
Teach this new function to treat the two different kinds of kept packs
(on disk ones with .keep files, as well as in-core ones which are set by
manually poking the 'pack_keep_in_core' bit) separately. This will
become important for callers that only want to respect a certain kind of
kept pack.
Introduce 'find_kept_pack_entry()' which behaves like
'find_pack_entry()', except that it skips over packs which are not
marked kept. Callers will be added in subsequent patches.
Co-authored-by: Jeff King <peff@xxxxxxxx>
Signed-off-by: Jeff King <peff@xxxxxxxx>
Signed-off-by: Taylor Blau <me@xxxxxxxxxxxx>
---
packfile.c | 64 +++++++++++++++++++++++++++++++++++++++++++++++++-----
packfile.h | 6 +++++
2 files changed, 65 insertions(+), 5 deletions(-)
diff --git a/packfile.c b/packfile.c
index 62d92e0c7c..30f43a1a35 100644
--- a/packfile.c
+++ b/packfile.c
@@ -2015,7 +2015,10 @@ static int fill_pack_entry(const struct object_id *oid,
return 1;
}
-int find_pack_entry(struct repository *r, const struct object_id *oid, struct pack_entry *e)
+static int find_one_pack_entry(struct repository *r,
+ const struct object_id *oid,
+ struct pack_entry *e,
+ int kept_only)
{
struct list_head *pos;
struct multi_pack_index *m;
@@ -2025,26 +2028,77 @@ int find_pack_entry(struct repository *r, const struct object_id *oid, struct pa
return 0;
for (m = r->objects->multi_pack_index; m; m = m->next) {
- if (fill_midx_entry(r, oid, e, m))
+ if (!(fill_midx_entry(r, oid, e, m)))
+ continue;
+
+ if (!kept_only)
+ return 1;
+
+ if (((kept_only & ON_DISK_KEEP_PACKS) && e->p->pack_keep) ||
+ ((kept_only & IN_CORE_KEEP_PACKS) && e->p->pack_keep_in_core))
return 1;
}
list_for_each(pos, &r->objects->packed_git_mru) {
struct packed_git *p = list_entry(pos, struct packed_git, mru);
- if (!p->multi_pack_index && fill_pack_entry(oid, e, p)) {
- list_move(&p->mru, &r->objects->packed_git_mru);
- return 1;
+ if (p->multi_pack_index && !kept_only) {
+ /*
+ * If this pack is covered by the MIDX, we'd have found
+ * the object already in the loop above if it was here,
+ * so don't bother looking.
+ *
+ * The exception is if we are looking only at kept
+ * packs. An object can be present in two packs covered
+ * by the MIDX, one kept and one not-kept. And as the
+ * MIDX points to only one copy of each object, it might
+ * have returned only the non-kept version above. We
+ * have to check again to be thorough.
+ */
+ continue;
+ }
+ if (!kept_only ||
+ (((kept_only & ON_DISK_KEEP_PACKS) && p->pack_keep) ||
+ ((kept_only & IN_CORE_KEEP_PACKS) && p->pack_keep_in_core))) {
+ if (fill_pack_entry(oid, e, p)) {
+ list_move(&p->mru, &r->objects->packed_git_mru);
+ return 1;
+ }
}
}
return 0;
}
+int find_pack_entry(struct repository *r, const struct object_id *oid, struct pack_entry *e)
+{
+ return find_one_pack_entry(r, oid, e, 0);
+}
+
+int find_kept_pack_entry(struct repository *r,
+ const struct object_id *oid,
+ unsigned flags,
+ struct pack_entry *e)
+{
+ /*
+ * Load all packs, including midx packs, since our "kept" strategy
+ * relies on that. We're relying on the side effect of it setting up
+ * r->objects->packed_git, which is a little ugly.
+ */
+ get_all_packs(r);
+ return find_one_pack_entry(r, oid, e, flags);
+}
+
int has_object_pack(const struct object_id *oid)
{
struct pack_entry e;
return find_pack_entry(the_repository, oid, &e);
}
+int has_object_kept_pack(const struct object_id *oid, unsigned flags)
+{
+ struct pack_entry e;
+ return find_kept_pack_entry(the_repository, oid, flags, &e);
+}
+
int has_pack_index(const unsigned char *sha1)
{
struct stat st;
diff --git a/packfile.h b/packfile.h
index a58fc738e0..624327f64d 100644
--- a/packfile.h
+++ b/packfile.h
@@ -161,13 +161,19 @@ int packed_object_info(struct repository *r,
void mark_bad_packed_object(struct packed_git *p, const unsigned char *sha1);
const struct packed_git *has_packed_and_bad(struct repository *r, const unsigned char *sha1);
+#define ON_DISK_KEEP_PACKS 1
+#define IN_CORE_KEEP_PACKS 2
+#define ALL_KEEP_PACKS (ON_DISK_KEEP_PACKS | IN_CORE_KEEP_PACKS)
+
/*
* Iff a pack file in the given repository contains the object named by sha1,
* return true and store its location to e.
*/
int find_pack_entry(struct repository *r, const struct object_id *oid, struct pack_entry *e);
+int find_kept_pack_entry(struct repository *r, const struct object_id *oid, unsigned flags, struct pack_entry *e);
int has_object_pack(const struct object_id *oid);
+int has_object_kept_pack(const struct object_id *oid, unsigned flags);
int has_pack_index(const unsigned char *sha1);
--
2.30.0.138.g6d7191ea01
