fix repack with --max-pack-size

Two issues here:

1) git-repack -a --max-pack-size=10 on the GIT repo dies pretty quick.
There is a lot of confusion about deltas that were suposed to be
reused from another pack but that get stored undeltified due to pack
limit and object size doesn't match entry->size anymore.  This test
is not really worth the complexity for determining when it is valid
so get rid of it.

2) If pack limit is reached, the object buffer is freed, including when
it comes from a cached delta data.  In practice the object will be
stored in a subsequent pack undeltified, but let's make sure no
pointer to freed data subsists by clearing entry->delta_data.

I also reorganized that code a bit to make it more readable.

Signed-off-by: Nicolas Pitre <nico@cam.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>

diff --git a/builtin-pack-objects.c b/builtin-pack-objects.c
index 41472fcbd09b4ab5c1732d7656ebc70e4fb563dd..ccb25f6a9c298bd977c5f55a84dd9a20a1e54e23 100644 (file)
--- a/builtin-pack-objects.c
+++ b/builtin-pack-objects.c
@@ -410,31 +410,24 @@ static unsigned long write_object(struct sha1file *f,
                z_stream stream;
                unsigned long maxsize;
                void *out;
                z_stream stream;
                unsigned long maxsize;
                void *out;

-               if (entry->delta_data && usable_delta) {
-                       buf = entry->delta_data;
+               if (!usable_delta) {
+                       buf = read_sha1_file(entry->sha1, &obj_type, &size);
+                       if (!buf)
+                               die("unable to read %s", sha1_to_hex(entry->sha1));
+               } else if (entry->delta_data) {

                        size = entry->delta_size;
                        size = entry->delta_size;

+                       buf = entry->delta_data;
+                       entry->delta_data = NULL;

                        obj_type = (allow_ofs_delta && entry->delta->offset) ?
                                OBJ_OFS_DELTA : OBJ_REF_DELTA;
                } else {
                        buf = read_sha1_file(entry->sha1, &type, &size);
                        if (!buf)
                                die("unable to read %s", sha1_to_hex(entry->sha1));
                        obj_type = (allow_ofs_delta && entry->delta->offset) ?
                                OBJ_OFS_DELTA : OBJ_REF_DELTA;
                } else {
                        buf = read_sha1_file(entry->sha1, &type, &size);
                        if (!buf)
                                die("unable to read %s", sha1_to_hex(entry->sha1));

-                       if (size != entry->size)
-                               die("object %s size inconsistency (%lu vs %lu)",
-                                   sha1_to_hex(entry->sha1), size, entry->size);
-                       if (usable_delta) {
-                               buf = delta_against(buf, size, entry);
-                               size = entry->delta_size;
-                               obj_type = (allow_ofs_delta && entry->delta->offset) ?
-                                       OBJ_OFS_DELTA : OBJ_REF_DELTA;
-                       } else {
-                               /*
-                                * recover real object type in case
-                                * check_object() wanted to re-use a delta,
-                                * but we couldn't since base was in previous split pack
-                                */
-                               obj_type = type;
-                       }
+                       buf = delta_against(buf, size, entry);
+                       size = entry->delta_size;
+                       obj_type = (allow_ofs_delta && entry->delta->offset) ?
+                               OBJ_OFS_DELTA : OBJ_REF_DELTA;

                }
                /* compress the data to store and put compressed length in datalen */
                memset(&stream, 0, sizeof(stream));
                }
                /* compress the data to store and put compressed length in datalen */
                memset(&stream, 0, sizeof(stream));