🌐 AI搜索 & 代理 主页
Google Git
Sign in
chromium / external / github.com / git / git / refs/tags/v2.37.0 / . / pack-write.c
blob: 00787e306db4c010ae68845f27ed69966fb9e250 [file] [log] [blame]
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]1#include "cache.h"
2#include "pack.h"
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]3#include "csum-file.h"
Christian Couder33add2a2021-01-12 08:21:59[diff] [blame]4#include "remote.h"
Taylor Blaud9fef9d2022-05-20 23:17:41[diff] [blame]5#include "chunk-format.h"
Taylor Blau5dfaf492022-05-20 23:17:43[diff] [blame]6#include "pack-mtimes.h"
7#include "oidmap.h"
8#include "chunk-format.h"
9#include "pack-objects.h"
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]10
Junio C Hamanoebcfb372011-02-25 23:43:25[diff] [blame]11void reset_pack_idx_option(struct pack_idx_option *opts)
12{
13 memset(opts, 0, sizeof(*opts));
14 opts->version = 2;
15 opts->off32_limit = 0x7fffffff;
16}
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]17
18static int sha1_compare(const void *_a, const void *_b)
19{
20 struct pack_idx_entry *a = *(struct pack_idx_entry **)_a;
21 struct pack_idx_entry *b = *(struct pack_idx_entry **)_b;
brian m. carlsone6a492b2017-05-06 22:10:11[diff] [blame]22 return oidcmp(&a->oid, &b->oid);
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]23}
24
Junio C Hamano3c9fc072011-02-26 00:55:26[diff] [blame]25static int cmp_uint32(const void *a_, const void *b_)
26{
27 uint32_t a = *((uint32_t *)a_);
28 uint32_t b = *((uint32_t *)b_);
29
30 return (a < b) ? -1 : (a != b);
31}
32
Junio C Hamanofb956c12011-02-26 00:54:00[diff] [blame]33static int need_large_offset(off_t offset, const struct pack_idx_option *opts)
34{
Junio C Hamano3c9fc072011-02-26 00:55:26[diff] [blame]35 uint32_t ofsval;
36
37 if ((offset >> 31) || (opts->off32_limit < offset))
38 return 1;
39 if (!opts->anomaly_nr)
40 return 0;
41 ofsval = offset;
42 return !!bsearch(&ofsval, opts->anomaly, opts->anomaly_nr,
43 sizeof(ofsval), cmp_uint32);
Junio C Hamanofb956c12011-02-26 00:54:00[diff] [blame]44}
45
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]46/*
Johannes Berge2bfa502020-07-22 21:40:31[diff] [blame]47 * The *sha1 contains the pack content SHA1 hash.
48 * The objects array passed in will be sorted by SHA1 on exit.
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]49 */
Linus Torvalds3bb72562010-01-22 15:55:19[diff] [blame]50const char *write_idx_file(const char *index_name, struct pack_idx_entry **objects,
Junio C Hamanoebcfb372011-02-25 23:43:25[diff] [blame]51 int nr_objects, const struct pack_idx_option *opts,
Jeff King1190a1a2013-12-05 20:28:07[diff] [blame]52 const unsigned char *sha1)
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]53{
brian m. carlson98a3bea2018-02-01 02:18:46[diff] [blame]54 struct hashfile *f;
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]55 struct pack_idx_entry **sorted_by_sha, **list, **last;
56 off_t last_obj_offset = 0;
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]57 int i, fd;
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]58 uint32_t index_version;
59
60 if (nr_objects) {
61 sorted_by_sha = objects;
62 list = sorted_by_sha;
63 last = sorted_by_sha + nr_objects;
64 for (i = 0; i < nr_objects; ++i) {
65 if (objects[i]->offset > last_obj_offset)
66 last_obj_offset = objects[i]->offset;
67 }
René Scharfe9ed0d8d2016-09-29 15:27:31[diff] [blame]68 QSORT(sorted_by_sha, nr_objects, sha1_compare);
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]69 }
70 else
71 sorted_by_sha = list = last = NULL;
72
Junio C Hamanoe337a042011-02-03 01:29:01[diff] [blame]73 if (opts->flags & WRITE_IDX_VERIFY) {
74 assert(index_name);
brian m. carlson98a3bea2018-02-01 02:18:46[diff] [blame]75 f = hashfd_check(index_name);
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]76 } else {
Junio C Hamanoe337a042011-02-03 01:29:01[diff] [blame]77 if (!index_name) {
Jeff King594fa992017-03-28 19:45:43[diff] [blame]78 struct strbuf tmp_file = STRBUF_INIT;
79 fd = odb_mkstemp(&tmp_file, "pack/tmp_idx_XXXXXX");
80 index_name = strbuf_detach(&tmp_file, NULL);
Junio C Hamanoe337a042011-02-03 01:29:01[diff] [blame]81 } else {
82 unlink(index_name);
René Scharfe66e905b2021-08-25 20:16:46[diff] [blame]83 fd = xopen(index_name, O_CREAT|O_EXCL|O_WRONLY, 0600);
Junio C Hamanoe337a042011-02-03 01:29:01[diff] [blame]84 }
brian m. carlson98a3bea2018-02-01 02:18:46[diff] [blame]85 f = hashfd(fd, index_name);
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]86 }
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]87
88 /* if last object's offset is >= 2^31 we should use index V2 */
Junio C Hamanofb956c12011-02-26 00:54:00[diff] [blame]89 index_version = need_large_offset(last_obj_offset, opts) ? 2 : opts->version;
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]90
91 /* index versions 2 and above need a header */
92 if (index_version >= 2) {
93 struct pack_idx_header hdr;
94 hdr.idx_signature = htonl(PACK_IDX_SIGNATURE);
95 hdr.idx_version = htonl(index_version);
brian m. carlson98a3bea2018-02-01 02:18:46[diff] [blame]96 hashwrite(f, &hdr, sizeof(hdr));
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]97 }
98
99 /*
100 * Write the first-level table (the list is sorted,
101 * but we use a 256-entry lookup to be able to avoid
102 * having to do eight extra binary search iterations).
103 */
104 for (i = 0; i < 256; i++) {
105 struct pack_idx_entry **next = list;
106 while (next < last) {
107 struct pack_idx_entry *obj = *next;
brian m. carlsone6a492b2017-05-06 22:10:11[diff] [blame]108 if (obj->oid.hash[0] != i)
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]109 break;
110 next++;
111 }
René Scharfe06d43fa2020-11-01 08:52:12[diff] [blame]112 hashwrite_be32(f, next - sorted_by_sha);
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]113 list = next;
114 }
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]115
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]116 /*
117 * Write the actual SHA1 entries..
118 */
119 list = sorted_by_sha;
120 for (i = 0; i < nr_objects; i++) {
121 struct pack_idx_entry *obj = *list++;
René Scharfe389cf682020-09-19 18:26:36[diff] [blame]122 if (index_version < 2)
123 hashwrite_be32(f, obj->offset);
brian m. carlson98a3bea2018-02-01 02:18:46[diff] [blame]124 hashwrite(f, obj->oid.hash, the_hash_algo->rawsz);
Junio C Hamano68be2fe2011-11-17 06:04:13[diff] [blame]125 if ((opts->flags & WRITE_IDX_STRICT) &&
Jeff King4a7e27e2018-08-28 21:22:40[diff] [blame]126 (i && oideq(&list[-2]->oid, &obj->oid)))
Junio C Hamano68be2fe2011-11-17 06:04:13[diff] [blame]127 die("The same object %s appears twice in the pack",
brian m. carlsone6a492b2017-05-06 22:10:11[diff] [blame]128 oid_to_hex(&obj->oid));
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]129 }
130
131 if (index_version >= 2) {
132 unsigned int nr_large_offset = 0;
133
134 /* write the crc32 table */
135 list = sorted_by_sha;
136 for (i = 0; i < nr_objects; i++) {
137 struct pack_idx_entry *obj = *list++;
René Scharfe389cf682020-09-19 18:26:36[diff] [blame]138 hashwrite_be32(f, obj->crc32);
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]139 }
140
141 /* write the 32-bit offset table */
142 list = sorted_by_sha;
143 for (i = 0; i < nr_objects; i++) {
144 struct pack_idx_entry *obj = *list++;
Junio C Hamanofb956c12011-02-26 00:54:00[diff] [blame]145 uint32_t offset;
146
147 offset = (need_large_offset(obj->offset, opts)
148 ? (0x80000000 | nr_large_offset++)
149 : obj->offset);
René Scharfe389cf682020-09-19 18:26:36[diff] [blame]150 hashwrite_be32(f, offset);
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]151 }
152
153 /* write the large offset table */
154 list = sorted_by_sha;
155 while (nr_large_offset) {
156 struct pack_idx_entry *obj = *list++;
157 uint64_t offset = obj->offset;
Junio C Hamanofb956c12011-02-26 00:54:00[diff] [blame]158
159 if (!need_large_offset(offset, opts))
160 continue;
René Scharfe970909c2020-11-12 12:23:10[diff] [blame]161 hashwrite_be64(f, offset);
Junio C Hamanofb956c12011-02-26 00:54:00[diff] [blame]162 nr_large_offset--;
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]163 }
164 }
165
brian m. carlson98a3bea2018-02-01 02:18:46[diff] [blame]166 hashwrite(f, sha1, the_hash_algo->rawsz);
Neeraj Singh020406e2022-03-10 22:43:21[diff] [blame]167 finalize_hashfile(f, NULL, FSYNC_COMPONENT_PACK_METADATA,
168 CSUM_HASH_IN_STREAM | CSUM_CLOSE |
169 ((opts->flags & WRITE_IDX_VERIFY) ? 0 : CSUM_FSYNC));
Geert Boschaa7e44b2007-06-01 19:18:05[diff] [blame]170 return index_name;
171}
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]172
Taylor Blau8ef50d92021-01-25 23:37:18[diff] [blame]173static int pack_order_cmp(const void *va, const void *vb, void *ctx)
174{
175 struct pack_idx_entry **objects = ctx;
176
177 off_t oa = objects[*(uint32_t*)va]->offset;
178 off_t ob = objects[*(uint32_t*)vb]->offset;
179
180 if (oa < ob)
181 return -1;
182 if (oa > ob)
183 return 1;
184 return 0;
185}
186
187static void write_rev_header(struct hashfile *f)
188{
Taylor Blau8ef50d92021-01-25 23:37:18[diff] [blame]189 hashwrite_be32(f, RIDX_SIGNATURE);
190 hashwrite_be32(f, RIDX_VERSION);
Taylor Blaud9fef9d2022-05-20 23:17:41[diff] [blame]191 hashwrite_be32(f, oid_version(the_hash_algo));
Taylor Blau8ef50d92021-01-25 23:37:18[diff] [blame]192}
193
194static void write_rev_index_positions(struct hashfile *f,
Taylor Blaua587b5a2021-03-30 15:04:29[diff] [blame]195 uint32_t *pack_order,
Taylor Blau8ef50d92021-01-25 23:37:18[diff] [blame]196 uint32_t nr_objects)
197{
Taylor Blau8ef50d92021-01-25 23:37:18[diff] [blame]198 uint32_t i;
Taylor Blau8ef50d92021-01-25 23:37:18[diff] [blame]199 for (i = 0; i < nr_objects; i++)
200 hashwrite_be32(f, pack_order[i]);
Taylor Blau8ef50d92021-01-25 23:37:18[diff] [blame]201}
202
203static void write_rev_trailer(struct hashfile *f, const unsigned char *hash)
204{
205 hashwrite(f, hash, the_hash_algo->rawsz);
206}
207
208const char *write_rev_file(const char *rev_name,
209 struct pack_idx_entry **objects,
210 uint32_t nr_objects,
211 const unsigned char *hash,
212 unsigned flags)
213{
Taylor Blaua587b5a2021-03-30 15:04:29[diff] [blame]214 uint32_t *pack_order;
215 uint32_t i;
216 const char *ret;
217
Ævar Arnfjörð Bjarmason8fe8bae2021-09-08 01:08:03[diff] [blame]218 if (!(flags & WRITE_REV) && !(flags & WRITE_REV_VERIFY))
219 return NULL;
220
Taylor Blaua587b5a2021-03-30 15:04:29[diff] [blame]221 ALLOC_ARRAY(pack_order, nr_objects);
222 for (i = 0; i < nr_objects; i++)
223 pack_order[i] = i;
224 QSORT_S(pack_order, nr_objects, pack_order_cmp, objects);
225
226 ret = write_rev_file_order(rev_name, pack_order, nr_objects, hash,
227 flags);
228
229 free(pack_order);
230
231 return ret;
232}
233
234const char *write_rev_file_order(const char *rev_name,
235 uint32_t *pack_order,
236 uint32_t nr_objects,
237 const unsigned char *hash,
238 unsigned flags)
239{
Taylor Blau8ef50d92021-01-25 23:37:18[diff] [blame]240 struct hashfile *f;
241 int fd;
242
243 if ((flags & WRITE_REV) && (flags & WRITE_REV_VERIFY))
244 die(_("cannot both write and verify reverse index"));
245
246 if (flags & WRITE_REV) {
247 if (!rev_name) {
248 struct strbuf tmp_file = STRBUF_INIT;
249 fd = odb_mkstemp(&tmp_file, "pack/tmp_rev_XXXXXX");
250 rev_name = strbuf_detach(&tmp_file, NULL);
251 } else {
252 unlink(rev_name);
René Scharfe66e905b2021-08-25 20:16:46[diff] [blame]253 fd = xopen(rev_name, O_CREAT|O_EXCL|O_WRONLY, 0600);
Taylor Blau8ef50d92021-01-25 23:37:18[diff] [blame]254 }
255 f = hashfd(fd, rev_name);
256 } else if (flags & WRITE_REV_VERIFY) {
257 struct stat statbuf;
258 if (stat(rev_name, &statbuf)) {
259 if (errno == ENOENT) {
260 /* .rev files are optional */
261 return NULL;
262 } else
263 die_errno(_("could not stat: %s"), rev_name);
264 }
265 f = hashfd_check(rev_name);
266 } else
267 return NULL;
268
269 write_rev_header(f);
270
Taylor Blaua587b5a2021-03-30 15:04:29[diff] [blame]271 write_rev_index_positions(f, pack_order, nr_objects);
Taylor Blau8ef50d92021-01-25 23:37:18[diff] [blame]272 write_rev_trailer(f, hash);
273
274 if (rev_name && adjust_shared_perm(rev_name) < 0)
275 die(_("failed to make %s readable"), rev_name);
276
Neeraj Singh020406e2022-03-10 22:43:21[diff] [blame]277 finalize_hashfile(f, NULL, FSYNC_COMPONENT_PACK_METADATA,
278 CSUM_HASH_IN_STREAM | CSUM_CLOSE |
279 ((flags & WRITE_IDX_VERIFY) ? 0 : CSUM_FSYNC));
Taylor Blau8ef50d92021-01-25 23:37:18[diff] [blame]280
281 return rev_name;
282}
283
Taylor Blau5dfaf492022-05-20 23:17:43[diff] [blame]284static void write_mtimes_header(struct hashfile *f)
285{
286 hashwrite_be32(f, MTIMES_SIGNATURE);
287 hashwrite_be32(f, MTIMES_VERSION);
288 hashwrite_be32(f, oid_version(the_hash_algo));
289}
290
291/*
292 * Writes the object mtimes of "objects" for use in a .mtimes file.
293 * Note that objects must be in lexicographic (index) order, which is
294 * the expected ordering of these values in the .mtimes file.
295 */
296static void write_mtimes_objects(struct hashfile *f,
297 struct packing_data *to_pack,
298 struct pack_idx_entry **objects,
299 uint32_t nr_objects)
300{
301 uint32_t i;
302 for (i = 0; i < nr_objects; i++) {
303 struct object_entry *e = (struct object_entry*)objects[i];
304 hashwrite_be32(f, oe_cruft_mtime(to_pack, e));
305 }
306}
307
308static void write_mtimes_trailer(struct hashfile *f, const unsigned char *hash)
309{
310 hashwrite(f, hash, the_hash_algo->rawsz);
311}
312
Derrick Stolee82db1952022-06-16 13:13:49[diff] [blame]313static const char *write_mtimes_file(struct packing_data *to_pack,
Taylor Blau5dfaf492022-05-20 23:17:43[diff] [blame]314 struct pack_idx_entry **objects,
315 uint32_t nr_objects,
316 const unsigned char *hash)
317{
Derrick Stolee82db1952022-06-16 13:13:49[diff] [blame]318 struct strbuf tmp_file = STRBUF_INIT;
319 const char *mtimes_name;
Taylor Blau5dfaf492022-05-20 23:17:43[diff] [blame]320 struct hashfile *f;
321 int fd;
322
323 if (!to_pack)
324 BUG("cannot call write_mtimes_file with NULL packing_data");
325
Derrick Stolee82db1952022-06-16 13:13:49[diff] [blame]326 fd = odb_mkstemp(&tmp_file, "pack/tmp_mtimes_XXXXXX");
327 mtimes_name = strbuf_detach(&tmp_file, NULL);
Taylor Blau5dfaf492022-05-20 23:17:43[diff] [blame]328 f = hashfd(fd, mtimes_name);
329
330 write_mtimes_header(f);
331 write_mtimes_objects(f, to_pack, objects, nr_objects);
332 write_mtimes_trailer(f, hash);
333
334 if (adjust_shared_perm(mtimes_name) < 0)
335 die(_("failed to make %s readable"), mtimes_name);
336
337 finalize_hashfile(f, NULL, FSYNC_COMPONENT_PACK_METADATA,
338 CSUM_HASH_IN_STREAM | CSUM_CLOSE | CSUM_FSYNC);
339
340 return mtimes_name;
341}
342
brian m. carlson98a3bea2018-02-01 02:18:46[diff] [blame]343off_t write_pack_header(struct hashfile *f, uint32_t nr_entries)
Junio C Hamanoc0ad4652011-10-28 18:40:48[diff] [blame]344{
345 struct pack_header hdr;
346
347 hdr.hdr_signature = htonl(PACK_SIGNATURE);
348 hdr.hdr_version = htonl(PACK_VERSION);
349 hdr.hdr_entries = htonl(nr_entries);
brian m. carlson98a3bea2018-02-01 02:18:46[diff] [blame]350 hashwrite(f, &hdr, sizeof(hdr));
Junio C Hamanoc0ad4652011-10-28 18:40:48[diff] [blame]351 return sizeof(hdr);
352}
353
Nicolas Pitreabeb40e2008-08-29 20:07:59[diff] [blame]354/*
355 * Update pack header with object_count and compute new SHA1 for pack data
356 * associated to pack_fd, and write that SHA1 at the end. That new SHA1
357 * is also returned in new_pack_sha1.
358 *
359 * If partial_pack_sha1 is non null, then the SHA1 of the existing pack
360 * (without the header update) is computed and validated against the
361 * one provided in partial_pack_sha1. The validation is performed at
362 * partial_pack_offset bytes in the pack file. The SHA1 of the remaining
363 * data (i.e. from partial_pack_offset to the end) is then computed and
364 * returned in partial_pack_sha1.
365 *
366 * Note that new_pack_sha1 is updated last, so both new_pack_sha1 and
367 * partial_pack_sha1 can refer to the same buffer if the caller is not
368 * interested in the resulting SHA1 of pack data above partial_pack_offset.
369 */
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]370void fixup_pack_header_footer(int pack_fd,
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]371 unsigned char *new_pack_hash,
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]372 const char *pack_name,
Nicolas Pitreabeb40e2008-08-29 20:07:59[diff] [blame]373 uint32_t object_count,
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]374 unsigned char *partial_pack_hash,
Nicolas Pitreabeb40e2008-08-29 20:07:59[diff] [blame]375 off_t partial_pack_offset)
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]376{
Nicolas Pitred35825d2008-08-29 20:08:02[diff] [blame]377 int aligned_sz, buf_sz = 8 * 1024;
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]378 git_hash_ctx old_hash_ctx, new_hash_ctx;
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]379 struct pack_header hdr;
380 char *buf;
Jeff King90dca672017-09-27 06:01:07[diff] [blame]381 ssize_t read_result;
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]382
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]383 the_hash_algo->init_fn(&old_hash_ctx);
384 the_hash_algo->init_fn(&new_hash_ctx);
Nicolas Pitreabeb40e2008-08-29 20:07:59[diff] [blame]385
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]386 if (lseek(pack_fd, 0, SEEK_SET) != 0)
Thomas Rastd824cbb2009-06-27 15:58:46[diff] [blame]387 die_errno("Failed seeking to start of '%s'", pack_name);
Jeff King90dca672017-09-27 06:01:07[diff] [blame]388 read_result = read_in_full(pack_fd, &hdr, sizeof(hdr));
389 if (read_result < 0)
Thomas Rastd824cbb2009-06-27 15:58:46[diff] [blame]390 die_errno("Unable to reread header of '%s'", pack_name);
Jeff King90dca672017-09-27 06:01:07[diff] [blame]391 else if (read_result != sizeof(hdr))
392 die_errno("Unexpected short read for header of '%s'",
393 pack_name);
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]394 if (lseek(pack_fd, 0, SEEK_SET) != 0)
Thomas Rastd824cbb2009-06-27 15:58:46[diff] [blame]395 die_errno("Failed seeking to start of '%s'", pack_name);
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]396 the_hash_algo->update_fn(&old_hash_ctx, &hdr, sizeof(hdr));
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]397 hdr.hdr_entries = htonl(object_count);
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]398 the_hash_algo->update_fn(&new_hash_ctx, &hdr, sizeof(hdr));
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]399 write_or_die(pack_fd, &hdr, sizeof(hdr));
Nicolas Pitreabeb40e2008-08-29 20:07:59[diff] [blame]400 partial_pack_offset -= sizeof(hdr);
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]401
402 buf = xmalloc(buf_sz);
Nicolas Pitred35825d2008-08-29 20:08:02[diff] [blame]403 aligned_sz = buf_sz - sizeof(hdr);
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]404 for (;;) {
Nicolas Pitreabeb40e2008-08-29 20:07:59[diff] [blame]405 ssize_t m, n;
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]406 m = (partial_pack_hash && partial_pack_offset < aligned_sz) ?
Nicolas Pitred35825d2008-08-29 20:08:02[diff] [blame]407 partial_pack_offset : aligned_sz;
Nicolas Pitreabeb40e2008-08-29 20:07:59[diff] [blame]408 n = xread(pack_fd, buf, m);
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]409 if (!n)
410 break;
411 if (n < 0)
Thomas Rastd824cbb2009-06-27 15:58:46[diff] [blame]412 die_errno("Failed to checksum '%s'", pack_name);
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]413 the_hash_algo->update_fn(&new_hash_ctx, buf, n);
Nicolas Pitreabeb40e2008-08-29 20:07:59[diff] [blame]414
Nicolas Pitred35825d2008-08-29 20:08:02[diff] [blame]415 aligned_sz -= n;
416 if (!aligned_sz)
417 aligned_sz = buf_sz;
418
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]419 if (!partial_pack_hash)
Nicolas Pitreabeb40e2008-08-29 20:07:59[diff] [blame]420 continue;
421
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]422 the_hash_algo->update_fn(&old_hash_ctx, buf, n);
Nicolas Pitreabeb40e2008-08-29 20:07:59[diff] [blame]423 partial_pack_offset -= n;
424 if (partial_pack_offset == 0) {
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]425 unsigned char hash[GIT_MAX_RAWSZ];
426 the_hash_algo->final_fn(hash, &old_hash_ctx);
Jeff King67947c32018-08-28 21:22:52[diff] [blame]427 if (!hasheq(hash, partial_pack_hash))
Nicolas Pitreabeb40e2008-08-29 20:07:59[diff] [blame]428 die("Unexpected checksum for %s "
429 "(disk corruption?)", pack_name);
430 /*
431 * Now let's compute the SHA1 of the remainder of the
432 * pack, which also means making partial_pack_offset
433 * big enough not to matter anymore.
434 */
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]435 the_hash_algo->init_fn(&old_hash_ctx);
Nicolas Pitreabeb40e2008-08-29 20:07:59[diff] [blame]436 partial_pack_offset = ~partial_pack_offset;
437 partial_pack_offset -= MSB(partial_pack_offset, 1);
438 }
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]439 }
440 free(buf);
441
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]442 if (partial_pack_hash)
443 the_hash_algo->final_fn(partial_pack_hash, &old_hash_ctx);
444 the_hash_algo->final_fn(new_pack_hash, &new_hash_ctx);
445 write_or_die(pack_fd, new_pack_hash, the_hash_algo->rawsz);
Neeraj Singh020406e2022-03-10 22:43:21[diff] [blame]446 fsync_component_or_die(FSYNC_COMPONENT_PACK, pack_fd, pack_name);
Dana L. How8b0eca72007-05-02 16:13:14[diff] [blame]447}
Shawn O. Pearce106764e2007-09-14 07:31:16[diff] [blame]448
Jonathan Tan5476e1e2021-02-22 19:20:09[diff] [blame]449char *index_pack_lockfile(int ip_out, int *is_well_formed)
Shawn O. Pearce106764e2007-09-14 07:31:16[diff] [blame]450{
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]451 char packname[GIT_MAX_HEXSZ + 6];
452 const int len = the_hash_algo->hexsz + 6;
Shawn O. Pearce106764e2007-09-14 07:31:16[diff] [blame]453
454 /*
Junio C Hamano6e180cd2009-02-25 07:11:29[diff] [blame]455 * The first thing we expect from index-pack's output
Shawn O. Pearce106764e2007-09-14 07:31:16[diff] [blame]456 * is "pack\t%40s\n" or "keep\t%40s\n" (46 bytes) where
457 * %40s is the newly created pack SHA1 name. In the "keep"
458 * case, we need it to remove the corresponding .keep file
459 * later on. If we don't get that then tough luck with it.
460 */
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]461 if (read_in_full(ip_out, packname, len) == len && packname[len-1] == '\n') {
René Scharfed7731442014-08-30 09:47:19[diff] [blame]462 const char *name;
Jonathan Tan5476e1e2021-02-22 19:20:09[diff] [blame]463
464 if (is_well_formed)
465 *is_well_formed = 1;
brian m. carlson81c58cd2018-02-01 02:18:44[diff] [blame]466 packname[len-1] = 0;
René Scharfed7731442014-08-30 09:47:19[diff] [blame]467 if (skip_prefix(packname, "keep\t", &name))
468 return xstrfmt("%s/pack/pack-%s.keep",
469 get_object_directory(), name);
Jonathan Tan5476e1e2021-02-22 19:20:09[diff] [blame]470 return NULL;
Shawn O. Pearce106764e2007-09-14 07:31:16[diff] [blame]471 }
Jonathan Tan5476e1e2021-02-22 19:20:09[diff] [blame]472 if (is_well_formed)
473 *is_well_formed = 0;
Shawn O. Pearce106764e2007-09-14 07:31:16[diff] [blame]474 return NULL;
475}
Nicolas Pitref965c522010-02-23 20:02:37[diff] [blame]476
477/*
478 * The per-object header is a pretty dense thing, which is
479 * - first byte: low four bits are "size", then three bits of "type",
480 * and the high bit is "size continues".
481 * - each byte afterwards: low seven bits are size continuation,
482 * with the high bit being "size continues"
483 */
Jeff King7202a6f2017-03-24 17:26:40[diff] [blame]484int encode_in_pack_object_header(unsigned char *hdr, int hdr_len,
485 enum object_type type, uintmax_t size)
Nicolas Pitref965c522010-02-23 20:02:37[diff] [blame]486{
487 int n = 1;
488 unsigned char c;
489
490 if (type < OBJ_COMMIT || type > OBJ_REF_DELTA)
491 die("bad type %d", type);
492
493 c = (type << 4) | (size & 15);
494 size >>= 4;
495 while (size) {
Jeff King7202a6f2017-03-24 17:26:40[diff] [blame]496 if (n == hdr_len)
497 die("object size is too enormous to format");
Nicolas Pitref965c522010-02-23 20:02:37[diff] [blame]498 *hdr++ = c | 0x80;
499 c = size & 0x7f;
500 size >>= 7;
501 n++;
502 }
503 *hdr = c;
504 return n;
505}
Junio C Hamanocdf9db32011-10-28 18:52:14[diff] [blame]506
brian m. carlson98a3bea2018-02-01 02:18:46[diff] [blame]507struct hashfile *create_tmp_packfile(char **pack_tmp_name)
Junio C Hamanocdf9db32011-10-28 18:52:14[diff] [blame]508{
Jeff King594fa992017-03-28 19:45:43[diff] [blame]509 struct strbuf tmpname = STRBUF_INIT;
Junio C Hamanocdf9db32011-10-28 18:52:14[diff] [blame]510 int fd;
511
Jeff King594fa992017-03-28 19:45:43[diff] [blame]512 fd = odb_mkstemp(&tmpname, "pack/tmp_pack_XXXXXX");
513 *pack_tmp_name = strbuf_detach(&tmpname, NULL);
brian m. carlson98a3bea2018-02-01 02:18:46[diff] [blame]514 return hashfd(fd, *pack_tmp_name);
Junio C Hamanocdf9db32011-10-28 18:52:14[diff] [blame]515}
Junio C Hamano0e990532011-10-28 19:34:09[diff] [blame]516
Ævar Arnfjörð Bjarmason66833f02021-09-09 23:24:37[diff] [blame]517static void rename_tmp_packfile(struct strbuf *name_prefix, const char *source,
518 const char *ext)
519{
520 size_t name_prefix_len = name_prefix->len;
521
522 strbuf_addstr(name_prefix, ext);
523 if (rename(source, name_prefix->buf))
524 die_errno("unable to rename temporary file to '%s'",
525 name_prefix->buf);
526 strbuf_setlen(name_prefix, name_prefix_len);
527}
528
Ævar Arnfjörð Bjarmason2ec02dd2021-09-09 23:24:56[diff] [blame]529void rename_tmp_packfile_idx(struct strbuf *name_buffer,
530 char **idx_tmp_name)
531{
532 rename_tmp_packfile(name_buffer, *idx_tmp_name, "idx");
533}
534
535void stage_tmp_packfiles(struct strbuf *name_buffer,
Junio C Hamano0e990532011-10-28 19:34:09[diff] [blame]536 const char *pack_tmp_name,
537 struct pack_idx_entry **written_list,
538 uint32_t nr_written,
Taylor Blau1c573cd2022-05-20 23:17:38[diff] [blame]539 struct packing_data *to_pack,
Junio C Hamano0e990532011-10-28 19:34:09[diff] [blame]540 struct pack_idx_option *pack_idx_opts,
Ævar Arnfjörð Bjarmason2ec02dd2021-09-09 23:24:56[diff] [blame]541 unsigned char hash[],
542 char **idx_tmp_name)
Junio C Hamano0e990532011-10-28 19:34:09[diff] [blame]543{
Ævar Arnfjörð Bjarmason2ec02dd2021-09-09 23:24:56[diff] [blame]544 const char *rev_tmp_name = NULL;
Taylor Blau5dfaf492022-05-20 23:17:43[diff] [blame]545 const char *mtimes_tmp_name = NULL;
Junio C Hamano0e990532011-10-28 19:34:09[diff] [blame]546
547 if (adjust_shared_perm(pack_tmp_name))
548 die_errno("unable to make temporary pack file readable");
549
Ævar Arnfjörð Bjarmason2ec02dd2021-09-09 23:24:56[diff] [blame]550 *idx_tmp_name = (char *)write_idx_file(NULL, written_list, nr_written,
551 pack_idx_opts, hash);
552 if (adjust_shared_perm(*idx_tmp_name))
Junio C Hamano0e990532011-10-28 19:34:09[diff] [blame]553 die_errno("unable to make temporary index file readable");
554
Taylor Blau8ef50d92021-01-25 23:37:18[diff] [blame]555 rev_tmp_name = write_rev_file(NULL, written_list, nr_written, hash,
556 pack_idx_opts->flags);
557
Taylor Blau5dfaf492022-05-20 23:17:43[diff] [blame]558 if (pack_idx_opts->flags & WRITE_MTIMES) {
Derrick Stolee82db1952022-06-16 13:13:49[diff] [blame]559 mtimes_tmp_name = write_mtimes_file(to_pack, written_list,
Taylor Blau5dfaf492022-05-20 23:17:43[diff] [blame]560 nr_written,
561 hash);
562 }
563
Ævar Arnfjörð Bjarmason66833f02021-09-09 23:24:37[diff] [blame]564 rename_tmp_packfile(name_buffer, pack_tmp_name, "pack");
Ævar Arnfjörð Bjarmason66833f02021-09-09 23:24:37[diff] [blame]565 if (rev_tmp_name)
566 rename_tmp_packfile(name_buffer, rev_tmp_name, "rev");
Taylor Blau5dfaf492022-05-20 23:17:43[diff] [blame]567 if (mtimes_tmp_name)
568 rename_tmp_packfile(name_buffer, mtimes_tmp_name, "mtimes");
Junio C Hamano0e990532011-10-28 19:34:09[diff] [blame]569}
Christian Couder33add2a2021-01-12 08:21:59[diff] [blame]570
571void write_promisor_file(const char *promisor_name, struct ref **sought, int nr_sought)
572{
Christian Couder7c99bc22021-01-14 15:50:16[diff] [blame]573 int i, err;
Christian Couder33add2a2021-01-12 08:21:59[diff] [blame]574 FILE *output = xfopen(promisor_name, "w");
575
576 for (i = 0; i < nr_sought; i++)
577 fprintf(output, "%s %s\n", oid_to_hex(&sought[i]->old_oid),
578 sought[i]->name);
Christian Couder7c99bc22021-01-14 15:50:16[diff] [blame]579
580 err = ferror(output);
581 err |= fclose(output);
582 if (err)
583 die(_("could not write '%s' promisor file"), promisor_name);
Christian Couder33add2a2021-01-12 08:21:59[diff] [blame]584}