builtin/unpack-objects.c

   1 #include "builtin.h"
   2 #include "cache.h"
   3 #include "bulk-checkin.h"
   4 #include "config.h"
   5 #include "environment.h"
   6 #include "gettext.h"
   7 #include "git-zlib.h"
   8 #include "hex.h"
   9 #include "object-store.h"
  10 #include "object.h"
  11 #include "delta.h"
  12 #include "pack.h"
  13 #include "blob.h"
  14 #include "commit.h"
  15 #include "replace-object.h"
  16 #include "tag.h"
  17 #include "tree.h"
  18 #include "tree-walk.h"
  19 #include "progress.h"
  20 #include "decorate.h"
  21 #include "fsck.h"
  22
  23 static int dry_run, quiet, recover, has_errors, strict;
  24 static const char unpack_usage[] = "git unpack-objects [-n] [-q] [-r] [--strict]";
  25
  26 /* We always read in 4kB chunks. */
  27 static unsigned char buffer[4096];
  28 static unsigned int offset, len;
  29 static off_t consumed_bytes;
  30 static off_t max_input_size;
  31 static git_hash_ctx ctx;
  32 static struct fsck_options fsck_options = FSCK_OPTIONS_STRICT;
  33 static struct progress *progress;
  34
  35 /*
  36  * When running under --strict mode, objects whose reachability are
  37  * suspect are kept in core without getting written in the object
  38  * store.
  39  */
  40 struct obj_buffer {
  41         char *buffer;
  42         unsigned long size;
  43 };
  44
  45 static struct decoration obj_decorate;
  46
  47 static struct obj_buffer *lookup_object_buffer(struct object *base)
  48 {
  49         return lookup_decoration(&obj_decorate, base);
  50 }
  51
  52 static void add_object_buffer(struct object *object, char *buffer, unsigned long size)
  53 {
  54         struct obj_buffer *obj;
  55         CALLOC_ARRAY(obj, 1);
  56         obj->buffer = buffer;
  57         obj->size = size;
  58         if (add_decoration(&obj_decorate, object, obj))
  59                 die("object %s tried to add buffer twice!", oid_to_hex(&object->oid));
  60 }
  61
  62 /*
  63  * Make sure at least "min" bytes are available in the buffer, and
  64  * return the pointer to the buffer.
  65  */
  66 static void *fill(int min)
  67 {
  68         if (min <= len)
  69                 return buffer + offset;
  70         if (min > sizeof(buffer))
  71                 die("cannot fill %d bytes", min);
  72         if (offset) {
  73                 the_hash_algo->update_fn(&ctx, buffer, offset);
  74                 memmove(buffer, buffer + offset, len);
  75                 offset = 0;
  76         }
  77         do {
  78                 ssize_t ret = xread(0, buffer + len, sizeof(buffer) - len);
  79                 if (ret <= 0) {
  80                         if (!ret)
  81                                 die("early EOF");
  82                         die_errno("read error on input");
  83                 }
  84                 len += ret;
  85         } while (len < min);
  86         return buffer;
  87 }
  88
  89 static void use(int bytes)
  90 {
  91         if (bytes > len)
  92                 die("used more bytes than were available");
  93         len -= bytes;
  94         offset += bytes;
  95
  96         /* make sure off_t is sufficiently large not to wrap */
  97         if (signed_add_overflows(consumed_bytes, bytes))
  98                 die("pack too large for current definition of off_t");
  99         consumed_bytes += bytes;
 100         if (max_input_size && consumed_bytes > max_input_size)
 101                 die(_("pack exceeds maximum allowed size"));
 102         display_throughput(progress, consumed_bytes);
 103 }
 104
 105 /*
 106  * Decompress zstream from the standard input into a newly
 107  * allocated buffer of specified size and return the buffer.
 108  * The caller is responsible to free the returned buffer.
 109  *
 110  * But for dry_run mode, "get_data()" is only used to check the
 111  * integrity of data, and the returned buffer is not used at all.
 112  * Therefore, in dry_run mode, "get_data()" will release the small
 113  * allocated buffer which is reused to hold temporary zstream output
 114  * and return NULL instead of returning garbage data.
 115  */
 116 static void *get_data(unsigned long size)
 117 {
 118         git_zstream stream;
 119         unsigned long bufsize = dry_run && size > 8192 ? 8192 : size;
 120         void *buf = xmallocz(bufsize);
 121
 122         memset(&stream, 0, sizeof(stream));
 123
 124         stream.next_out = buf;
 125         stream.avail_out = bufsize;
 126         stream.next_in = fill(1);
 127         stream.avail_in = len;
 128         git_inflate_init(&stream);
 129
 130         for (;;) {
 131                 int ret = git_inflate(&stream, 0);
 132                 use(len - stream.avail_in);
 133                 if (stream.total_out == size && ret == Z_STREAM_END)
 134                         break;
 135                 if (ret != Z_OK) {
 136                         error("inflate returned %d", ret);
 137                         FREE_AND_NULL(buf);
 138                         if (!recover)
 139                                 exit(1);
 140                         has_errors = 1;
 141                         break;
 142                 }
 143                 stream.next_in = fill(1);
 144                 stream.avail_in = len;
 145                 if (dry_run) {
 146                         /* reuse the buffer in dry_run mode */
 147                         stream.next_out = buf;
 148                         stream.avail_out = bufsize > size - stream.total_out ?
 149                                                    size - stream.total_out :
 150                                                    bufsize;
 151                 }
 152         }
 153         git_inflate_end(&stream);
 154         if (dry_run)
 155                 FREE_AND_NULL(buf);
 156         return buf;
 157 }
 158
 159 struct delta_info {
 160         struct object_id base_oid;
 161         unsigned nr;
 162         off_t base_offset;
 163         unsigned long size;
 164         void *delta;
 165         struct delta_info *next;
 166 };
 167
 168 static struct delta_info *delta_list;
 169
 170 static void add_delta_to_list(unsigned nr, const struct object_id *base_oid,
 171                               off_t base_offset,
 172                               void *delta, unsigned long size)
 173 {
 174         struct delta_info *info = xmalloc(sizeof(*info));
 175
 176         oidcpy(&info->base_oid, base_oid);
 177         info->base_offset = base_offset;
 178         info->size = size;
 179         info->delta = delta;
 180         info->nr = nr;
 181         info->next = delta_list;
 182         delta_list = info;
 183 }
 184
 185 struct obj_info {
 186         off_t offset;
 187         struct object_id oid;
 188         struct object *obj;
 189 };
 190
 191 /* Remember to update object flag allocation in object.h */
 192 #define FLAG_OPEN (1u<<20)
 193 #define FLAG_WRITTEN (1u<<21)
 194
 195 static struct obj_info *obj_list;
 196 static unsigned nr_objects;
 197
 198 /*
 199  * Called only from check_object() after it verified this object
 200  * is Ok.
 201  */
 202 static void write_cached_object(struct object *obj, struct obj_buffer *obj_buf)
 203 {
 204         struct object_id oid;
 205
 206         if (write_object_file(obj_buf->buffer, obj_buf->size,
 207                               obj->type, &oid) < 0)
 208                 die("failed to write object %s", oid_to_hex(&obj->oid));
 209         obj->flags |= FLAG_WRITTEN;
 210 }
 211
 212 /*
 213  * At the very end of the processing, write_rest() scans the objects
 214  * that have reachability requirements and calls this function.
 215  * Verify its reachability and validity recursively and write it out.
 216  */
 217 static int check_object(struct object *obj, enum object_type type,
 218                         void *data, struct fsck_options *options)
 219 {
 220         struct obj_buffer *obj_buf;
 221
 222         if (!obj)
 223                 return 1;
 224
 225         if (obj->flags & FLAG_WRITTEN)
 226                 return 0;
 227
 228         if (type != OBJ_ANY && obj->type != type)
 229                 die("object type mismatch");
 230
 231         if (!(obj->flags & FLAG_OPEN)) {
 232                 unsigned long size;
 233                 int type = oid_object_info(the_repository, &obj->oid, &size);
 234                 if (type != obj->type || type <= 0)
 235                         die("object of unexpected type");
 236                 obj->flags |= FLAG_WRITTEN;
 237                 return 0;
 238         }
 239
 240         obj_buf = lookup_object_buffer(obj);
 241         if (!obj_buf)
 242                 die("Whoops! Cannot find object '%s'", oid_to_hex(&obj->oid));
 243         if (fsck_object(obj, obj_buf->buffer, obj_buf->size, &fsck_options))
 244                 die("fsck error in packed object");
 245         fsck_options.walk = check_object;
 246         if (fsck_walk(obj, NULL, &fsck_options))
 247                 die("Error on reachable objects of %s", oid_to_hex(&obj->oid));
 248         write_cached_object(obj, obj_buf);
 249         return 0;
 250 }
 251
 252 static void write_rest(void)
 253 {
 254         unsigned i;
 255         for (i = 0; i < nr_objects; i++) {
 256                 if (obj_list[i].obj)
 257                         check_object(obj_list[i].obj, OBJ_ANY, NULL, NULL);
 258         }
 259 }
 260
 261 static void added_object(unsigned nr, enum object_type type,
 262                          void *data, unsigned long size);
 263
 264 /*
 265  * Write out nr-th object from the list, now we know the contents
 266  * of it.  Under --strict, this buffers structured objects in-core,
 267  * to be checked at the end.
 268  */
 269 static void write_object(unsigned nr, enum object_type type,
 270                          void *buf, unsigned long size)
 271 {
 272         if (!strict) {
 273                 if (write_object_file(buf, size, type,
 274                                       &obj_list[nr].oid) < 0)
 275                         die("failed to write object");
 276                 added_object(nr, type, buf, size);
 277                 free(buf);
 278                 obj_list[nr].obj = NULL;
 279         } else if (type == OBJ_BLOB) {
 280                 struct blob *blob;
 281                 if (write_object_file(buf, size, type,
 282                                       &obj_list[nr].oid) < 0)
 283                         die("failed to write object");
 284                 added_object(nr, type, buf, size);
 285                 free(buf);
 286
 287                 blob = lookup_blob(the_repository, &obj_list[nr].oid);
 288                 if (blob)
 289                         blob->object.flags |= FLAG_WRITTEN;
 290                 else
 291                         die("invalid blob object");
 292                 obj_list[nr].obj = NULL;
 293         } else {
 294                 struct object *obj;
 295                 int eaten;
 296                 hash_object_file(the_hash_algo, buf, size, type,
 297                                  &obj_list[nr].oid);
 298                 added_object(nr, type, buf, size);
 299                 obj = parse_object_buffer(the_repository, &obj_list[nr].oid,
 300                                           type, size, buf,
 301                                           &eaten);
 302                 if (!obj)
 303                         die("invalid %s", type_name(type));
 304                 add_object_buffer(obj, buf, size);
 305                 obj->flags |= FLAG_OPEN;
 306                 obj_list[nr].obj = obj;
 307         }
 308 }
 309
 310 static void resolve_delta(unsigned nr, enum object_type type,
 311                           void *base, unsigned long base_size,
 312                           void *delta, unsigned long delta_size)
 313 {
 314         void *result;
 315         unsigned long result_size;
 316
 317         result = patch_delta(base, base_size,
 318                              delta, delta_size,
 319                              &result_size);
 320         if (!result)
 321                 die("failed to apply delta");
 322         free(delta);
 323         write_object(nr, type, result, result_size);
 324 }
 325
 326 /*
 327  * We now know the contents of an object (which is nr-th in the pack);
 328  * resolve all the deltified objects that are based on it.
 329  */
 330 static void added_object(unsigned nr, enum object_type type,
 331                          void *data, unsigned long size)
 332 {
 333         struct delta_info **p = &delta_list;
 334         struct delta_info *info;
 335
 336         while ((info = *p) != NULL) {
 337                 if (oideq(&info->base_oid, &obj_list[nr].oid) ||
 338                     info->base_offset == obj_list[nr].offset) {
 339                         *p = info->next;
 340                         p = &delta_list;
 341                         resolve_delta(info->nr, type, data, size,
 342                                       info->delta, info->size);
 343                         free(info);
 344                         continue;
 345                 }
 346                 p = &info->next;
 347         }
 348 }
 349
 350 static void unpack_non_delta_entry(enum object_type type, unsigned long size,
 351                                    unsigned nr)
 352 {
 353         void *buf = get_data(size);
 354
 355         if (buf)
 356                 write_object(nr, type, buf, size);
 357 }
 358
 359 struct input_zstream_data {
 360         git_zstream *zstream;
 361         unsigned char buf[8192];
 362         int status;
 363 };
 364
 365 static const void *feed_input_zstream(struct input_stream *in_stream,
 366                                       unsigned long *readlen)
 367 {
 368         struct input_zstream_data *data = in_stream->data;
 369         git_zstream *zstream = data->zstream;
 370         void *in = fill(1);
 371
 372         if (in_stream->is_finished) {
 373                 *readlen = 0;
 374                 return NULL;
 375         }
 376
 377         zstream->next_out = data->buf;
 378         zstream->avail_out = sizeof(data->buf);
 379         zstream->next_in = in;
 380         zstream->avail_in = len;
 381
 382         data->status = git_inflate(zstream, 0);
 383
 384         in_stream->is_finished = data->status != Z_OK;
 385         use(len - zstream->avail_in);
 386         *readlen = sizeof(data->buf) - zstream->avail_out;
 387
 388         return data->buf;
 389 }
 390
 391 static void stream_blob(unsigned long size, unsigned nr)
 392 {
 393         git_zstream zstream = { 0 };
 394         struct input_zstream_data data = { 0 };
 395         struct input_stream in_stream = {
 396                 .read = feed_input_zstream,
 397                 .data = &data,
 398         };
 399         struct obj_info *info = &obj_list[nr];
 400
 401         data.zstream = &zstream;
 402         git_inflate_init(&zstream);
 403
 404         if (stream_loose_object(&in_stream, size, &info->oid))
 405                 die(_("failed to write object in stream"));
 406
 407         if (data.status != Z_STREAM_END)
 408                 die(_("inflate returned (%d)"), data.status);
 409         git_inflate_end(&zstream);
 410
 411         if (strict) {
 412                 struct blob *blob = lookup_blob(the_repository, &info->oid);
 413
 414                 if (!blob)
 415                         die(_("invalid blob object from stream"));
 416                 blob->object.flags |= FLAG_WRITTEN;
 417         }
 418         info->obj = NULL;
 419 }
 420
 421 static int resolve_against_held(unsigned nr, const struct object_id *base,
 422                                 void *delta_data, unsigned long delta_size)
 423 {
 424         struct object *obj;
 425         struct obj_buffer *obj_buffer;
 426         obj = lookup_object(the_repository, base);
 427         if (!obj)
 428                 return 0;
 429         obj_buffer = lookup_object_buffer(obj);
 430         if (!obj_buffer)
 431                 return 0;
 432         resolve_delta(nr, obj->type, obj_buffer->buffer,
 433                       obj_buffer->size, delta_data, delta_size);
 434         return 1;
 435 }
 436
 437 static void unpack_delta_entry(enum object_type type, unsigned long delta_size,
 438                                unsigned nr)
 439 {
 440         void *delta_data, *base;
 441         unsigned long base_size;
 442         struct object_id base_oid;
 443
 444         if (type == OBJ_REF_DELTA) {
 445                 oidread(&base_oid, fill(the_hash_algo->rawsz));
 446                 use(the_hash_algo->rawsz);
 447                 delta_data = get_data(delta_size);
 448                 if (!delta_data)
 449                         return;
 450                 if (repo_has_object_file(the_repository, &base_oid))
 451                         ; /* Ok we have this one */
 452                 else if (resolve_against_held(nr, &base_oid,
 453                                               delta_data, delta_size))
 454                         return; /* we are done */
 455                 else {
 456                         /* cannot resolve yet --- queue it */
 457                         oidclr(&obj_list[nr].oid);
 458                         add_delta_to_list(nr, &base_oid, 0, delta_data, delta_size);
 459                         return;
 460                 }
 461         } else {
 462                 unsigned base_found = 0;
 463                 unsigned char *pack, c;
 464                 off_t base_offset;
 465                 unsigned lo, mid, hi;
 466
 467                 pack = fill(1);
 468                 c = *pack;
 469                 use(1);
 470                 base_offset = c & 127;
 471                 while (c & 128) {
 472                         base_offset += 1;
 473                         if (!base_offset || MSB(base_offset, 7))
 474                                 die("offset value overflow for delta base object");
 475                         pack = fill(1);
 476                         c = *pack;
 477                         use(1);
 478                         base_offset = (base_offset << 7) + (c & 127);
 479                 }
 480                 base_offset = obj_list[nr].offset - base_offset;
 481                 if (base_offset <= 0 || base_offset >= obj_list[nr].offset)
 482                         die("offset value out of bound for delta base object");
 483
 484                 delta_data = get_data(delta_size);
 485                 if (!delta_data)
 486                         return;
 487                 lo = 0;
 488                 hi = nr;
 489                 while (lo < hi) {
 490                         mid = lo + (hi - lo) / 2;
 491                         if (base_offset < obj_list[mid].offset) {
 492                                 hi = mid;
 493                         } else if (base_offset > obj_list[mid].offset) {
 494                                 lo = mid + 1;
 495                         } else {
 496                                 oidcpy(&base_oid, &obj_list[mid].oid);
 497                                 base_found = !is_null_oid(&base_oid);
 498                                 break;
 499                         }
 500                 }
 501                 if (!base_found) {
 502                         /*
 503                          * The delta base object is itself a delta that
 504                          * has not been resolved yet.
 505                          */
 506                         oidclr(&obj_list[nr].oid);
 507                         add_delta_to_list(nr, null_oid(), base_offset,
 508                                           delta_data, delta_size);
 509                         return;
 510                 }
 511         }
 512
 513         if (resolve_against_held(nr, &base_oid, delta_data, delta_size))
 514                 return;
 515
 516         base = repo_read_object_file(the_repository, &base_oid, &type,
 517                                      &base_size);
 518         if (!base) {
 519                 error("failed to read delta-pack base object %s",
 520                       oid_to_hex(&base_oid));
 521                 if (!recover)
 522                         exit(1);
 523                 has_errors = 1;
 524                 return;
 525         }
 526         resolve_delta(nr, type, base, base_size, delta_data, delta_size);
 527         free(base);
 528 }
 529
 530 static void unpack_one(unsigned nr)
 531 {
 532         unsigned shift;
 533         unsigned char *pack;
 534         unsigned long size, c;
 535         enum object_type type;
 536
 537         obj_list[nr].offset = consumed_bytes;
 538
 539         pack = fill(1);
 540         c = *pack;
 541         use(1);
 542         type = (c >> 4) & 7;
 543         size = (c & 15);
 544         shift = 4;
 545         while (c & 0x80) {
 546                 pack = fill(1);
 547                 c = *pack;
 548                 use(1);
 549                 size += (c & 0x7f) << shift;
 550                 shift += 7;
 551         }
 552
 553         switch (type) {
 554         case OBJ_BLOB:
 555                 if (!dry_run && size > big_file_threshold) {
 556                         stream_blob(size, nr);
 557                         return;
 558                 }
 559                 /* fallthrough */
 560         case OBJ_COMMIT:
 561         case OBJ_TREE:
 562         case OBJ_TAG:
 563                 unpack_non_delta_entry(type, size, nr);
 564                 return;
 565         case OBJ_REF_DELTA:
 566         case OBJ_OFS_DELTA:
 567                 unpack_delta_entry(type, size, nr);
 568                 return;
 569         default:
 570                 error("bad object type %d", type);
 571                 has_errors = 1;
 572                 if (recover)
 573                         return;
 574                 exit(1);
 575         }
 576 }
 577
 578 static void unpack_all(void)
 579 {
 580         int i;
 581         struct pack_header *hdr = fill(sizeof(struct pack_header));
 582
 583         nr_objects = ntohl(hdr->hdr_entries);
 584
 585         if (ntohl(hdr->hdr_signature) != PACK_SIGNATURE)
 586                 die("bad pack file");
 587         if (!pack_version_ok(hdr->hdr_version))
 588                 die("unknown pack file version %"PRIu32,
 589                         ntohl(hdr->hdr_version));
 590         use(sizeof(struct pack_header));
 591
 592         if (!quiet)
 593                 progress = start_progress(_("Unpacking objects"), nr_objects);
 594         CALLOC_ARRAY(obj_list, nr_objects);
 595         begin_odb_transaction();
 596         for (i = 0; i < nr_objects; i++) {
 597                 unpack_one(i);
 598                 display_progress(progress, i + 1);
 599         }
 600         end_odb_transaction();
 601         stop_progress(&progress);
 602
 603         if (delta_list)
 604                 die("unresolved deltas left after unpacking");
 605 }
 606
 607 int cmd_unpack_objects(int argc, const char **argv, const char *prefix UNUSED)
 608 {
 609         int i;
 610         struct object_id oid;
 611
 612         disable_replace_refs();
 613
 614         git_config(git_default_config, NULL);
 615
 616         quiet = !isatty(2);
 617
 618         for (i = 1 ; i < argc; i++) {
 619                 const char *arg = argv[i];
 620
 621                 if (*arg == '-') {
 622                         if (!strcmp(arg, "-n")) {
 623                                 dry_run = 1;
 624                                 continue;
 625                         }
 626                         if (!strcmp(arg, "-q")) {
 627                                 quiet = 1;
 628                                 continue;
 629                         }
 630                         if (!strcmp(arg, "-r")) {
 631                                 recover = 1;
 632                                 continue;
 633                         }
 634                         if (!strcmp(arg, "--strict")) {
 635                                 strict = 1;
 636                                 continue;
 637                         }
 638                         if (skip_prefix(arg, "--strict=", &arg)) {
 639                                 strict = 1;
 640                                 fsck_set_msg_types(&fsck_options, arg);
 641                                 continue;
 642                         }
 643                         if (starts_with(arg, "--pack_header=")) {
 644                                 struct pack_header *hdr;
 645                                 char *c;
 646
 647                                 hdr = (struct pack_header *)buffer;
 648                                 hdr->hdr_signature = htonl(PACK_SIGNATURE);
 649                                 hdr->hdr_version = htonl(strtoul(arg + 14, &c, 10));
 650                                 if (*c != ',')
 651                                         die("bad %s", arg);
 652                                 hdr->hdr_entries = htonl(strtoul(c + 1, &c, 10));
 653                                 if (*c)
 654                                         die("bad %s", arg);
 655                                 len = sizeof(*hdr);
 656                                 continue;
 657                         }
 658                         if (skip_prefix(arg, "--max-input-size=", &arg)) {
 659                                 max_input_size = strtoumax(arg, NULL, 10);
 660                                 continue;
 661                         }
 662                         usage(unpack_usage);
 663                 }
 664
 665                 /* We don't take any non-flag arguments now.. Maybe some day */
 666                 usage(unpack_usage);
 667         }
 668         the_hash_algo->init_fn(&ctx);
 669         unpack_all();
 670         the_hash_algo->update_fn(&ctx, buffer, offset);
 671         the_hash_algo->final_oid_fn(&oid, &ctx);
 672         if (strict) {
 673                 write_rest();
 674                 if (fsck_finish(&fsck_options))
 675                         die(_("fsck error in pack objects"));
 676         }
 677         if (!hasheq(fill(the_hash_algo->rawsz), oid.hash))
 678                 die("final sha1 did not match");
 679         use(the_hash_algo->rawsz);
 680
 681         /* Write the last part of the buffer to stdout */
 682         while (len) {
 683                 int ret = xwrite(1, buffer + offset, len);
 684                 if (ret <= 0)
 685                         break;
 686                 len -= ret;
 687                 offset += ret;
 688         }
 689
 690         /* All done */
 691         return has_errors;
 692 }