]>
Commit | Line | Data |
---|---|---|
90c62155 SB |
1 | #ifndef OBJECT_STORE_H |
2 | #define OBJECT_STORE_H | |
3 | ||
ef3ca954 | 4 | #include "cache.h" |
d88f9fdf | 5 | #include "oidmap.h" |
14727b7f JT |
6 | #include "list.h" |
7 | #include "sha1-array.h" | |
8 | #include "strbuf.h" | |
d88f9fdf | 9 | |
263db403 JK |
10 | struct object_directory { |
11 | struct object_directory *next; | |
0d4a1321 | 12 | |
0d4a1321 | 13 | /* |
3a2e0824 JK |
14 | * Used to store the results of readdir(3) calls when we are OK |
15 | * sacrificing accuracy due to races for speed. That includes | |
61c7711c | 16 | * object existence with OBJECT_INFO_QUICK, as well as |
3a2e0824 JK |
17 | * our search for unique abbreviated hashes. Don't use it for tasks |
18 | * requiring greater accuracy! | |
19 | * | |
20 | * Be sure to call odb_load_loose_cache() before using. | |
0d4a1321 SB |
21 | */ |
22 | char loose_objects_subdir_seen[256]; | |
23 | struct oid_array loose_objects_cache; | |
24 | ||
77f012e8 SB |
25 | /* |
26 | * Path to the alternative object store. If this is a relative path, | |
27 | * it is relative to the current working directory. | |
28 | */ | |
f0eaf638 | 29 | char *path; |
031dc927 | 30 | }; |
f0eaf638 | 31 | |
13068bf0 | 32 | void prepare_alt_odb(struct repository *r); |
0d4a1321 | 33 | char *compute_alternate_path(const char *path, struct strbuf *err); |
263db403 | 34 | typedef int alt_odb_fn(struct object_directory *, void *); |
0d4a1321 SB |
35 | int foreach_alt_odb(alt_odb_fn, void*); |
36 | ||
0d4a1321 SB |
37 | /* |
38 | * Add the directory to the on-disk alternates file; the new entry will also | |
39 | * take effect in the current process. | |
40 | */ | |
41 | void add_to_alternates_file(const char *dir); | |
42 | ||
43 | /* | |
44 | * Add the directory to the in-memory list of alternates (along with any | |
45 | * recursive alternates it points to), but do not modify the on-disk alternates | |
46 | * file. | |
47 | */ | |
48 | void add_to_alternates_memory(const char *dir); | |
49 | ||
3a2e0824 JK |
50 | /* |
51 | * Populate an odb's loose object cache for one particular subdirectory (i.e., | |
52 | * the one that corresponds to the first byte of objects you're interested in, | |
53 | * from 0 to 255 inclusive). | |
54 | */ | |
55 | void odb_load_loose_cache(struct object_directory *odb, int subdir_nr); | |
56 | ||
a80d72db SB |
57 | struct packed_git { |
58 | struct packed_git *next; | |
59 | struct list_head mru; | |
60 | struct pack_window *windows; | |
61 | off_t pack_size; | |
62 | const void *index_data; | |
63 | size_t index_size; | |
64 | uint32_t num_objects; | |
65 | uint32_t num_bad_objects; | |
66 | unsigned char *bad_object_sha1; | |
67 | int index_version; | |
68 | time_t mtime; | |
69 | int pack_fd; | |
43fa44fa | 70 | int index; /* for builtin/pack-objects.c */ |
a80d72db SB |
71 | unsigned pack_local:1, |
72 | pack_keep:1, | |
ed7e5fc3 | 73 | pack_keep_in_core:1, |
a80d72db SB |
74 | freshened:1, |
75 | do_not_close:1, | |
76 | pack_promisor:1; | |
77 | unsigned char sha1[20]; | |
78 | struct revindex_entry *revindex; | |
79 | /* something like ".git/objects/pack/xxxxx.pack" */ | |
80 | char pack_name[FLEX_ARRAY]; /* more */ | |
81 | }; | |
82 | ||
4d80560c DS |
83 | struct multi_pack_index; |
84 | ||
90c62155 SB |
85 | struct raw_object_store { |
86 | /* | |
f0eaf638 JK |
87 | * Set of all object directories; the main directory is first (and |
88 | * cannot be NULL after initialization). Subsequent directories are | |
89 | * alternates. | |
90c62155 | 90 | */ |
f0eaf638 JK |
91 | struct object_directory *odb; |
92 | struct object_directory **odb_tail; | |
93 | int loaded_alternates; | |
90c62155 | 94 | |
f0eaf638 JK |
95 | /* |
96 | * A list of alternate object directories loaded from the environment; | |
97 | * this should not generally need to be accessed directly, but will | |
98 | * populate the "odb" list when prepare_alt_odb() is run. | |
99 | */ | |
90c62155 | 100 | char *alternate_db; |
031dc927 | 101 | |
d88f9fdf SB |
102 | /* |
103 | * Objects that should be substituted by other objects | |
104 | * (see git-replace(1)). | |
105 | */ | |
c1274495 | 106 | struct oidmap *replace_map; |
d88f9fdf | 107 | |
85277506 JT |
108 | struct commit_graph *commit_graph; |
109 | unsigned commit_graph_attempted : 1; /* if loading has been attempted */ | |
110 | ||
c4d25228 DS |
111 | /* |
112 | * private data | |
113 | * | |
114 | * should only be accessed directly by packfile.c and midx.c | |
115 | */ | |
116 | struct multi_pack_index *multi_pack_index; | |
117 | ||
a80d72db SB |
118 | /* |
119 | * private data | |
120 | * | |
121 | * should only be accessed directly by packfile.c | |
122 | */ | |
123 | ||
124 | struct packed_git *packed_git; | |
125 | /* A most-recently-used ordered version of the packed_git list. */ | |
126 | struct list_head packed_git_mru; | |
5508f693 | 127 | |
0bff5269 DS |
128 | /* |
129 | * A linked list containing all packfiles, starting with those | |
130 | * contained in the multi_pack_index. | |
131 | */ | |
132 | struct packed_git *all_packs; | |
133 | ||
9a00580d SB |
134 | /* |
135 | * A fast, rough count of the number of objects in the repository. | |
136 | * These two fields are not meant for direct access. Use | |
137 | * approximate_object_count() instead. | |
138 | */ | |
139 | unsigned long approximate_object_count; | |
140 | unsigned approximate_object_count_valid : 1; | |
141 | ||
5508f693 SB |
142 | /* |
143 | * Whether packed_git has already been populated with this repository's | |
144 | * packs. | |
145 | */ | |
146 | unsigned packed_git_initialized : 1; | |
90c62155 SB |
147 | }; |
148 | ||
149 | struct raw_object_store *raw_object_store_new(void); | |
150 | void raw_object_store_clear(struct raw_object_store *o); | |
151 | ||
cf78ae4f SB |
152 | /* |
153 | * Put in `buf` the name of the file in the local object database that | |
154 | * would be used to store a loose object with the specified sha1. | |
155 | */ | |
f3f043a1 | 156 | const char *loose_object_path(struct repository *r, struct strbuf *buf, const unsigned char *sha1); |
cf78ae4f | 157 | |
bd27f50c | 158 | void *map_sha1_file(struct repository *r, const unsigned char *sha1, unsigned long *size); |
e35454fa | 159 | |
cbd53a21 SB |
160 | extern void *read_object_file_extended(const struct object_id *oid, |
161 | enum object_type *type, | |
162 | unsigned long *size, int lookup_replace); | |
163 | static inline void *read_object_file(const struct object_id *oid, enum object_type *type, unsigned long *size) | |
164 | { | |
165 | return read_object_file_extended(oid, type, size, 1); | |
166 | } | |
167 | ||
168 | /* Read and unpack an object file into memory, write memory to an object file */ | |
169 | int oid_object_info(struct repository *r, const struct object_id *, unsigned long *); | |
170 | ||
171 | extern int hash_object_file(const void *buf, unsigned long len, | |
172 | const char *type, struct object_id *oid); | |
173 | ||
174 | extern int write_object_file(const void *buf, unsigned long len, | |
175 | const char *type, struct object_id *oid); | |
176 | ||
177 | extern int hash_object_file_literally(const void *buf, unsigned long len, | |
178 | const char *type, struct object_id *oid, | |
179 | unsigned flags); | |
180 | ||
181 | extern int pretend_object_file(void *, unsigned long, enum object_type, | |
182 | struct object_id *oid); | |
183 | ||
184 | extern int force_object_loose(const struct object_id *oid, time_t mtime); | |
185 | ||
186 | /* | |
187 | * Open the loose object at path, check its hash, and return the contents, | |
188 | * type, and size. If the object is a blob, then "contents" may return NULL, | |
189 | * to allow streaming of large blobs. | |
190 | * | |
191 | * Returns 0 on success, negative on error (details may be written to stderr). | |
192 | */ | |
193 | int read_loose_object(const char *path, | |
194 | const struct object_id *expected_oid, | |
195 | enum object_type *type, | |
196 | unsigned long *size, | |
197 | void **contents); | |
198 | ||
199 | /* | |
200 | * Convenience for sha1_object_info_extended() with a NULL struct | |
201 | * object_info. OBJECT_INFO_SKIP_CACHED is automatically set; pass | |
202 | * nonzero flags to also set other flags. | |
203 | */ | |
204 | extern int has_sha1_file_with_flags(const unsigned char *sha1, int flags); | |
205 | static inline int has_sha1_file(const unsigned char *sha1) | |
206 | { | |
207 | return has_sha1_file_with_flags(sha1, 0); | |
208 | } | |
209 | ||
210 | /* Same as the above, except for struct object_id. */ | |
211 | extern int has_object_file(const struct object_id *oid); | |
212 | extern int has_object_file_with_flags(const struct object_id *oid, int flags); | |
213 | ||
214 | /* | |
215 | * Return true iff an alternate object database has a loose object | |
216 | * with the specified name. This function does not respect replace | |
217 | * references. | |
218 | */ | |
b16b60f7 | 219 | extern int has_loose_object_nonlocal(const struct object_id *); |
cbd53a21 SB |
220 | |
221 | extern void assert_oid_type(const struct object_id *oid, enum object_type expect); | |
222 | ||
223 | struct object_info { | |
224 | /* Request */ | |
225 | enum object_type *typep; | |
226 | unsigned long *sizep; | |
227 | off_t *disk_sizep; | |
228 | unsigned char *delta_base_sha1; | |
229 | struct strbuf *type_name; | |
230 | void **contentp; | |
231 | ||
232 | /* Response */ | |
233 | enum { | |
234 | OI_CACHED, | |
235 | OI_LOOSE, | |
236 | OI_PACKED, | |
237 | OI_DBCACHED | |
238 | } whence; | |
239 | union { | |
240 | /* | |
241 | * struct { | |
242 | * ... Nothing to expose in this case | |
243 | * } cached; | |
244 | * struct { | |
245 | * ... Nothing to expose in this case | |
246 | * } loose; | |
247 | */ | |
248 | struct { | |
249 | struct packed_git *pack; | |
250 | off_t offset; | |
251 | unsigned int is_delta; | |
252 | } packed; | |
253 | } u; | |
254 | }; | |
255 | ||
256 | /* | |
257 | * Initializer for a "struct object_info" that wants no items. You may | |
258 | * also memset() the memory to all-zeroes. | |
259 | */ | |
260 | #define OBJECT_INFO_INIT {NULL} | |
261 | ||
262 | /* Invoke lookup_replace_object() on the given hash */ | |
263 | #define OBJECT_INFO_LOOKUP_REPLACE 1 | |
264 | /* Allow reading from a loose object file of unknown/bogus type */ | |
265 | #define OBJECT_INFO_ALLOW_UNKNOWN_TYPE 2 | |
266 | /* Do not check cached storage */ | |
267 | #define OBJECT_INFO_SKIP_CACHED 4 | |
268 | /* Do not retry packed storage after checking packed and loose storage */ | |
269 | #define OBJECT_INFO_QUICK 8 | |
270 | /* Do not check loose object */ | |
271 | #define OBJECT_INFO_IGNORE_LOOSE 16 | |
272 | ||
273 | int oid_object_info_extended(struct repository *r, | |
274 | const struct object_id *, | |
275 | struct object_info *, unsigned flags); | |
276 | ||
0889aae1 JK |
277 | /* |
278 | * Iterate over the files in the loose-object parts of the object | |
279 | * directory "path", triggering the following callbacks: | |
280 | * | |
281 | * - loose_object is called for each loose object we find. | |
282 | * | |
283 | * - loose_cruft is called for any files that do not appear to be | |
284 | * loose objects. Note that we only look in the loose object | |
285 | * directories "objects/[0-9a-f]{2}/", so we will not report | |
286 | * "objects/foobar" as cruft. | |
287 | * | |
288 | * - loose_subdir is called for each top-level hashed subdirectory | |
289 | * of the object directory (e.g., "$OBJDIR/f0"). It is called | |
290 | * after the objects in the directory are processed. | |
291 | * | |
292 | * Any callback that is NULL will be ignored. Callbacks returning non-zero | |
293 | * will end the iteration. | |
294 | * | |
295 | * In the "buf" variant, "path" is a strbuf which will also be used as a | |
296 | * scratch buffer, but restored to its original contents before | |
297 | * the function returns. | |
298 | */ | |
299 | typedef int each_loose_object_fn(const struct object_id *oid, | |
300 | const char *path, | |
301 | void *data); | |
302 | typedef int each_loose_cruft_fn(const char *basename, | |
303 | const char *path, | |
304 | void *data); | |
305 | typedef int each_loose_subdir_fn(unsigned int nr, | |
306 | const char *path, | |
307 | void *data); | |
308 | int for_each_file_in_obj_subdir(unsigned int subdir_nr, | |
309 | struct strbuf *path, | |
310 | each_loose_object_fn obj_cb, | |
311 | each_loose_cruft_fn cruft_cb, | |
312 | each_loose_subdir_fn subdir_cb, | |
313 | void *data); | |
314 | int for_each_loose_file_in_objdir(const char *path, | |
315 | each_loose_object_fn obj_cb, | |
316 | each_loose_cruft_fn cruft_cb, | |
317 | each_loose_subdir_fn subdir_cb, | |
318 | void *data); | |
319 | int for_each_loose_file_in_objdir_buf(struct strbuf *path, | |
320 | each_loose_object_fn obj_cb, | |
321 | each_loose_cruft_fn cruft_cb, | |
322 | each_loose_subdir_fn subdir_cb, | |
323 | void *data); | |
324 | ||
325 | /* Flags for for_each_*_object() below. */ | |
326 | enum for_each_object_flags { | |
327 | /* Iterate only over local objects, not alternates. */ | |
328 | FOR_EACH_OBJECT_LOCAL_ONLY = (1<<0), | |
329 | ||
330 | /* Only iterate over packs obtained from the promisor remote. */ | |
331 | FOR_EACH_OBJECT_PROMISOR_ONLY = (1<<1), | |
332 | ||
333 | /* | |
334 | * Visit objects within a pack in packfile order rather than .idx order | |
335 | */ | |
336 | FOR_EACH_OBJECT_PACK_ORDER = (1<<2), | |
337 | }; | |
338 | ||
339 | /* | |
340 | * Iterate over all accessible loose objects without respect to | |
341 | * reachability. By default, this includes both local and alternate objects. | |
342 | * The order in which objects are visited is unspecified. | |
343 | * | |
344 | * Any flags specific to packs are ignored. | |
345 | */ | |
346 | int for_each_loose_object(each_loose_object_fn, void *, | |
347 | enum for_each_object_flags flags); | |
348 | ||
349 | /* | |
350 | * Iterate over all accessible packed objects without respect to reachability. | |
351 | * By default, this includes both local and alternate packs. | |
352 | * | |
353 | * Note that some objects may appear twice if they are found in multiple packs. | |
354 | * Each pack is visited in an unspecified order. By default, objects within a | |
355 | * pack are visited in pack-idx order (i.e., sorted by oid). | |
356 | */ | |
357 | typedef int each_packed_object_fn(const struct object_id *oid, | |
358 | struct packed_git *pack, | |
359 | uint32_t pos, | |
360 | void *data); | |
361 | int for_each_object_in_pack(struct packed_git *p, | |
362 | each_packed_object_fn, void *data, | |
363 | enum for_each_object_flags flags); | |
364 | int for_each_packed_object(each_packed_object_fn, void *, | |
365 | enum for_each_object_flags flags); | |
366 | ||
90c62155 | 367 | #endif /* OBJECT_STORE_H */ |