3 #include "replace-object.h"
4 #include "object-store.h"
10 #include "object-store.h"
12 #include "commit-graph.h"
14 unsigned int get_max_object_index(void)
16 return the_repository
->parsed_objects
->obj_hash_size
;
19 struct object
*get_indexed_object(unsigned int idx
)
21 return the_repository
->parsed_objects
->obj_hash
[idx
];
24 static const char *object_type_strings
[] = {
25 NULL
, /* OBJ_NONE = 0 */
26 "commit", /* OBJ_COMMIT = 1 */
27 "tree", /* OBJ_TREE = 2 */
28 "blob", /* OBJ_BLOB = 3 */
29 "tag", /* OBJ_TAG = 4 */
32 const char *type_name(unsigned int type
)
34 if (type
>= ARRAY_SIZE(object_type_strings
))
36 return object_type_strings
[type
];
39 int type_from_string_gently(const char *str
, ssize_t len
, int gentle
)
46 for (i
= 1; i
< ARRAY_SIZE(object_type_strings
); i
++)
47 if (!strncmp(str
, object_type_strings
[i
], len
) &&
48 object_type_strings
[i
][len
] == '\0')
54 die(_("invalid object type \"%s\""), str
);
58 * Return a numerical hash value between 0 and n-1 for the object with
59 * the specified sha1. n must be a power of 2. Please note that the
60 * return value is *not* consistent across computer architectures.
62 static unsigned int hash_obj(const unsigned char *sha1
, unsigned int n
)
64 return sha1hash(sha1
) & (n
- 1);
68 * Insert obj into the hash table hash, which has length size (which
69 * must be a power of 2). On collisions, simply overflow to the next
72 static void insert_obj_hash(struct object
*obj
, struct object
**hash
, unsigned int size
)
74 unsigned int j
= hash_obj(obj
->oid
.hash
, size
);
85 * Look up the record for the given sha1 in the hash map stored in
86 * obj_hash. Return NULL if it was not found.
88 struct object
*lookup_object(struct repository
*r
, const unsigned char *sha1
)
90 unsigned int i
, first
;
93 if (!r
->parsed_objects
->obj_hash
)
96 first
= i
= hash_obj(sha1
, r
->parsed_objects
->obj_hash_size
);
97 while ((obj
= r
->parsed_objects
->obj_hash
[i
]) != NULL
) {
98 if (!hashcmp(sha1
, obj
->oid
.hash
))
101 if (i
== r
->parsed_objects
->obj_hash_size
)
104 if (obj
&& i
!= first
) {
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.
110 SWAP(r
->parsed_objects
->obj_hash
[i
],
111 r
->parsed_objects
->obj_hash
[first
]);
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
121 static void grow_object_hash(struct repository
*r
)
125 * Note that this size must always be power-of-2 to match hash_obj
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
;
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
];
137 insert_obj_hash(obj
, new_hash
, new_hash_size
);
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
;
144 void *create_object(struct repository
*r
, const unsigned char *sha1
, void *o
)
146 struct object
*obj
= o
;
150 hashcpy(obj
->oid
.hash
, sha1
);
152 if (r
->parsed_objects
->obj_hash_size
- 1 <= r
->parsed_objects
->nr_objs
* 2)
155 insert_obj_hash(obj
, r
->parsed_objects
->obj_hash
,
156 r
->parsed_objects
->obj_hash_size
);
157 r
->parsed_objects
->nr_objs
++;
161 void *object_as_type(struct repository
*r
, struct object
*obj
, enum object_type type
, int quiet
)
163 if (obj
->type
== type
)
165 else if (obj
->type
== OBJ_NONE
) {
166 if (type
== OBJ_COMMIT
)
167 ((struct commit
*)obj
)->index
= alloc_commit_index(r
);
173 error(_("object %s is a %s, not a %s"),
174 oid_to_hex(&obj
->oid
),
175 type_name(obj
->type
), type_name(type
));
180 struct object
*lookup_unknown_object(const unsigned char *sha1
)
182 struct object
*obj
= lookup_object(the_repository
, sha1
);
184 obj
= create_object(the_repository
, sha1
,
185 alloc_object_node(the_repository
));
189 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
)
195 if (type
== OBJ_BLOB
) {
196 struct blob
*blob
= lookup_blob(r
, oid
);
198 if (parse_blob_buffer(blob
, buffer
, size
))
202 } else if (type
== OBJ_TREE
) {
203 struct tree
*tree
= lookup_tree(r
, oid
);
207 tree
->object
.parsed
= 0;
208 if (!tree
->object
.parsed
) {
209 if (parse_tree_buffer(tree
, buffer
, size
))
214 } else if (type
== OBJ_COMMIT
) {
215 struct commit
*commit
= lookup_commit(r
, oid
);
217 if (parse_commit_buffer(r
, commit
, buffer
, size
, 1))
219 if (!get_cached_commit_buffer(r
, commit
, NULL
)) {
220 set_commit_buffer(r
, commit
, buffer
, size
);
223 obj
= &commit
->object
;
225 } else if (type
== OBJ_TAG
) {
226 struct tag
*tag
= lookup_tag(r
, oid
);
228 if (parse_tag_buffer(r
, tag
, buffer
, size
))
233 warning(_("object %s has unknown type id %d"), oid_to_hex(oid
), type
);
239 struct object
*parse_object_or_die(const struct object_id
*oid
,
242 struct object
*o
= parse_object(the_repository
, oid
);
246 die(_("unable to parse object: %s"), name
? name
: oid_to_hex(oid
));
249 struct object
*parse_object(struct repository
*r
, const struct object_id
*oid
)
252 enum object_type type
;
254 const struct object_id
*repl
= lookup_replace_object(r
, oid
);
258 obj
= lookup_object(r
, oid
->hash
);
259 if (obj
&& obj
->parsed
)
262 if ((obj
&& obj
->type
== OBJ_BLOB
&& has_object_file(oid
)) ||
263 (!obj
&& has_object_file(oid
) &&
264 oid_object_info(r
, oid
, NULL
) == OBJ_BLOB
)) {
265 if (check_object_signature(repl
, NULL
, 0, NULL
) < 0) {
266 error(_("sha1 mismatch %s"), oid_to_hex(oid
));
269 parse_blob_buffer(lookup_blob(r
, oid
), NULL
, 0);
270 return lookup_object(r
, oid
->hash
);
273 buffer
= read_object_file(oid
, &type
, &size
);
275 if (check_object_signature(repl
, buffer
, size
, type_name(type
)) < 0) {
277 error(_("sha1 mismatch %s"), oid_to_hex(repl
));
281 obj
= parse_object_buffer(r
, oid
, type
, size
,
290 struct object_list
*object_list_insert(struct object
*item
,
291 struct object_list
**list_p
)
293 struct object_list
*new_list
= xmalloc(sizeof(struct object_list
));
294 new_list
->item
= item
;
295 new_list
->next
= *list_p
;
300 int object_list_contains(struct object_list
*list
, struct object
*obj
)
303 if (list
->item
== obj
)
311 * A zero-length string to which object_array_entry::name can be
312 * initialized without requiring a malloc/free.
314 static char object_array_slopbuf
[1];
316 void add_object_array_with_path(struct object
*obj
, const char *name
,
317 struct object_array
*array
,
318 unsigned mode
, const char *path
)
320 unsigned nr
= array
->nr
;
321 unsigned alloc
= array
->alloc
;
322 struct object_array_entry
*objects
= array
->objects
;
323 struct object_array_entry
*entry
;
326 alloc
= (alloc
+ 32) * 2;
327 REALLOC_ARRAY(objects
, alloc
);
328 array
->alloc
= alloc
;
329 array
->objects
= objects
;
331 entry
= &objects
[nr
];
336 /* Use our own empty string instead of allocating one: */
337 entry
->name
= object_array_slopbuf
;
339 entry
->name
= xstrdup(name
);
342 entry
->path
= xstrdup(path
);
348 void add_object_array(struct object
*obj
, const char *name
, struct object_array
*array
)
350 add_object_array_with_path(obj
, name
, array
, S_IFINVALID
, NULL
);
354 * Free all memory associated with an entry; the result is
355 * in an unspecified state and should not be examined.
357 static void object_array_release_entry(struct object_array_entry
*ent
)
359 if (ent
->name
!= object_array_slopbuf
)
364 struct object
*object_array_pop(struct object_array
*array
)
371 ret
= array
->objects
[array
->nr
- 1].item
;
372 object_array_release_entry(&array
->objects
[array
->nr
- 1]);
377 void object_array_filter(struct object_array
*array
,
378 object_array_each_func_t want
, void *cb_data
)
380 unsigned nr
= array
->nr
, src
, dst
;
381 struct object_array_entry
*objects
= array
->objects
;
383 for (src
= dst
= 0; src
< nr
; src
++) {
384 if (want(&objects
[src
], cb_data
)) {
386 objects
[dst
] = objects
[src
];
389 object_array_release_entry(&objects
[src
]);
395 void object_array_clear(struct object_array
*array
)
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;
405 * Return true iff array already contains an entry with name.
407 static int contains_name(struct object_array
*array
, const char *name
)
409 unsigned nr
= array
->nr
, i
;
410 struct object_array_entry
*object
= array
->objects
;
412 for (i
= 0; i
< nr
; i
++, object
++)
413 if (!strcmp(object
->name
, name
))
418 void object_array_remove_duplicates(struct object_array
*array
)
420 unsigned nr
= array
->nr
, src
;
421 struct object_array_entry
*objects
= array
->objects
;
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
];
430 object_array_release_entry(&objects
[src
]);
435 void clear_object_flags(unsigned flags
)
439 for (i
=0; i
< the_repository
->parsed_objects
->obj_hash_size
; i
++) {
440 struct object
*obj
= the_repository
->parsed_objects
->obj_hash
[i
];
442 obj
->flags
&= ~flags
;
446 void clear_commit_marks_all(unsigned int flags
)
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
;
457 struct parsed_object_pool
*parsed_object_pool_new(void)
459 struct parsed_object_pool
*o
= xmalloc(sizeof(*o
));
460 memset(o
, 0, sizeof(*o
));
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();
469 o
->shallow_stat
= xcalloc(1, sizeof(*o
->shallow_stat
));
471 o
->buffer_slab
= allocate_commit_buffer_slab();
476 struct raw_object_store
*raw_object_store_new(void)
478 struct raw_object_store
*o
= xmalloc(sizeof(*o
));
480 memset(o
, 0, sizeof(*o
));
481 INIT_LIST_HEAD(&o
->packed_git_mru
);
485 static void free_alt_odb(struct alternate_object_database
*alt
)
487 strbuf_release(&alt
->scratch
);
488 oid_array_clear(&alt
->loose_objects_cache
);
492 static void free_alt_odbs(struct raw_object_store
*o
)
494 while (o
->alt_odb_list
) {
495 struct alternate_object_database
*next
;
497 next
= o
->alt_odb_list
->next
;
498 free_alt_odb(o
->alt_odb_list
);
499 o
->alt_odb_list
= next
;
503 void raw_object_store_clear(struct raw_object_store
*o
)
505 FREE_AND_NULL(o
->objectdir
);
506 FREE_AND_NULL(o
->alternate_db
);
508 oidmap_free(o
->replace_map
, 1);
509 FREE_AND_NULL(o
->replace_map
);
511 free_commit_graph(o
->commit_graph
);
512 o
->commit_graph
= NULL
;
513 o
->commit_graph_attempted
= 0;
516 o
->alt_odb_tail
= NULL
;
518 INIT_LIST_HEAD(&o
->packed_git_mru
);
520 o
->packed_git
= NULL
;
523 void parsed_object_pool_clear(struct parsed_object_pool
*o
)
526 * As objects are allocated in slabs (see alloc.c), we do
527 * not need to free each object, but each slab instead.
529 * Before doing so, we need to free any additional memory
530 * the objects may hold.
534 for (i
= 0; i
< o
->obj_hash_size
; i
++) {
535 struct object
*obj
= o
->obj_hash
[i
];
540 if (obj
->type
== OBJ_TREE
)
541 free_tree_buffer((struct tree
*)obj
);
542 else if (obj
->type
== OBJ_COMMIT
)
543 release_commit_memory((struct commit
*)obj
);
544 else if (obj
->type
== OBJ_TAG
)
545 release_tag_memory((struct tag
*)obj
);
548 FREE_AND_NULL(o
->obj_hash
);
549 o
->obj_hash_size
= 0;
551 free_commit_buffer_slab(o
->buffer_slab
);
552 o
->buffer_slab
= NULL
;
554 clear_alloc_state(o
->blob_state
);
555 clear_alloc_state(o
->tree_state
);
556 clear_alloc_state(o
->commit_state
);
557 clear_alloc_state(o
->tag_state
);
558 clear_alloc_state(o
->object_state
);
559 FREE_AND_NULL(o
->blob_state
);
560 FREE_AND_NULL(o
->tree_state
);
561 FREE_AND_NULL(o
->commit_state
);
562 FREE_AND_NULL(o
->tag_state
);
563 FREE_AND_NULL(o
->object_state
);