object.con commit commit: add repository argument to lookup_commit_reference (2122f67)
   1#include "cache.h"
   2#include "object.h"
   3#include "replace-object.h"
   4#include "object-store.h"
   5#include "blob.h"
   6#include "tree.h"
   7#include "commit.h"
   8#include "tag.h"
   9#include "alloc.h"
  10#include "object-store.h"
  11#include "packfile.h"
  12
  13unsigned int get_max_object_index(void)
  14{
  15        return the_repository->parsed_objects->obj_hash_size;
  16}
  17
  18struct object *get_indexed_object(unsigned int idx)
  19{
  20        return the_repository->parsed_objects->obj_hash[idx];
  21}
  22
  23static const char *object_type_strings[] = {
  24        NULL,           /* OBJ_NONE = 0 */
  25        "commit",       /* OBJ_COMMIT = 1 */
  26        "tree",         /* OBJ_TREE = 2 */
  27        "blob",         /* OBJ_BLOB = 3 */
  28        "tag",          /* OBJ_TAG = 4 */
  29};
  30
  31const char *type_name(unsigned int type)
  32{
  33        if (type >= ARRAY_SIZE(object_type_strings))
  34                return NULL;
  35        return object_type_strings[type];
  36}
  37
  38int type_from_string_gently(const char *str, ssize_t len, int gentle)
  39{
  40        int i;
  41
  42        if (len < 0)
  43                len = strlen(str);
  44
  45        for (i = 1; i < ARRAY_SIZE(object_type_strings); i++)
  46                if (!strncmp(str, object_type_strings[i], len) &&
  47                    object_type_strings[i][len] == '\0')
  48                        return i;
  49
  50        if (gentle)
  51                return -1;
  52
  53        die("invalid object type \"%s\"", str);
  54}
  55
  56/*
  57 * Return a numerical hash value between 0 and n-1 for the object with
  58 * the specified sha1.  n must be a power of 2.  Please note that the
  59 * return value is *not* consistent across computer architectures.
  60 */
  61static unsigned int hash_obj(const unsigned char *sha1, unsigned int n)
  62{
  63        return sha1hash(sha1) & (n - 1);
  64}
  65
  66/*
  67 * Insert obj into the hash table hash, which has length size (which
  68 * must be a power of 2).  On collisions, simply overflow to the next
  69 * empty bucket.
  70 */
  71static void insert_obj_hash(struct object *obj, struct object **hash, unsigned int size)
  72{
  73        unsigned int j = hash_obj(obj->oid.hash, size);
  74
  75        while (hash[j]) {
  76                j++;
  77                if (j >= size)
  78                        j = 0;
  79        }
  80        hash[j] = obj;
  81}
  82
  83/*
  84 * Look up the record for the given sha1 in the hash map stored in
  85 * obj_hash.  Return NULL if it was not found.
  86 */
  87struct object *lookup_object_the_repository(const unsigned char *sha1)
  88{
  89        unsigned int i, first;
  90        struct object *obj;
  91
  92        if (!the_repository->parsed_objects->obj_hash)
  93                return NULL;
  94
  95        first = i = hash_obj(sha1,
  96                             the_repository->parsed_objects->obj_hash_size);
  97        while ((obj = the_repository->parsed_objects->obj_hash[i]) != NULL) {
  98                if (!hashcmp(sha1, obj->oid.hash))
  99                        break;
 100                i++;
 101                if (i == the_repository->parsed_objects->obj_hash_size)
 102                        i = 0;
 103        }
 104        if (obj && i != first) {
 105                /*
 106                 * Move object to where we started to look for it so
 107                 * that we do not need to walk the hash table the next
 108                 * time we look for it.
 109                 */
 110                SWAP(the_repository->parsed_objects->obj_hash[i],
 111                     the_repository->parsed_objects->obj_hash[first]);
 112        }
 113        return obj;
 114}
 115
 116/*
 117 * Increase the size of the hash map stored in obj_hash to the next
 118 * power of 2 (but at least 32).  Copy the existing values to the new
 119 * hash map.
 120 */
 121static void grow_object_hash(struct repository *r)
 122{
 123        int i;
 124        /*
 125         * Note that this size must always be power-of-2 to match hash_obj
 126         * above.
 127         */
 128        int new_hash_size = r->parsed_objects->obj_hash_size < 32 ? 32 : 2 * r->parsed_objects->obj_hash_size;
 129        struct object **new_hash;
 130
 131        new_hash = xcalloc(new_hash_size, sizeof(struct object *));
 132        for (i = 0; i < r->parsed_objects->obj_hash_size; i++) {
 133                struct object *obj = r->parsed_objects->obj_hash[i];
 134
 135                if (!obj)
 136                        continue;
 137                insert_obj_hash(obj, new_hash, new_hash_size);
 138        }
 139        free(r->parsed_objects->obj_hash);
 140        r->parsed_objects->obj_hash = new_hash;
 141        r->parsed_objects->obj_hash_size = new_hash_size;
 142}
 143
 144void *create_object(struct repository *r, const unsigned char *sha1, void *o)
 145{
 146        struct object *obj = o;
 147
 148        obj->parsed = 0;
 149        obj->flags = 0;
 150        hashcpy(obj->oid.hash, sha1);
 151
 152        if (r->parsed_objects->obj_hash_size - 1 <= r->parsed_objects->nr_objs * 2)
 153                grow_object_hash(r);
 154
 155        insert_obj_hash(obj, r->parsed_objects->obj_hash,
 156                        r->parsed_objects->obj_hash_size);
 157        r->parsed_objects->nr_objs++;
 158        return obj;
 159}
 160
 161void *object_as_type_the_repository(struct object *obj, enum object_type type, int quiet)
 162{
 163        if (obj->type == type)
 164                return obj;
 165        else if (obj->type == OBJ_NONE) {
 166                if (type == OBJ_COMMIT)
 167                        ((struct commit *)obj)->index = alloc_commit_index(the_repository);
 168                obj->type = type;
 169                return obj;
 170        }
 171        else {
 172                if (!quiet)
 173                        error("object %s is a %s, not a %s",
 174                              oid_to_hex(&obj->oid),
 175                              type_name(obj->type), type_name(type));
 176                return NULL;
 177        }
 178}
 179
 180struct object *lookup_unknown_object(const unsigned char *sha1)
 181{
 182        struct object *obj = lookup_object(the_repository, sha1);
 183        if (!obj)
 184                obj = create_object(the_repository, sha1,
 185                                    alloc_object_node(the_repository));
 186        return obj;
 187}
 188
 189struct object *parse_object_buffer_the_repository(const struct object_id *oid, enum object_type type, unsigned long size, void *buffer, int *eaten_p)
 190{
 191        struct object *obj;
 192        *eaten_p = 0;
 193
 194        obj = NULL;
 195        if (type == OBJ_BLOB) {
 196                struct blob *blob = lookup_blob(the_repository, oid);
 197                if (blob) {
 198                        if (parse_blob_buffer(blob, buffer, size))
 199                                return NULL;
 200                        obj = &blob->object;
 201                }
 202        } else if (type == OBJ_TREE) {
 203                struct tree *tree = lookup_tree(the_repository, oid);
 204                if (tree) {
 205                        obj = &tree->object;
 206                        if (!tree->buffer)
 207                                tree->object.parsed = 0;
 208                        if (!tree->object.parsed) {
 209                                if (parse_tree_buffer(tree, buffer, size))
 210                                        return NULL;
 211                                *eaten_p = 1;
 212                        }
 213                }
 214        } else if (type == OBJ_COMMIT) {
 215                struct commit *commit = lookup_commit(oid);
 216                if (commit) {
 217                        if (parse_commit_buffer(commit, buffer, size, 1))
 218                                return NULL;
 219                        if (!get_cached_commit_buffer(commit, NULL)) {
 220                                set_commit_buffer(commit, buffer, size);
 221                                *eaten_p = 1;
 222                        }
 223                        obj = &commit->object;
 224                }
 225        } else if (type == OBJ_TAG) {
 226                struct tag *tag = lookup_tag(oid);
 227                if (tag) {
 228                        if (parse_tag_buffer(tag, buffer, size))
 229                               return NULL;
 230                        obj = &tag->object;
 231                }
 232        } else {
 233                warning("object %s has unknown type id %d", oid_to_hex(oid), type);
 234                obj = NULL;
 235        }
 236        return obj;
 237}
 238
 239struct object *parse_object_or_die(const struct object_id *oid,
 240                                   const char *name)
 241{
 242        struct object *o = parse_object(the_repository, oid);
 243        if (o)
 244                return o;
 245
 246        die(_("unable to parse object: %s"), name ? name : oid_to_hex(oid));
 247}
 248
 249struct object *parse_object_the_repository(const struct object_id *oid)
 250{
 251        unsigned long size;
 252        enum object_type type;
 253        int eaten;
 254        const struct object_id *repl = lookup_replace_object(the_repository, oid);
 255        void *buffer;
 256        struct object *obj;
 257
 258        obj = lookup_object(the_repository, oid->hash);
 259        if (obj && obj->parsed)
 260                return obj;
 261
 262        if ((obj && obj->type == OBJ_BLOB && has_object_file(oid)) ||
 263            (!obj && has_object_file(oid) &&
 264             oid_object_info(the_repository, oid, NULL) == OBJ_BLOB)) {
 265                if (check_object_signature(repl, NULL, 0, NULL) < 0) {
 266                        error("sha1 mismatch %s", oid_to_hex(oid));
 267                        return NULL;
 268                }
 269                parse_blob_buffer(lookup_blob(the_repository, oid), NULL, 0);
 270                return lookup_object(the_repository, oid->hash);
 271        }
 272
 273        buffer = read_object_file(oid, &type, &size);
 274        if (buffer) {
 275                if (check_object_signature(repl, buffer, size, type_name(type)) < 0) {
 276                        free(buffer);
 277                        error("sha1 mismatch %s", oid_to_hex(repl));
 278                        return NULL;
 279                }
 280
 281                obj = parse_object_buffer(the_repository, oid, type, size,
 282                                          buffer, &eaten);
 283                if (!eaten)
 284                        free(buffer);
 285                return obj;
 286        }
 287        return NULL;
 288}
 289
 290struct object_list *object_list_insert(struct object *item,
 291                                       struct object_list **list_p)
 292{
 293        struct object_list *new_list = xmalloc(sizeof(struct object_list));
 294        new_list->item = item;
 295        new_list->next = *list_p;
 296        *list_p = new_list;
 297        return new_list;
 298}
 299
 300int object_list_contains(struct object_list *list, struct object *obj)
 301{
 302        while (list) {
 303                if (list->item == obj)
 304                        return 1;
 305                list = list->next;
 306        }
 307        return 0;
 308}
 309
 310/*
 311 * A zero-length string to which object_array_entry::name can be
 312 * initialized without requiring a malloc/free.
 313 */
 314static char object_array_slopbuf[1];
 315
 316void add_object_array_with_path(struct object *obj, const char *name,
 317                                struct object_array *array,
 318                                unsigned mode, const char *path)
 319{
 320        unsigned nr = array->nr;
 321        unsigned alloc = array->alloc;
 322        struct object_array_entry *objects = array->objects;
 323        struct object_array_entry *entry;
 324
 325        if (nr >= alloc) {
 326                alloc = (alloc + 32) * 2;
 327                REALLOC_ARRAY(objects, alloc);
 328                array->alloc = alloc;
 329                array->objects = objects;
 330        }
 331        entry = &objects[nr];
 332        entry->item = obj;
 333        if (!name)
 334                entry->name = NULL;
 335        else if (!*name)
 336                /* Use our own empty string instead of allocating one: */
 337                entry->name = object_array_slopbuf;
 338        else
 339                entry->name = xstrdup(name);
 340        entry->mode = mode;
 341        if (path)
 342                entry->path = xstrdup(path);
 343        else
 344                entry->path = NULL;
 345        array->nr = ++nr;
 346}
 347
 348void add_object_array(struct object *obj, const char *name, struct object_array *array)
 349{
 350        add_object_array_with_path(obj, name, array, S_IFINVALID, NULL);
 351}
 352
 353/*
 354 * Free all memory associated with an entry; the result is
 355 * in an unspecified state and should not be examined.
 356 */
 357static void object_array_release_entry(struct object_array_entry *ent)
 358{
 359        if (ent->name != object_array_slopbuf)
 360                free(ent->name);
 361        free(ent->path);
 362}
 363
 364struct object *object_array_pop(struct object_array *array)
 365{
 366        struct object *ret;
 367
 368        if (!array->nr)
 369                return NULL;
 370
 371        ret = array->objects[array->nr - 1].item;
 372        object_array_release_entry(&array->objects[array->nr - 1]);
 373        array->nr--;
 374        return ret;
 375}
 376
 377void object_array_filter(struct object_array *array,
 378                         object_array_each_func_t want, void *cb_data)
 379{
 380        unsigned nr = array->nr, src, dst;
 381        struct object_array_entry *objects = array->objects;
 382
 383        for (src = dst = 0; src < nr; src++) {
 384                if (want(&objects[src], cb_data)) {
 385                        if (src != dst)
 386                                objects[dst] = objects[src];
 387                        dst++;
 388                } else {
 389                        object_array_release_entry(&objects[src]);
 390                }
 391        }
 392        array->nr = dst;
 393}
 394
 395void object_array_clear(struct object_array *array)
 396{
 397        int i;
 398        for (i = 0; i < array->nr; i++)
 399                object_array_release_entry(&array->objects[i]);
 400        FREE_AND_NULL(array->objects);
 401        array->nr = array->alloc = 0;
 402}
 403
 404/*
 405 * Return true iff array already contains an entry with name.
 406 */
 407static int contains_name(struct object_array *array, const char *name)
 408{
 409        unsigned nr = array->nr, i;
 410        struct object_array_entry *object = array->objects;
 411
 412        for (i = 0; i < nr; i++, object++)
 413                if (!strcmp(object->name, name))
 414                        return 1;
 415        return 0;
 416}
 417
 418void object_array_remove_duplicates(struct object_array *array)
 419{
 420        unsigned nr = array->nr, src;
 421        struct object_array_entry *objects = array->objects;
 422
 423        array->nr = 0;
 424        for (src = 0; src < nr; src++) {
 425                if (!contains_name(array, objects[src].name)) {
 426                        if (src != array->nr)
 427                                objects[array->nr] = objects[src];
 428                        array->nr++;
 429                } else {
 430                        object_array_release_entry(&objects[src]);
 431                }
 432        }
 433}
 434
 435void clear_object_flags(unsigned flags)
 436{
 437        int i;
 438
 439        for (i=0; i < the_repository->parsed_objects->obj_hash_size; i++) {
 440                struct object *obj = the_repository->parsed_objects->obj_hash[i];
 441                if (obj)
 442                        obj->flags &= ~flags;
 443        }
 444}
 445
 446void clear_commit_marks_all(unsigned int flags)
 447{
 448        int i;
 449
 450        for (i = 0; i < the_repository->parsed_objects->obj_hash_size; i++) {
 451                struct object *obj = the_repository->parsed_objects->obj_hash[i];
 452                if (obj && obj->type == OBJ_COMMIT)
 453                        obj->flags &= ~flags;
 454        }
 455}
 456
 457struct parsed_object_pool *parsed_object_pool_new(void)
 458{
 459        struct parsed_object_pool *o = xmalloc(sizeof(*o));
 460        memset(o, 0, sizeof(*o));
 461
 462        o->blob_state = allocate_alloc_state();
 463        o->tree_state = allocate_alloc_state();
 464        o->commit_state = allocate_alloc_state();
 465        o->tag_state = allocate_alloc_state();
 466        o->object_state = allocate_alloc_state();
 467
 468        o->is_shallow = -1;
 469        o->shallow_stat = xcalloc(1, sizeof(*o->shallow_stat));
 470
 471        return o;
 472}
 473
 474struct raw_object_store *raw_object_store_new(void)
 475{
 476        struct raw_object_store *o = xmalloc(sizeof(*o));
 477
 478        memset(o, 0, sizeof(*o));
 479        INIT_LIST_HEAD(&o->packed_git_mru);
 480        return o;
 481}
 482
 483static void free_alt_odb(struct alternate_object_database *alt)
 484{
 485        strbuf_release(&alt->scratch);
 486        oid_array_clear(&alt->loose_objects_cache);
 487        free(alt);
 488}
 489
 490static void free_alt_odbs(struct raw_object_store *o)
 491{
 492        while (o->alt_odb_list) {
 493                struct alternate_object_database *next;
 494
 495                next = o->alt_odb_list->next;
 496                free_alt_odb(o->alt_odb_list);
 497                o->alt_odb_list = next;
 498        }
 499}
 500
 501void raw_object_store_clear(struct raw_object_store *o)
 502{
 503        FREE_AND_NULL(o->objectdir);
 504        FREE_AND_NULL(o->alternate_db);
 505
 506        oidmap_free(o->replace_map, 1);
 507        FREE_AND_NULL(o->replace_map);
 508
 509        free_alt_odbs(o);
 510        o->alt_odb_tail = NULL;
 511
 512        INIT_LIST_HEAD(&o->packed_git_mru);
 513        close_all_packs(o);
 514        o->packed_git = NULL;
 515}
 516
 517void parsed_object_pool_clear(struct parsed_object_pool *o)
 518{
 519        /*
 520         * As objects are allocated in slabs (see alloc.c), we do
 521         * not need to free each object, but each slab instead.
 522         *
 523         * Before doing so, we need to free any additional memory
 524         * the objects may hold.
 525         */
 526        unsigned i;
 527
 528        for (i = 0; i < o->obj_hash_size; i++) {
 529                struct object *obj = o->obj_hash[i];
 530
 531                if (!obj)
 532                        continue;
 533
 534                if (obj->type == OBJ_TREE)
 535                        free_tree_buffer((struct tree*)obj);
 536                else if (obj->type == OBJ_COMMIT)
 537                        release_commit_memory((struct commit*)obj);
 538                else if (obj->type == OBJ_TAG)
 539                        release_tag_memory((struct tag*)obj);
 540        }
 541
 542        FREE_AND_NULL(o->obj_hash);
 543        o->obj_hash_size = 0;
 544
 545        clear_alloc_state(o->blob_state);
 546        clear_alloc_state(o->tree_state);
 547        clear_alloc_state(o->commit_state);
 548        clear_alloc_state(o->tag_state);
 549        clear_alloc_state(o->object_state);
 550        FREE_AND_NULL(o->blob_state);
 551        FREE_AND_NULL(o->tree_state);
 552        FREE_AND_NULL(o->commit_state);
 553        FREE_AND_NULL(o->tag_state);
 554        FREE_AND_NULL(o->object_state);
 555}