1 #include "git-compat-util.h"
5 #include "replace-object.h"
6 #include "object-file.h"
7 #include "object-store.h"
15 #include "commit-graph.h"
18 unsigned int get_max_object_index(void)
20 return the_repository
->parsed_objects
->obj_hash_size
;
23 struct object
*get_indexed_object(unsigned int idx
)
25 return the_repository
->parsed_objects
->obj_hash
[idx
];
28 static const char *object_type_strings
[] = {
29 NULL
, /* OBJ_NONE = 0 */
30 "commit", /* OBJ_COMMIT = 1 */
31 "tree", /* OBJ_TREE = 2 */
32 "blob", /* OBJ_BLOB = 3 */
33 "tag", /* OBJ_TAG = 4 */
36 const char *type_name(unsigned int type
)
38 if (type
>= ARRAY_SIZE(object_type_strings
))
40 return object_type_strings
[type
];
43 int type_from_string_gently(const char *str
, ssize_t len
, int gentle
)
50 for (i
= 1; i
< ARRAY_SIZE(object_type_strings
); i
++)
51 if (!xstrncmpz(object_type_strings
[i
], str
, len
))
57 die(_("invalid object type \"%s\""), str
);
61 * Return a numerical hash value between 0 and n-1 for the object with
62 * the specified sha1. n must be a power of 2. Please note that the
63 * return value is *not* consistent across computer architectures.
65 static unsigned int hash_obj(const struct object_id
*oid
, unsigned int n
)
67 return oidhash(oid
) & (n
- 1);
71 * Insert obj into the hash table hash, which has length size (which
72 * must be a power of 2). On collisions, simply overflow to the next
75 static void insert_obj_hash(struct object
*obj
, struct object
**hash
, unsigned int size
)
77 unsigned int j
= hash_obj(&obj
->oid
, size
);
88 * Look up the record for the given sha1 in the hash map stored in
89 * obj_hash. Return NULL if it was not found.
91 struct object
*lookup_object(struct repository
*r
, const struct object_id
*oid
)
93 unsigned int i
, first
;
96 if (!r
->parsed_objects
->obj_hash
)
99 first
= i
= hash_obj(oid
, r
->parsed_objects
->obj_hash_size
);
100 while ((obj
= r
->parsed_objects
->obj_hash
[i
]) != NULL
) {
101 if (oideq(oid
, &obj
->oid
))
104 if (i
== r
->parsed_objects
->obj_hash_size
)
107 if (obj
&& i
!= first
) {
109 * Move object to where we started to look for it so
110 * that we do not need to walk the hash table the next
111 * time we look for it.
113 SWAP(r
->parsed_objects
->obj_hash
[i
],
114 r
->parsed_objects
->obj_hash
[first
]);
120 * Increase the size of the hash map stored in obj_hash to the next
121 * power of 2 (but at least 32). Copy the existing values to the new
124 static void grow_object_hash(struct repository
*r
)
128 * Note that this size must always be power-of-2 to match hash_obj
131 int new_hash_size
= r
->parsed_objects
->obj_hash_size
< 32 ? 32 : 2 * r
->parsed_objects
->obj_hash_size
;
132 struct object
**new_hash
;
134 CALLOC_ARRAY(new_hash
, new_hash_size
);
135 for (i
= 0; i
< r
->parsed_objects
->obj_hash_size
; i
++) {
136 struct object
*obj
= r
->parsed_objects
->obj_hash
[i
];
140 insert_obj_hash(obj
, new_hash
, new_hash_size
);
142 free(r
->parsed_objects
->obj_hash
);
143 r
->parsed_objects
->obj_hash
= new_hash
;
144 r
->parsed_objects
->obj_hash_size
= new_hash_size
;
147 void *create_object(struct repository
*r
, const struct object_id
*oid
, void *o
)
149 struct object
*obj
= o
;
153 oidcpy(&obj
->oid
, oid
);
155 if (r
->parsed_objects
->obj_hash_size
- 1 <= r
->parsed_objects
->nr_objs
* 2)
158 insert_obj_hash(obj
, r
->parsed_objects
->obj_hash
,
159 r
->parsed_objects
->obj_hash_size
);
160 r
->parsed_objects
->nr_objs
++;
164 void *object_as_type(struct object
*obj
, enum object_type type
, int quiet
)
166 if (obj
->type
== type
)
168 else if (obj
->type
== OBJ_NONE
) {
169 if (type
== OBJ_COMMIT
)
170 init_commit_node((struct commit
*) obj
);
177 error(_("object %s is a %s, not a %s"),
178 oid_to_hex(&obj
->oid
),
179 type_name(obj
->type
), type_name(type
));
184 struct object
*lookup_unknown_object(struct repository
*r
, const struct object_id
*oid
)
186 struct object
*obj
= lookup_object(r
, oid
);
188 obj
= create_object(r
, oid
, alloc_object_node(r
));
192 struct object
*lookup_object_by_type(struct repository
*r
,
193 const struct object_id
*oid
,
194 enum object_type type
)
198 return (struct object
*)lookup_commit(r
, oid
);
200 return (struct object
*)lookup_tree(r
, oid
);
202 return (struct object
*)lookup_tag(r
, oid
);
204 return (struct object
*)lookup_blob(r
, oid
);
206 BUG("unknown object type %d", type
);
210 enum peel_status
peel_object(struct repository
*r
,
211 const struct object_id
*name
,
212 struct object_id
*oid
)
214 struct object
*o
= lookup_unknown_object(r
, name
);
216 if (o
->type
== OBJ_NONE
) {
217 int type
= oid_object_info(r
, name
, NULL
);
218 if (type
< 0 || !object_as_type(o
, type
, 0))
222 if (o
->type
!= OBJ_TAG
)
225 o
= deref_tag_noverify(r
, o
);
229 oidcpy(oid
, &o
->oid
);
233 struct object
*parse_object_buffer(struct repository
*r
, const struct object_id
*oid
, enum object_type type
, unsigned long size
, void *buffer
, int *eaten_p
)
239 if (type
== OBJ_BLOB
) {
240 struct blob
*blob
= lookup_blob(r
, oid
);
242 parse_blob_buffer(blob
);
245 } else if (type
== OBJ_TREE
) {
246 struct tree
*tree
= lookup_tree(r
, oid
);
250 tree
->object
.parsed
= 0;
251 if (!tree
->object
.parsed
) {
252 if (parse_tree_buffer(tree
, buffer
, size
))
257 } else if (type
== OBJ_COMMIT
) {
258 struct commit
*commit
= lookup_commit(r
, oid
);
260 if (parse_commit_buffer(r
, commit
, buffer
, size
, 1))
262 if (save_commit_buffer
&&
263 !get_cached_commit_buffer(r
, commit
, NULL
)) {
264 set_commit_buffer(r
, commit
, buffer
, size
);
267 obj
= &commit
->object
;
269 } else if (type
== OBJ_TAG
) {
270 struct tag
*tag
= lookup_tag(r
, oid
);
272 if (parse_tag_buffer(r
, tag
, buffer
, size
))
277 warning(_("object %s has unknown type id %d"), oid_to_hex(oid
), type
);
283 struct object
*parse_object_or_die(const struct object_id
*oid
,
286 struct object
*o
= parse_object(the_repository
, oid
);
290 die(_("unable to parse object: %s"), name
? name
: oid_to_hex(oid
));
293 struct object
*parse_object_with_flags(struct repository
*r
,
294 const struct object_id
*oid
,
295 enum parse_object_flags flags
)
297 int skip_hash
= !!(flags
& PARSE_OBJECT_SKIP_HASH_CHECK
);
298 int discard_tree
= !!(flags
& PARSE_OBJECT_DISCARD_TREE
);
300 enum object_type type
;
302 const struct object_id
*repl
= lookup_replace_object(r
, oid
);
306 obj
= lookup_object(r
, oid
);
307 if (obj
&& obj
->parsed
)
311 struct commit
*commit
= lookup_commit_in_graph(r
, repl
);
313 return &commit
->object
;
316 if ((!obj
|| obj
->type
== OBJ_BLOB
) &&
317 oid_object_info(r
, oid
, NULL
) == OBJ_BLOB
) {
318 if (!skip_hash
&& stream_object_signature(r
, repl
) < 0) {
319 error(_("hash mismatch %s"), oid_to_hex(oid
));
322 parse_blob_buffer(lookup_blob(r
, oid
));
323 return lookup_object(r
, oid
);
327 * If the caller does not care about the tree buffer and does not
328 * care about checking the hash, we can simply verify that we
329 * have the on-disk object with the correct type.
331 if (skip_hash
&& discard_tree
&&
332 (!obj
|| obj
->type
== OBJ_TREE
) &&
333 oid_object_info(r
, oid
, NULL
) == OBJ_TREE
) {
334 return &lookup_tree(r
, oid
)->object
;
337 buffer
= repo_read_object_file(r
, oid
, &type
, &size
);
340 check_object_signature(r
, repl
, buffer
, size
, type
) < 0) {
342 error(_("hash mismatch %s"), oid_to_hex(repl
));
346 obj
= parse_object_buffer(r
, oid
, type
, size
,
350 if (discard_tree
&& type
== OBJ_TREE
)
351 free_tree_buffer((struct tree
*)obj
);
357 struct object
*parse_object(struct repository
*r
, const struct object_id
*oid
)
359 return parse_object_with_flags(r
, oid
, 0);
362 struct object_list
*object_list_insert(struct object
*item
,
363 struct object_list
**list_p
)
365 struct object_list
*new_list
= xmalloc(sizeof(struct object_list
));
366 new_list
->item
= item
;
367 new_list
->next
= *list_p
;
372 int object_list_contains(struct object_list
*list
, struct object
*obj
)
375 if (list
->item
== obj
)
382 void object_list_free(struct object_list
**list
)
385 struct object_list
*p
= *list
;
392 * A zero-length string to which object_array_entry::name can be
393 * initialized without requiring a malloc/free.
395 static char object_array_slopbuf
[1];
397 void object_array_init(struct object_array
*array
)
399 struct object_array blank
= OBJECT_ARRAY_INIT
;
400 memcpy(array
, &blank
, sizeof(*array
));
403 void add_object_array_with_path(struct object
*obj
, const char *name
,
404 struct object_array
*array
,
405 unsigned mode
, const char *path
)
407 unsigned nr
= array
->nr
;
408 unsigned alloc
= array
->alloc
;
409 struct object_array_entry
*objects
= array
->objects
;
410 struct object_array_entry
*entry
;
413 alloc
= (alloc
+ 32) * 2;
414 REALLOC_ARRAY(objects
, alloc
);
415 array
->alloc
= alloc
;
416 array
->objects
= objects
;
418 entry
= &objects
[nr
];
423 /* Use our own empty string instead of allocating one: */
424 entry
->name
= object_array_slopbuf
;
426 entry
->name
= xstrdup(name
);
429 entry
->path
= xstrdup(path
);
435 void add_object_array(struct object
*obj
, const char *name
, struct object_array
*array
)
437 add_object_array_with_path(obj
, name
, array
, S_IFINVALID
, NULL
);
441 * Free all memory associated with an entry; the result is
442 * in an unspecified state and should not be examined.
444 static void object_array_release_entry(struct object_array_entry
*ent
)
446 if (ent
->name
!= object_array_slopbuf
)
451 struct object
*object_array_pop(struct object_array
*array
)
458 ret
= array
->objects
[array
->nr
- 1].item
;
459 object_array_release_entry(&array
->objects
[array
->nr
- 1]);
464 void object_array_filter(struct object_array
*array
,
465 object_array_each_func_t want
, void *cb_data
)
467 unsigned nr
= array
->nr
, src
, dst
;
468 struct object_array_entry
*objects
= array
->objects
;
470 for (src
= dst
= 0; src
< nr
; src
++) {
471 if (want(&objects
[src
], cb_data
)) {
473 objects
[dst
] = objects
[src
];
476 object_array_release_entry(&objects
[src
]);
482 void object_array_clear(struct object_array
*array
)
485 for (i
= 0; i
< array
->nr
; i
++)
486 object_array_release_entry(&array
->objects
[i
]);
487 FREE_AND_NULL(array
->objects
);
488 array
->nr
= array
->alloc
= 0;
492 * Return true if array already contains an entry.
494 static int contains_object(struct object_array
*array
,
495 const struct object
*item
, const char *name
)
497 unsigned nr
= array
->nr
, i
;
498 struct object_array_entry
*object
= array
->objects
;
500 for (i
= 0; i
< nr
; i
++, object
++)
501 if (item
== object
->item
&& !strcmp(object
->name
, name
))
506 void object_array_remove_duplicates(struct object_array
*array
)
508 unsigned nr
= array
->nr
, src
;
509 struct object_array_entry
*objects
= array
->objects
;
512 for (src
= 0; src
< nr
; src
++) {
513 if (!contains_object(array
, objects
[src
].item
,
514 objects
[src
].name
)) {
515 if (src
!= array
->nr
)
516 objects
[array
->nr
] = objects
[src
];
519 object_array_release_entry(&objects
[src
]);
524 void clear_object_flags(unsigned flags
)
528 for (i
=0; i
< the_repository
->parsed_objects
->obj_hash_size
; i
++) {
529 struct object
*obj
= the_repository
->parsed_objects
->obj_hash
[i
];
531 obj
->flags
&= ~flags
;
535 void repo_clear_commit_marks(struct repository
*r
, unsigned int flags
)
539 for (i
= 0; i
< r
->parsed_objects
->obj_hash_size
; i
++) {
540 struct object
*obj
= r
->parsed_objects
->obj_hash
[i
];
541 if (obj
&& obj
->type
== OBJ_COMMIT
)
542 obj
->flags
&= ~flags
;
546 struct parsed_object_pool
*parsed_object_pool_new(void)
548 struct parsed_object_pool
*o
= xmalloc(sizeof(*o
));
549 memset(o
, 0, sizeof(*o
));
551 o
->blob_state
= allocate_alloc_state();
552 o
->tree_state
= allocate_alloc_state();
553 o
->commit_state
= allocate_alloc_state();
554 o
->tag_state
= allocate_alloc_state();
555 o
->object_state
= allocate_alloc_state();
558 CALLOC_ARRAY(o
->shallow_stat
, 1);
560 o
->buffer_slab
= allocate_commit_buffer_slab();
565 struct raw_object_store
*raw_object_store_new(void)
567 struct raw_object_store
*o
= xmalloc(sizeof(*o
));
569 memset(o
, 0, sizeof(*o
));
570 INIT_LIST_HEAD(&o
->packed_git_mru
);
571 hashmap_init(&o
->pack_map
, pack_map_entry_cmp
, NULL
, 0);
572 pthread_mutex_init(&o
->replace_mutex
, NULL
);
576 void free_object_directory(struct object_directory
*odb
)
579 odb_clear_loose_cache(odb
);
580 loose_object_map_clear(&odb
->loose_map
);
584 static void free_object_directories(struct raw_object_store
*o
)
587 struct object_directory
*next
;
590 free_object_directory(o
->odb
);
593 kh_destroy_odb_path_map(o
->odb_by_path
);
594 o
->odb_by_path
= NULL
;
597 void raw_object_store_clear(struct raw_object_store
*o
)
599 FREE_AND_NULL(o
->alternate_db
);
601 oidmap_free(o
->replace_map
, 1);
602 FREE_AND_NULL(o
->replace_map
);
603 pthread_mutex_destroy(&o
->replace_mutex
);
605 free_commit_graph(o
->commit_graph
);
606 o
->commit_graph
= NULL
;
607 o
->commit_graph_attempted
= 0;
609 free_object_directories(o
);
611 o
->loaded_alternates
= 0;
613 INIT_LIST_HEAD(&o
->packed_git_mru
);
614 close_object_store(o
);
615 o
->packed_git
= NULL
;
617 hashmap_clear(&o
->pack_map
);
620 void parsed_object_pool_clear(struct parsed_object_pool
*o
)
623 * As objects are allocated in slabs (see alloc.c), we do
624 * not need to free each object, but each slab instead.
626 * Before doing so, we need to free any additional memory
627 * the objects may hold.
631 for (i
= 0; i
< o
->obj_hash_size
; i
++) {
632 struct object
*obj
= o
->obj_hash
[i
];
637 if (obj
->type
== OBJ_TREE
)
638 free_tree_buffer((struct tree
*)obj
);
639 else if (obj
->type
== OBJ_COMMIT
)
640 release_commit_memory(o
, (struct commit
*)obj
);
641 else if (obj
->type
== OBJ_TAG
)
642 release_tag_memory((struct tag
*)obj
);
645 FREE_AND_NULL(o
->obj_hash
);
646 o
->obj_hash_size
= 0;
648 free_commit_buffer_slab(o
->buffer_slab
);
649 o
->buffer_slab
= NULL
;
651 clear_alloc_state(o
->blob_state
);
652 clear_alloc_state(o
->tree_state
);
653 clear_alloc_state(o
->commit_state
);
654 clear_alloc_state(o
->tag_state
);
655 clear_alloc_state(o
->object_state
);
656 stat_validity_clear(o
->shallow_stat
);
657 FREE_AND_NULL(o
->blob_state
);
658 FREE_AND_NULL(o
->tree_state
);
659 FREE_AND_NULL(o
->commit_state
);
660 FREE_AND_NULL(o
->tag_state
);
661 FREE_AND_NULL(o
->object_state
);
662 FREE_AND_NULL(o
->shallow_stat
);