9 #include "fetch-pack.h"
11 #include "run-command.h"
12 #include "transport.h"
14 static int transfer_unpack_limit
= -1;
15 static int fetch_unpack_limit
= -1;
16 static int unpack_limit
= 100;
17 static int prefer_ofs_delta
= 1;
18 static struct fetch_pack_args args
= {
19 /* .uploadpack = */ "git-upload-pack",
22 static const char fetch_pack_usage
[] =
23 "git fetch-pack [--all] [--quiet|-q] [--keep|-k] [--thin] [--include-tag] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>...]";
25 #define COMPLETE (1U << 0)
26 #define COMMON (1U << 1)
27 #define COMMON_REF (1U << 2)
28 #define SEEN (1U << 3)
29 #define POPPED (1U << 4)
34 * After sending this many "have"s if we do not get any new ACK , we
35 * give up traversing our history.
37 #define MAX_IN_VAIN 256
39 static struct commit_list
*rev_list
;
40 static int non_common_revs
, multi_ack
, use_sideband
;
42 static void rev_list_push(struct commit
*commit
, int mark
)
44 if (!(commit
->object
.flags
& mark
)) {
45 commit
->object
.flags
|= mark
;
47 if (!(commit
->object
.parsed
))
48 if (parse_commit(commit
))
51 commit_list_insert_by_date(commit
, &rev_list
);
53 if (!(commit
->object
.flags
& COMMON
))
58 static int rev_list_insert_ref(const char *path
, const unsigned char *sha1
, int flag
, void *cb_data
)
60 struct object
*o
= deref_tag(parse_object(sha1
), path
, 0);
62 if (o
&& o
->type
== OBJ_COMMIT
)
63 rev_list_push((struct commit
*)o
, SEEN
);
68 static int clear_marks(const char *path
, const unsigned char *sha1
, int flag
, void *cb_data
)
70 struct object
*o
= deref_tag(parse_object(sha1
), path
, 0);
72 if (o
&& o
->type
== OBJ_COMMIT
)
73 clear_commit_marks((struct commit
*)o
,
74 COMMON
| COMMON_REF
| SEEN
| POPPED
);
79 This function marks a rev and its ancestors as common.
80 In some cases, it is desirable to mark only the ancestors (for example
81 when only the server does not yet know that they are common).
84 static void mark_common(struct commit
*commit
,
85 int ancestors_only
, int dont_parse
)
87 if (commit
!= NULL
&& !(commit
->object
.flags
& COMMON
)) {
88 struct object
*o
= (struct object
*)commit
;
93 if (!(o
->flags
& SEEN
))
94 rev_list_push(commit
, SEEN
);
96 struct commit_list
*parents
;
98 if (!ancestors_only
&& !(o
->flags
& POPPED
))
100 if (!o
->parsed
&& !dont_parse
)
101 if (parse_commit(commit
))
104 for (parents
= commit
->parents
;
106 parents
= parents
->next
)
107 mark_common(parents
->item
, 0, dont_parse
);
113 Get the next rev to send, ignoring the common.
116 static const unsigned char *get_rev(void)
118 struct commit
*commit
= NULL
;
120 while (commit
== NULL
) {
122 struct commit_list
*parents
;
124 if (rev_list
== NULL
|| non_common_revs
== 0)
127 commit
= rev_list
->item
;
128 if (!commit
->object
.parsed
)
129 parse_commit(commit
);
130 parents
= commit
->parents
;
132 commit
->object
.flags
|= POPPED
;
133 if (!(commit
->object
.flags
& COMMON
))
136 if (commit
->object
.flags
& COMMON
) {
137 /* do not send "have", and ignore ancestors */
139 mark
= COMMON
| SEEN
;
140 } else if (commit
->object
.flags
& COMMON_REF
)
141 /* send "have", and ignore ancestors */
142 mark
= COMMON
| SEEN
;
144 /* send "have", also for its ancestors */
148 if (!(parents
->item
->object
.flags
& SEEN
))
149 rev_list_push(parents
->item
, mark
);
151 mark_common(parents
->item
, 1, 0);
152 parents
= parents
->next
;
155 rev_list
= rev_list
->next
;
158 return commit
->object
.sha1
;
169 static void consume_shallow_list(int fd
)
171 if (args
.stateless_rpc
&& args
.depth
> 0) {
172 /* If we sent a depth we will get back "duplicate"
173 * shallow and unshallow commands every time there
174 * is a block of have lines exchanged.
177 while (packet_read_line(fd
, line
, sizeof(line
))) {
178 if (!prefixcmp(line
, "shallow "))
180 if (!prefixcmp(line
, "unshallow "))
182 die("git fetch-pack: expected shallow list");
187 static enum ack_type
get_ack(int fd
, unsigned char *result_sha1
)
189 static char line
[1000];
190 int len
= packet_read_line(fd
, line
, sizeof(line
));
193 die("git fetch-pack: expected ACK/NAK, got EOF");
194 if (line
[len
-1] == '\n')
196 if (!strcmp(line
, "NAK"))
198 if (!prefixcmp(line
, "ACK ")) {
199 if (!get_sha1_hex(line
+4, result_sha1
)) {
200 if (strstr(line
+45, "continue"))
202 if (strstr(line
+45, "common"))
204 if (strstr(line
+45, "ready"))
209 die("git fetch_pack: expected ACK/NAK, got '%s'", line
);
212 static void send_request(int fd
, struct strbuf
*buf
)
214 if (args
.stateless_rpc
) {
215 send_sideband(fd
, -1, buf
->buf
, buf
->len
, LARGE_PACKET_MAX
);
218 safe_write(fd
, buf
->buf
, buf
->len
);
221 static void insert_one_alternate_ref(const struct ref
*ref
, void *unused
)
223 rev_list_insert_ref(NULL
, ref
->old_sha1
, 0, NULL
);
226 static void insert_alternate_refs(void)
228 foreach_alt_odb(refs_from_alternate_cb
, insert_one_alternate_ref
);
231 #define INITIAL_FLUSH 16
232 #define LARGE_FLUSH 1024
234 static int next_flush(int count
)
236 if (count
< INITIAL_FLUSH
* 2)
237 count
+= INITIAL_FLUSH
;
238 else if (count
< LARGE_FLUSH
)
241 count
+= LARGE_FLUSH
;
245 static int find_common(int fd
[2], unsigned char *result_sha1
,
249 int count
= 0, flushes
= 0, flush_at
= INITIAL_FLUSH
, retval
;
250 const unsigned char *sha1
;
251 unsigned in_vain
= 0;
252 int got_continue
= 0;
253 struct strbuf req_buf
= STRBUF_INIT
;
254 size_t state_len
= 0;
256 if (args
.stateless_rpc
&& multi_ack
== 1)
257 die("--stateless-rpc requires multi_ack_detailed");
259 for_each_ref(clear_marks
, NULL
);
262 for_each_ref(rev_list_insert_ref
, NULL
);
263 insert_alternate_refs();
266 for ( ; refs
; refs
= refs
->next
) {
267 unsigned char *remote
= refs
->old_sha1
;
268 const char *remote_hex
;
272 * If that object is complete (i.e. it is an ancestor of a
273 * local ref), we tell them we have it but do not have to
274 * tell them about its ancestors, which they already know
277 * We use lookup_object here because we are only
278 * interested in the case we *know* the object is
279 * reachable and we have already scanned it.
281 if (((o
= lookup_object(remote
)) != NULL
) &&
282 (o
->flags
& COMPLETE
)) {
286 remote_hex
= sha1_to_hex(remote
);
288 struct strbuf c
= STRBUF_INIT
;
289 if (multi_ack
== 2) strbuf_addstr(&c
, " multi_ack_detailed");
290 if (multi_ack
== 1) strbuf_addstr(&c
, " multi_ack");
291 if (use_sideband
== 2) strbuf_addstr(&c
, " side-band-64k");
292 if (use_sideband
== 1) strbuf_addstr(&c
, " side-band");
293 if (args
.use_thin_pack
) strbuf_addstr(&c
, " thin-pack");
294 if (args
.no_progress
) strbuf_addstr(&c
, " no-progress");
295 if (args
.include_tag
) strbuf_addstr(&c
, " include-tag");
296 if (prefer_ofs_delta
) strbuf_addstr(&c
, " ofs-delta");
297 packet_buf_write(&req_buf
, "want %s%s\n", remote_hex
, c
.buf
);
300 packet_buf_write(&req_buf
, "want %s\n", remote_hex
);
305 strbuf_release(&req_buf
);
310 if (is_repository_shallow())
311 write_shallow_commits(&req_buf
, 1);
313 packet_buf_write(&req_buf
, "deepen %d", args
.depth
);
314 packet_buf_flush(&req_buf
);
315 state_len
= req_buf
.len
;
317 if (args
.depth
> 0) {
319 unsigned char sha1
[20];
321 send_request(fd
[1], &req_buf
);
322 while (packet_read_line(fd
[0], line
, sizeof(line
))) {
323 if (!prefixcmp(line
, "shallow ")) {
324 if (get_sha1_hex(line
+ 8, sha1
))
325 die("invalid shallow line: %s", line
);
326 register_shallow(sha1
);
329 if (!prefixcmp(line
, "unshallow ")) {
330 if (get_sha1_hex(line
+ 10, sha1
))
331 die("invalid unshallow line: %s", line
);
332 if (!lookup_object(sha1
))
333 die("object not found: %s", line
);
334 /* make sure that it is parsed as shallow */
335 if (!parse_object(sha1
))
336 die("error in object: %s", line
);
337 if (unregister_shallow(sha1
))
338 die("no shallow found: %s", line
);
341 die("expected shallow/unshallow, got %s", line
);
343 } else if (!args
.stateless_rpc
)
344 send_request(fd
[1], &req_buf
);
346 if (!args
.stateless_rpc
) {
347 /* If we aren't using the stateless-rpc interface
348 * we don't need to retain the headers.
350 strbuf_setlen(&req_buf
, 0);
356 while ((sha1
= get_rev())) {
357 packet_buf_write(&req_buf
, "have %s\n", sha1_to_hex(sha1
));
359 fprintf(stderr
, "have %s\n", sha1_to_hex(sha1
));
361 if (flush_at
<= ++count
) {
364 packet_buf_flush(&req_buf
);
365 send_request(fd
[1], &req_buf
);
366 strbuf_setlen(&req_buf
, state_len
);
368 flush_at
= next_flush(count
);
371 * We keep one window "ahead" of the other side, and
372 * will wait for an ACK only on the next one
374 if (!args
.stateless_rpc
&& count
== INITIAL_FLUSH
)
377 consume_shallow_list(fd
[0]);
379 ack
= get_ack(fd
[0], result_sha1
);
380 if (args
.verbose
&& ack
)
381 fprintf(stderr
, "got ack %d %s\n", ack
,
382 sha1_to_hex(result_sha1
));
392 struct commit
*commit
=
393 lookup_commit(result_sha1
);
394 if (args
.stateless_rpc
396 && !(commit
->object
.flags
& COMMON
)) {
397 /* We need to replay the have for this object
398 * on the next RPC request so the peer knows
399 * it is in common with us.
401 const char *hex
= sha1_to_hex(result_sha1
);
402 packet_buf_write(&req_buf
, "have %s\n", hex
);
403 state_len
= req_buf
.len
;
405 mark_common(commit
, 0, 1);
409 if (ack
== ACK_ready
)
416 if (got_continue
&& MAX_IN_VAIN
< in_vain
) {
418 fprintf(stderr
, "giving up\n");
424 packet_buf_write(&req_buf
, "done\n");
425 send_request(fd
[1], &req_buf
);
427 fprintf(stderr
, "done\n");
432 strbuf_release(&req_buf
);
434 consume_shallow_list(fd
[0]);
435 while (flushes
|| multi_ack
) {
436 int ack
= get_ack(fd
[0], result_sha1
);
439 fprintf(stderr
, "got ack (%d) %s\n", ack
,
440 sha1_to_hex(result_sha1
));
448 /* it is no error to fetch into a completely empty repo */
449 return count
? retval
: 0;
452 static struct commit_list
*complete
;
454 static int mark_complete(const char *path
, const unsigned char *sha1
, int flag
, void *cb_data
)
456 struct object
*o
= parse_object(sha1
);
458 while (o
&& o
->type
== OBJ_TAG
) {
459 struct tag
*t
= (struct tag
*) o
;
461 break; /* broken repository */
462 o
->flags
|= COMPLETE
;
463 o
= parse_object(t
->tagged
->sha1
);
465 if (o
&& o
->type
== OBJ_COMMIT
) {
466 struct commit
*commit
= (struct commit
*)o
;
467 commit
->object
.flags
|= COMPLETE
;
468 commit_list_insert_by_date(commit
, &complete
);
473 static void mark_recent_complete_commits(unsigned long cutoff
)
475 while (complete
&& cutoff
<= complete
->item
->date
) {
477 fprintf(stderr
, "Marking %s as complete\n",
478 sha1_to_hex(complete
->item
->object
.sha1
));
479 pop_most_recent_commit(&complete
, COMPLETE
);
483 static void filter_refs(struct ref
**refs
, int nr_match
, char **match
)
485 struct ref
**return_refs
;
486 struct ref
*newlist
= NULL
;
487 struct ref
**newtail
= &newlist
;
488 struct ref
*ref
, *next
;
489 struct ref
*fastarray
[32];
491 if (nr_match
&& !args
.fetch_all
) {
492 if (ARRAY_SIZE(fastarray
) < nr_match
)
493 return_refs
= xcalloc(nr_match
, sizeof(struct ref
*));
495 return_refs
= fastarray
;
496 memset(return_refs
, 0, sizeof(struct ref
*) * nr_match
);
502 for (ref
= *refs
; ref
; ref
= next
) {
504 if (!memcmp(ref
->name
, "refs/", 5) &&
505 check_ref_format(ref
->name
+ 5))
507 else if (args
.fetch_all
&&
508 (!args
.depth
|| prefixcmp(ref
->name
, "refs/tags/") )) {
511 newtail
= &ref
->next
;
515 int order
= path_match(ref
->name
, nr_match
, match
);
517 return_refs
[order
-1] = ref
;
518 continue; /* we will link it later */
524 if (!args
.fetch_all
) {
526 for (i
= 0; i
< nr_match
; i
++) {
527 ref
= return_refs
[i
];
531 newtail
= &ref
->next
;
534 if (return_refs
!= fastarray
)
540 static int everything_local(struct ref
**refs
, int nr_match
, char **match
)
544 unsigned long cutoff
= 0;
546 save_commit_buffer
= 0;
548 for (ref
= *refs
; ref
; ref
= ref
->next
) {
551 o
= parse_object(ref
->old_sha1
);
555 /* We already have it -- which may mean that we were
556 * in sync with the other side at some time after
557 * that (it is OK if we guess wrong here).
559 if (o
->type
== OBJ_COMMIT
) {
560 struct commit
*commit
= (struct commit
*)o
;
561 if (!cutoff
|| cutoff
< commit
->date
)
562 cutoff
= commit
->date
;
567 for_each_ref(mark_complete
, NULL
);
569 mark_recent_complete_commits(cutoff
);
573 * Mark all complete remote refs as common refs.
574 * Don't mark them common yet; the server has to be told so first.
576 for (ref
= *refs
; ref
; ref
= ref
->next
) {
577 struct object
*o
= deref_tag(lookup_object(ref
->old_sha1
),
580 if (!o
|| o
->type
!= OBJ_COMMIT
|| !(o
->flags
& COMPLETE
))
583 if (!(o
->flags
& SEEN
)) {
584 rev_list_push((struct commit
*)o
, COMMON_REF
| SEEN
);
586 mark_common((struct commit
*)o
, 1, 1);
590 filter_refs(refs
, nr_match
, match
);
592 for (retval
= 1, ref
= *refs
; ref
; ref
= ref
->next
) {
593 const unsigned char *remote
= ref
->old_sha1
;
594 unsigned char local
[20];
597 o
= lookup_object(remote
);
598 if (!o
|| !(o
->flags
& COMPLETE
)) {
603 "want %s (%s)\n", sha1_to_hex(remote
),
608 hashcpy(ref
->new_sha1
, local
);
612 "already have %s (%s)\n", sha1_to_hex(remote
),
618 static int sideband_demux(int in
, int out
, void *data
)
622 int ret
= recv_sideband("fetch-pack", xd
[0], out
);
627 static int get_pack(int xd
[2], char **pack_lockfile
)
630 const char *argv
[20];
634 int do_keep
= args
.keep_pack
;
635 struct child_process cmd
;
637 memset(&demux
, 0, sizeof(demux
));
639 /* xd[] is talking with upload-pack; subprocess reads from
640 * xd[0], spits out band#2 to stderr, and feeds us band#1
641 * through demux->out.
643 demux
.proc
= sideband_demux
;
646 if (start_async(&demux
))
647 die("fetch-pack: unable to fork off sideband"
653 memset(&cmd
, 0, sizeof(cmd
));
657 if (!args
.keep_pack
&& unpack_limit
) {
658 struct pack_header header
;
660 if (read_pack_header(demux
.out
, &header
))
661 die("protocol error: bad pack header");
662 snprintf(hdr_arg
, sizeof(hdr_arg
),
663 "--pack_header=%"PRIu32
",%"PRIu32
,
664 ntohl(header
.hdr_version
), ntohl(header
.hdr_entries
));
665 if (ntohl(header
.hdr_entries
) < unpack_limit
)
674 *av
++ = "index-pack";
676 if (!args
.quiet
&& !args
.no_progress
)
678 if (args
.use_thin_pack
)
679 *av
++ = "--fix-thin";
680 if (args
.lock_pack
|| unpack_limit
) {
681 int s
= sprintf(keep_arg
,
682 "--keep=fetch-pack %"PRIuMAX
" on ", (uintmax_t) getpid());
683 if (gethostname(keep_arg
+ s
, sizeof(keep_arg
) - s
))
684 strcpy(keep_arg
+ s
, "localhost");
689 *av
++ = "unpack-objects";
699 if (start_command(&cmd
))
700 die("fetch-pack: unable to fork off %s", argv
[0]);
701 if (do_keep
&& pack_lockfile
) {
702 *pack_lockfile
= index_pack_lockfile(cmd
.out
);
706 if (finish_command(&cmd
))
707 die("%s failed", argv
[0]);
708 if (use_sideband
&& finish_async(&demux
))
709 die("error in sideband demultiplexer");
713 static struct ref
*do_fetch_pack(int fd
[2],
714 const struct ref
*orig_ref
,
717 char **pack_lockfile
)
719 struct ref
*ref
= copy_ref_list(orig_ref
);
720 unsigned char sha1
[20];
722 if (is_repository_shallow() && !server_supports("shallow"))
723 die("Server does not support shallow clients");
724 if (server_supports("multi_ack_detailed")) {
726 fprintf(stderr
, "Server supports multi_ack_detailed\n");
729 else if (server_supports("multi_ack")) {
731 fprintf(stderr
, "Server supports multi_ack\n");
734 if (server_supports("side-band-64k")) {
736 fprintf(stderr
, "Server supports side-band-64k\n");
739 else if (server_supports("side-band")) {
741 fprintf(stderr
, "Server supports side-band\n");
744 if (server_supports("ofs-delta")) {
746 fprintf(stderr
, "Server supports ofs-delta\n");
748 prefer_ofs_delta
= 0;
749 if (everything_local(&ref
, nr_match
, match
)) {
753 if (find_common(fd
, sha1
, ref
) < 0)
755 /* When cloning, it is not unusual to have
758 warning("no common commits");
760 if (args
.stateless_rpc
)
762 if (get_pack(fd
, pack_lockfile
))
763 die("git fetch-pack: fetch failed.");
769 static int remove_duplicates(int nr_heads
, char **heads
)
773 for (src
= dst
= 0; src
< nr_heads
; src
++) {
774 /* If heads[src] is different from any of
775 * heads[0..dst], push it in.
778 for (i
= 0; i
< dst
; i
++) {
779 if (!strcmp(heads
[i
], heads
[src
]))
785 heads
[dst
] = heads
[src
];
791 static int fetch_pack_config(const char *var
, const char *value
, void *cb
)
793 if (strcmp(var
, "fetch.unpacklimit") == 0) {
794 fetch_unpack_limit
= git_config_int(var
, value
);
798 if (strcmp(var
, "transfer.unpacklimit") == 0) {
799 transfer_unpack_limit
= git_config_int(var
, value
);
803 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
804 prefer_ofs_delta
= git_config_bool(var
, value
);
808 return git_default_config(var
, value
, cb
);
811 static struct lock_file lock
;
813 static void fetch_pack_setup(void)
815 static int did_setup
;
818 git_config(fetch_pack_config
, NULL
);
819 if (0 <= transfer_unpack_limit
)
820 unpack_limit
= transfer_unpack_limit
;
821 else if (0 <= fetch_unpack_limit
)
822 unpack_limit
= fetch_unpack_limit
;
826 int cmd_fetch_pack(int argc
, const char **argv
, const char *prefix
)
828 int i
, ret
, nr_heads
;
829 struct ref
*ref
= NULL
;
830 char *dest
= NULL
, **heads
;
832 char *pack_lockfile
= NULL
;
833 char **pack_lockfile_ptr
= NULL
;
834 struct child_process
*conn
;
836 packet_trace_identity("fetch-pack");
840 for (i
= 1; i
< argc
; i
++) {
841 const char *arg
= argv
[i
];
844 if (!prefixcmp(arg
, "--upload-pack=")) {
845 args
.uploadpack
= arg
+ 14;
848 if (!prefixcmp(arg
, "--exec=")) {
849 args
.uploadpack
= arg
+ 7;
852 if (!strcmp("--quiet", arg
) || !strcmp("-q", arg
)) {
856 if (!strcmp("--keep", arg
) || !strcmp("-k", arg
)) {
857 args
.lock_pack
= args
.keep_pack
;
861 if (!strcmp("--thin", arg
)) {
862 args
.use_thin_pack
= 1;
865 if (!strcmp("--include-tag", arg
)) {
866 args
.include_tag
= 1;
869 if (!strcmp("--all", arg
)) {
873 if (!strcmp("-v", arg
)) {
877 if (!prefixcmp(arg
, "--depth=")) {
878 args
.depth
= strtol(arg
+ 8, NULL
, 0);
881 if (!strcmp("--no-progress", arg
)) {
882 args
.no_progress
= 1;
885 if (!strcmp("--stateless-rpc", arg
)) {
886 args
.stateless_rpc
= 1;
889 if (!strcmp("--lock-pack", arg
)) {
891 pack_lockfile_ptr
= &pack_lockfile
;
894 usage(fetch_pack_usage
);
897 heads
= (char **)(argv
+ i
+ 1);
898 nr_heads
= argc
- i
- 1;
902 usage(fetch_pack_usage
);
904 if (args
.stateless_rpc
) {
909 conn
= git_connect(fd
, (char *)dest
, args
.uploadpack
,
910 args
.verbose
? CONNECT_VERBOSE
: 0);
913 get_remote_heads(fd
[0], &ref
, 0, NULL
, 0, NULL
);
915 ref
= fetch_pack(&args
, fd
, conn
, ref
, dest
,
916 nr_heads
, heads
, pack_lockfile_ptr
);
918 printf("lock %s\n", pack_lockfile
);
923 if (finish_connect(conn
))
927 if (!ret
&& nr_heads
) {
928 /* If the heads to pull were given, we should have
929 * consumed all of them by matching the remote.
930 * Otherwise, 'git fetch remote no-such-ref' would
931 * silently succeed without issuing an error.
933 for (i
= 0; i
< nr_heads
; i
++)
934 if (heads
[i
] && heads
[i
][0]) {
935 error("no such remote ref %s", heads
[i
]);
941 sha1_to_hex(ref
->old_sha1
), ref
->name
);
948 struct ref
*fetch_pack(struct fetch_pack_args
*my_args
,
949 int fd
[], struct child_process
*conn
,
950 const struct ref
*ref
,
954 char **pack_lockfile
)
960 if (&args
!= my_args
)
961 memcpy(&args
, my_args
, sizeof(args
));
962 if (args
.depth
> 0) {
963 if (stat(git_path("shallow"), &st
))
967 if (heads
&& nr_heads
)
968 nr_heads
= remove_duplicates(nr_heads
, heads
);
971 die("no matching remote head");
973 ref_cpy
= do_fetch_pack(fd
, ref
, nr_heads
, heads
, pack_lockfile
);
975 if (args
.depth
> 0) {
976 struct cache_time mtime
;
977 struct strbuf sb
= STRBUF_INIT
;
978 char *shallow
= git_path("shallow");
981 mtime
.sec
= st
.st_mtime
;
982 mtime
.nsec
= ST_MTIME_NSEC(st
);
983 if (stat(shallow
, &st
)) {
985 die("shallow file was removed during fetch");
986 } else if (st
.st_mtime
!= mtime
.sec
988 || ST_MTIME_NSEC(st
) != mtime
.nsec
991 die("shallow file was changed during fetch");
993 fd
= hold_lock_file_for_update(&lock
, shallow
,
995 if (!write_shallow_commits(&sb
, 0)
996 || write_in_full(fd
, sb
.buf
, sb
.len
) != sb
.len
) {
997 unlink_or_warn(shallow
);
998 rollback_lock_file(&lock
);
1000 commit_lock_file(&lock
);
1002 strbuf_release(&sb
);
1005 reprepare_packed_git();