3 #include "replace-object.h"
4 #include "object-store.h"
11 #include "commit-graph.h"
13 unsigned int get_max_object_index(void)
15 return the_repository
->parsed_objects
->obj_hash_size
;
18 struct object
*get_indexed_object(unsigned int idx
)
20 return the_repository
->parsed_objects
->obj_hash
[idx
];
23 static 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 */
31 const char *type_name(unsigned int type
)
33 if (type
>= ARRAY_SIZE(object_type_strings
))
35 return object_type_strings
[type
];
38 int type_from_string_gently(const char *str
, ssize_t len
, int gentle
)
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')
53 die(_("invalid object type \"%s\""), str
);
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.
61 static unsigned int hash_obj(const struct object_id
*oid
, unsigned int n
)
63 return oidhash(oid
) & (n
- 1);
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
71 static void insert_obj_hash(struct object
*obj
, struct object
**hash
, unsigned int size
)
73 unsigned int j
= hash_obj(&obj
->oid
, size
);
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.
87 struct object
*lookup_object(struct repository
*r
, const struct object_id
*oid
)
89 unsigned int i
, first
;
92 if (!r
->parsed_objects
->obj_hash
)
95 first
= i
= hash_obj(oid
, r
->parsed_objects
->obj_hash_size
);
96 while ((obj
= r
->parsed_objects
->obj_hash
[i
]) != NULL
) {
97 if (oideq(oid
, &obj
->oid
))
100 if (i
== r
->parsed_objects
->obj_hash_size
)
103 if (obj
&& i
!= first
) {
105 * Move object to where we started to look for it so
106 * that we do not need to walk the hash table the next
107 * time we look for it.
109 SWAP(r
->parsed_objects
->obj_hash
[i
],
110 r
->parsed_objects
->obj_hash
[first
]);
116 * Increase the size of the hash map stored in obj_hash to the next
117 * power of 2 (but at least 32). Copy the existing values to the new
120 static void grow_object_hash(struct repository
*r
)
124 * Note that this size must always be power-of-2 to match hash_obj
127 int new_hash_size
= r
->parsed_objects
->obj_hash_size
< 32 ? 32 : 2 * r
->parsed_objects
->obj_hash_size
;
128 struct object
**new_hash
;
130 CALLOC_ARRAY(new_hash
, new_hash_size
);
131 for (i
= 0; i
< r
->parsed_objects
->obj_hash_size
; i
++) {
132 struct object
*obj
= r
->parsed_objects
->obj_hash
[i
];
136 insert_obj_hash(obj
, new_hash
, new_hash_size
);
138 free(r
->parsed_objects
->obj_hash
);
139 r
->parsed_objects
->obj_hash
= new_hash
;
140 r
->parsed_objects
->obj_hash_size
= new_hash_size
;
143 void *create_object(struct repository
*r
, const struct object_id
*oid
, void *o
)
145 struct object
*obj
= o
;
149 oidcpy(&obj
->oid
, oid
);
151 if (r
->parsed_objects
->obj_hash_size
- 1 <= r
->parsed_objects
->nr_objs
* 2)
154 insert_obj_hash(obj
, r
->parsed_objects
->obj_hash
,
155 r
->parsed_objects
->obj_hash_size
);
156 r
->parsed_objects
->nr_objs
++;
160 void *object_as_type(struct object
*obj
, enum object_type type
, int quiet
)
162 if (obj
->type
== type
)
164 else if (obj
->type
== OBJ_NONE
) {
165 if (type
== OBJ_COMMIT
)
166 init_commit_node((struct commit
*) obj
);
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(struct repository
*r
, const struct object_id
*oid
)
182 struct object
*obj
= lookup_object(r
, oid
);
184 obj
= create_object(r
, oid
, alloc_object_node(r
));
188 struct object
*lookup_object_by_type(struct repository
*r
,
189 const struct object_id
*oid
,
190 enum object_type type
)
194 return (struct object
*)lookup_commit(r
, oid
);
196 return (struct object
*)lookup_tree(r
, oid
);
198 return (struct object
*)lookup_tag(r
, oid
);
200 return (struct object
*)lookup_blob(r
, oid
);
202 BUG("unknown object type %d", type
);
206 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
)
212 if (type
== OBJ_BLOB
) {
213 struct blob
*blob
= lookup_blob(r
, oid
);
215 if (parse_blob_buffer(blob
, buffer
, size
))
219 } else if (type
== OBJ_TREE
) {
220 struct tree
*tree
= lookup_tree(r
, oid
);
224 tree
->object
.parsed
= 0;
225 if (!tree
->object
.parsed
) {
226 if (parse_tree_buffer(tree
, buffer
, size
))
231 } else if (type
== OBJ_COMMIT
) {
232 struct commit
*commit
= lookup_commit(r
, oid
);
234 if (parse_commit_buffer(r
, commit
, buffer
, size
, 1))
236 if (save_commit_buffer
&&
237 !get_cached_commit_buffer(r
, commit
, NULL
)) {
238 set_commit_buffer(r
, commit
, buffer
, size
);
241 obj
= &commit
->object
;
243 } else if (type
== OBJ_TAG
) {
244 struct tag
*tag
= lookup_tag(r
, oid
);
246 if (parse_tag_buffer(r
, tag
, buffer
, size
))
251 warning(_("object %s has unknown type id %d"), oid_to_hex(oid
), type
);
257 struct object
*parse_object_or_die(const struct object_id
*oid
,
260 struct object
*o
= parse_object(the_repository
, oid
);
264 die(_("unable to parse object: %s"), name
? name
: oid_to_hex(oid
));
267 struct object
*parse_object_with_flags(struct repository
*r
,
268 const struct object_id
*oid
,
269 enum parse_object_flags flags
)
271 int skip_hash
= !!(flags
& PARSE_OBJECT_SKIP_HASH_CHECK
);
273 enum object_type type
;
275 const struct object_id
*repl
= lookup_replace_object(r
, oid
);
279 obj
= lookup_object(r
, oid
);
280 if (obj
&& obj
->parsed
)
284 struct commit
*commit
= lookup_commit_in_graph(r
, repl
);
286 return &commit
->object
;
289 if ((obj
&& obj
->type
== OBJ_BLOB
&& repo_has_object_file(r
, oid
)) ||
290 (!obj
&& repo_has_object_file(r
, oid
) &&
291 oid_object_info(r
, oid
, NULL
) == OBJ_BLOB
)) {
292 if (!skip_hash
&& stream_object_signature(r
, repl
) < 0) {
293 error(_("hash mismatch %s"), oid_to_hex(oid
));
296 parse_blob_buffer(lookup_blob(r
, oid
), NULL
, 0);
297 return lookup_object(r
, oid
);
300 buffer
= repo_read_object_file(r
, oid
, &type
, &size
);
303 check_object_signature(r
, repl
, buffer
, size
, type
) < 0) {
305 error(_("hash mismatch %s"), oid_to_hex(repl
));
309 obj
= parse_object_buffer(r
, oid
, type
, size
,
318 struct object
*parse_object(struct repository
*r
, const struct object_id
*oid
)
320 return parse_object_with_flags(r
, oid
, 0);
323 struct object_list
*object_list_insert(struct object
*item
,
324 struct object_list
**list_p
)
326 struct object_list
*new_list
= xmalloc(sizeof(struct object_list
));
327 new_list
->item
= item
;
328 new_list
->next
= *list_p
;
333 int object_list_contains(struct object_list
*list
, struct object
*obj
)
336 if (list
->item
== obj
)
343 void object_list_free(struct object_list
**list
)
346 struct object_list
*p
= *list
;
353 * A zero-length string to which object_array_entry::name can be
354 * initialized without requiring a malloc/free.
356 static char object_array_slopbuf
[1];
358 void add_object_array_with_path(struct object
*obj
, const char *name
,
359 struct object_array
*array
,
360 unsigned mode
, const char *path
)
362 unsigned nr
= array
->nr
;
363 unsigned alloc
= array
->alloc
;
364 struct object_array_entry
*objects
= array
->objects
;
365 struct object_array_entry
*entry
;
368 alloc
= (alloc
+ 32) * 2;
369 REALLOC_ARRAY(objects
, alloc
);
370 array
->alloc
= alloc
;
371 array
->objects
= objects
;
373 entry
= &objects
[nr
];
378 /* Use our own empty string instead of allocating one: */
379 entry
->name
= object_array_slopbuf
;
381 entry
->name
= xstrdup(name
);
384 entry
->path
= xstrdup(path
);
390 void add_object_array(struct object
*obj
, const char *name
, struct object_array
*array
)
392 add_object_array_with_path(obj
, name
, array
, S_IFINVALID
, NULL
);
396 * Free all memory associated with an entry; the result is
397 * in an unspecified state and should not be examined.
399 static void object_array_release_entry(struct object_array_entry
*ent
)
401 if (ent
->name
!= object_array_slopbuf
)
406 struct object
*object_array_pop(struct object_array
*array
)
413 ret
= array
->objects
[array
->nr
- 1].item
;
414 object_array_release_entry(&array
->objects
[array
->nr
- 1]);
419 void object_array_filter(struct object_array
*array
,
420 object_array_each_func_t want
, void *cb_data
)
422 unsigned nr
= array
->nr
, src
, dst
;
423 struct object_array_entry
*objects
= array
->objects
;
425 for (src
= dst
= 0; src
< nr
; src
++) {
426 if (want(&objects
[src
], cb_data
)) {
428 objects
[dst
] = objects
[src
];
431 object_array_release_entry(&objects
[src
]);
437 void object_array_clear(struct object_array
*array
)
440 for (i
= 0; i
< array
->nr
; i
++)
441 object_array_release_entry(&array
->objects
[i
]);
442 FREE_AND_NULL(array
->objects
);
443 array
->nr
= array
->alloc
= 0;
447 * Return true if array already contains an entry.
449 static int contains_object(struct object_array
*array
,
450 const struct object
*item
, const char *name
)
452 unsigned nr
= array
->nr
, i
;
453 struct object_array_entry
*object
= array
->objects
;
455 for (i
= 0; i
< nr
; i
++, object
++)
456 if (item
== object
->item
&& !strcmp(object
->name
, name
))
461 void object_array_remove_duplicates(struct object_array
*array
)
463 unsigned nr
= array
->nr
, src
;
464 struct object_array_entry
*objects
= array
->objects
;
467 for (src
= 0; src
< nr
; src
++) {
468 if (!contains_object(array
, objects
[src
].item
,
469 objects
[src
].name
)) {
470 if (src
!= array
->nr
)
471 objects
[array
->nr
] = objects
[src
];
474 object_array_release_entry(&objects
[src
]);
479 void clear_object_flags(unsigned flags
)
483 for (i
=0; i
< the_repository
->parsed_objects
->obj_hash_size
; i
++) {
484 struct object
*obj
= the_repository
->parsed_objects
->obj_hash
[i
];
486 obj
->flags
&= ~flags
;
490 void repo_clear_commit_marks(struct repository
*r
, unsigned int flags
)
494 for (i
= 0; i
< r
->parsed_objects
->obj_hash_size
; i
++) {
495 struct object
*obj
= r
->parsed_objects
->obj_hash
[i
];
496 if (obj
&& obj
->type
== OBJ_COMMIT
)
497 obj
->flags
&= ~flags
;
501 struct parsed_object_pool
*parsed_object_pool_new(void)
503 struct parsed_object_pool
*o
= xmalloc(sizeof(*o
));
504 memset(o
, 0, sizeof(*o
));
506 o
->blob_state
= allocate_alloc_state();
507 o
->tree_state
= allocate_alloc_state();
508 o
->commit_state
= allocate_alloc_state();
509 o
->tag_state
= allocate_alloc_state();
510 o
->object_state
= allocate_alloc_state();
513 CALLOC_ARRAY(o
->shallow_stat
, 1);
515 o
->buffer_slab
= allocate_commit_buffer_slab();
520 struct raw_object_store
*raw_object_store_new(void)
522 struct raw_object_store
*o
= xmalloc(sizeof(*o
));
524 memset(o
, 0, sizeof(*o
));
525 INIT_LIST_HEAD(&o
->packed_git_mru
);
526 hashmap_init(&o
->pack_map
, pack_map_entry_cmp
, NULL
, 0);
527 pthread_mutex_init(&o
->replace_mutex
, NULL
);
531 void free_object_directory(struct object_directory
*odb
)
534 odb_clear_loose_cache(odb
);
538 static void free_object_directories(struct raw_object_store
*o
)
541 struct object_directory
*next
;
544 free_object_directory(o
->odb
);
547 kh_destroy_odb_path_map(o
->odb_by_path
);
548 o
->odb_by_path
= NULL
;
551 void raw_object_store_clear(struct raw_object_store
*o
)
553 FREE_AND_NULL(o
->alternate_db
);
555 oidmap_free(o
->replace_map
, 1);
556 FREE_AND_NULL(o
->replace_map
);
557 pthread_mutex_destroy(&o
->replace_mutex
);
559 free_commit_graph(o
->commit_graph
);
560 o
->commit_graph
= NULL
;
561 o
->commit_graph_attempted
= 0;
563 free_object_directories(o
);
565 o
->loaded_alternates
= 0;
567 INIT_LIST_HEAD(&o
->packed_git_mru
);
568 close_object_store(o
);
569 o
->packed_git
= NULL
;
571 hashmap_clear(&o
->pack_map
);
574 void parsed_object_pool_clear(struct parsed_object_pool
*o
)
577 * As objects are allocated in slabs (see alloc.c), we do
578 * not need to free each object, but each slab instead.
580 * Before doing so, we need to free any additional memory
581 * the objects may hold.
585 for (i
= 0; i
< o
->obj_hash_size
; i
++) {
586 struct object
*obj
= o
->obj_hash
[i
];
591 if (obj
->type
== OBJ_TREE
)
592 free_tree_buffer((struct tree
*)obj
);
593 else if (obj
->type
== OBJ_COMMIT
)
594 release_commit_memory(o
, (struct commit
*)obj
);
595 else if (obj
->type
== OBJ_TAG
)
596 release_tag_memory((struct tag
*)obj
);
599 FREE_AND_NULL(o
->obj_hash
);
600 o
->obj_hash_size
= 0;
602 free_commit_buffer_slab(o
->buffer_slab
);
603 o
->buffer_slab
= NULL
;
605 clear_alloc_state(o
->blob_state
);
606 clear_alloc_state(o
->tree_state
);
607 clear_alloc_state(o
->commit_state
);
608 clear_alloc_state(o
->tag_state
);
609 clear_alloc_state(o
->object_state
);
610 stat_validity_clear(o
->shallow_stat
);
611 FREE_AND_NULL(o
->blob_state
);
612 FREE_AND_NULL(o
->tree_state
);
613 FREE_AND_NULL(o
->commit_state
);
614 FREE_AND_NULL(o
->tag_state
);
615 FREE_AND_NULL(o
->object_state
);
616 FREE_AND_NULL(o
->shallow_stat
);