2012-10-26 17:53:55 +02:00
|
|
|
#include "cache.h"
|
2014-10-01 12:28:42 +02:00
|
|
|
#include "lockfile.h"
|
2012-10-26 17:53:55 +02:00
|
|
|
#include "refs.h"
|
|
|
|
|
#include "pkt-line.h"
|
|
|
|
|
#include "commit.h"
|
|
|
|
|
#include "tag.h"
|
|
|
|
|
#include "exec_cmd.h"
|
|
|
|
|
#include "pack.h"
|
|
|
|
|
#include "sideband.h"
|
|
|
|
|
#include "fetch-pack.h"
|
|
|
|
|
#include "remote.h"
|
|
|
|
|
#include "run-command.h"
|
2013-07-08 22:56:53 +02:00
|
|
|
#include "connect.h"
|
2012-10-26 17:53:55 +02:00
|
|
|
#include "transport.h"
|
|
|
|
|
#include "version.h"
|
fetch-pack: avoid quadratic behavior in rev_list_push
When we call find_common to start finding common ancestors
with the remote side of a fetch, the first thing we do is
insert the tip of each ref into our rev_list linked list. We
keep the list sorted the whole time with
commit_list_insert_by_date, which means our insertion ends
up doing O(n^2) timestamp comparisons.
We could teach rev_list_push to use an unsorted list, and
then sort it once after we have added each ref. However, in
get_rev, we process the list by popping commits off the
front and adding parents back in timestamp-sorted order. So
that procedure would still operate on the large list.
Instead, we can replace the linked list with a heap-based
priority queue, which can do O(log n) insertion, making the
whole insertion procedure O(n log n).
As a result of switching to the prio_queue struct, we fix
two minor bugs:
1. When we "pop" a commit in get_rev, and when we clear
the rev_list in find_common, we do not take care to
free the "struct commit_list", and just leak its
memory. With the prio_queue implementation, the memory
management is handled for us.
2. In get_rev, we look at the head commit of the list,
possibly push its parents onto the list, and then "pop"
the front of the list off, assuming it is the same
element that we just peeked at. This is typically going
to be the case, but would not be in the face of clock
skew: the parents are inserted by date, and could
potentially be inserted at the head of the list if they
have a timestamp newer than their descendent. In this
case, we would accidentally pop the parent, and never
process it at all.
The new implementation pulls the commit off of the
queue as we examine it, and so does not suffer from
this problem.
With this patch, a fetch of a single commit into a
repository with 50,000 refs went from:
real 0m7.984s
user 0m7.852s
sys 0m0.120s
to:
real 0m2.017s
user 0m1.884s
sys 0m0.124s
Before this patch, a larger case with 370K refs still had
not completed after tens of minutes; with this patch, it
completes in about 12 seconds.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-02 08:24:21 +02:00
|
|
|
#include "prio-queue.h"
|
2013-12-05 14:02:39 +01:00
|
|
|
#include "sha1-array.h"
|
2012-10-26 17:53:55 +02:00
|
|
|
|
|
|
|
|
static int transfer_unpack_limit = -1;
|
|
|
|
|
static int fetch_unpack_limit = -1;
|
|
|
|
|
static int unpack_limit = 100;
|
|
|
|
|
static int prefer_ofs_delta = 1;
|
|
|
|
|
static int no_done;
|
|
|
|
|
static int fetch_fsck_objects = -1;
|
|
|
|
|
static int transfer_fsck_objects = -1;
|
|
|
|
|
static int agent_supported;
|
2013-05-26 03:16:15 +02:00
|
|
|
static struct lock_file shallow_lock;
|
|
|
|
|
static const char *alternate_shallow_file;
|
2012-10-26 17:53:55 +02:00
|
|
|
|
2014-03-25 14:23:26 +01:00
|
|
|
/* Remember to update object flag allocation in object.h */
|
2012-10-26 17:53:55 +02:00
|
|
|
#define COMPLETE (1U << 0)
|
|
|
|
|
#define COMMON (1U << 1)
|
|
|
|
|
#define COMMON_REF (1U << 2)
|
|
|
|
|
#define SEEN (1U << 3)
|
|
|
|
|
#define POPPED (1U << 4)
|
|
|
|
|
|
|
|
|
|
static int marked;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* After sending this many "have"s if we do not get any new ACK , we
|
|
|
|
|
* give up traversing our history.
|
|
|
|
|
*/
|
|
|
|
|
#define MAX_IN_VAIN 256
|
|
|
|
|
|
fetch-pack: avoid quadratic behavior in rev_list_push
When we call find_common to start finding common ancestors
with the remote side of a fetch, the first thing we do is
insert the tip of each ref into our rev_list linked list. We
keep the list sorted the whole time with
commit_list_insert_by_date, which means our insertion ends
up doing O(n^2) timestamp comparisons.
We could teach rev_list_push to use an unsorted list, and
then sort it once after we have added each ref. However, in
get_rev, we process the list by popping commits off the
front and adding parents back in timestamp-sorted order. So
that procedure would still operate on the large list.
Instead, we can replace the linked list with a heap-based
priority queue, which can do O(log n) insertion, making the
whole insertion procedure O(n log n).
As a result of switching to the prio_queue struct, we fix
two minor bugs:
1. When we "pop" a commit in get_rev, and when we clear
the rev_list in find_common, we do not take care to
free the "struct commit_list", and just leak its
memory. With the prio_queue implementation, the memory
management is handled for us.
2. In get_rev, we look at the head commit of the list,
possibly push its parents onto the list, and then "pop"
the front of the list off, assuming it is the same
element that we just peeked at. This is typically going
to be the case, but would not be in the face of clock
skew: the parents are inserted by date, and could
potentially be inserted at the head of the list if they
have a timestamp newer than their descendent. In this
case, we would accidentally pop the parent, and never
process it at all.
The new implementation pulls the commit off of the
queue as we examine it, and so does not suffer from
this problem.
With this patch, a fetch of a single commit into a
repository with 50,000 refs went from:
real 0m7.984s
user 0m7.852s
sys 0m0.120s
to:
real 0m2.017s
user 0m1.884s
sys 0m0.124s
Before this patch, a larger case with 370K refs still had
not completed after tens of minutes; with this patch, it
completes in about 12 seconds.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-02 08:24:21 +02:00
|
|
|
static struct prio_queue rev_list = { compare_commits_by_commit_date };
|
2015-05-21 22:23:38 +02:00
|
|
|
static int non_common_revs, multi_ack, use_sideband;
|
|
|
|
|
/* Allow specifying sha1 if it is a ref tip. */
|
|
|
|
|
#define ALLOW_TIP_SHA1 01
|
2015-05-21 22:23:39 +02:00
|
|
|
/* Allow request of a sha1 if it is reachable from a ref (possibly hidden ref). */
|
|
|
|
|
#define ALLOW_REACHABLE_SHA1 02
|
2015-05-21 22:23:38 +02:00
|
|
|
static unsigned int allow_unadvertised_object_request;
|
2012-10-26 17:53:55 +02:00
|
|
|
|
|
|
|
|
static void rev_list_push(struct commit *commit, int mark)
|
|
|
|
|
{
|
|
|
|
|
if (!(commit->object.flags & mark)) {
|
|
|
|
|
commit->object.flags |= mark;
|
|
|
|
|
|
2013-10-24 10:53:01 +02:00
|
|
|
if (parse_commit(commit))
|
|
|
|
|
return;
|
2012-10-26 17:53:55 +02:00
|
|
|
|
fetch-pack: avoid quadratic behavior in rev_list_push
When we call find_common to start finding common ancestors
with the remote side of a fetch, the first thing we do is
insert the tip of each ref into our rev_list linked list. We
keep the list sorted the whole time with
commit_list_insert_by_date, which means our insertion ends
up doing O(n^2) timestamp comparisons.
We could teach rev_list_push to use an unsorted list, and
then sort it once after we have added each ref. However, in
get_rev, we process the list by popping commits off the
front and adding parents back in timestamp-sorted order. So
that procedure would still operate on the large list.
Instead, we can replace the linked list with a heap-based
priority queue, which can do O(log n) insertion, making the
whole insertion procedure O(n log n).
As a result of switching to the prio_queue struct, we fix
two minor bugs:
1. When we "pop" a commit in get_rev, and when we clear
the rev_list in find_common, we do not take care to
free the "struct commit_list", and just leak its
memory. With the prio_queue implementation, the memory
management is handled for us.
2. In get_rev, we look at the head commit of the list,
possibly push its parents onto the list, and then "pop"
the front of the list off, assuming it is the same
element that we just peeked at. This is typically going
to be the case, but would not be in the face of clock
skew: the parents are inserted by date, and could
potentially be inserted at the head of the list if they
have a timestamp newer than their descendent. In this
case, we would accidentally pop the parent, and never
process it at all.
The new implementation pulls the commit off of the
queue as we examine it, and so does not suffer from
this problem.
With this patch, a fetch of a single commit into a
repository with 50,000 refs went from:
real 0m7.984s
user 0m7.852s
sys 0m0.120s
to:
real 0m2.017s
user 0m1.884s
sys 0m0.124s
Before this patch, a larger case with 370K refs still had
not completed after tens of minutes; with this patch, it
completes in about 12 seconds.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-02 08:24:21 +02:00
|
|
|
prio_queue_put(&rev_list, commit);
|
2012-10-26 17:53:55 +02:00
|
|
|
|
|
|
|
|
if (!(commit->object.flags & COMMON))
|
|
|
|
|
non_common_revs++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-25 20:39:19 +02:00
|
|
|
static int rev_list_insert_ref(const char *refname, const unsigned char *sha1)
|
2012-10-26 17:53:55 +02:00
|
|
|
{
|
|
|
|
|
struct object *o = deref_tag(parse_object(sha1), refname, 0);
|
|
|
|
|
|
|
|
|
|
if (o && o->type == OBJ_COMMIT)
|
|
|
|
|
rev_list_push((struct commit *)o, SEEN);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-25 20:39:18 +02:00
|
|
|
static int rev_list_insert_ref_oid(const char *refname, const struct object_id *oid,
|
|
|
|
|
int flag, void *cb_data)
|
2012-10-26 17:53:55 +02:00
|
|
|
{
|
2015-05-25 20:39:19 +02:00
|
|
|
return rev_list_insert_ref(refname, oid->hash);
|
2015-05-25 20:39:18 +02:00
|
|
|
}
|
|
|
|
|
|
2015-05-25 20:39:15 +02:00
|
|
|
static int clear_marks(const char *refname, const struct object_id *oid,
|
|
|
|
|
int flag, void *cb_data)
|
2012-10-26 17:53:55 +02:00
|
|
|
{
|
2015-05-25 20:39:15 +02:00
|
|
|
struct object *o = deref_tag(parse_object(oid->hash), refname, 0);
|
2012-10-26 17:53:55 +02:00
|
|
|
|
|
|
|
|
if (o && o->type == OBJ_COMMIT)
|
|
|
|
|
clear_commit_marks((struct commit *)o,
|
|
|
|
|
COMMON | COMMON_REF | SEEN | POPPED);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
This function marks a rev and its ancestors as common.
|
|
|
|
|
In some cases, it is desirable to mark only the ancestors (for example
|
|
|
|
|
when only the server does not yet know that they are common).
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static void mark_common(struct commit *commit,
|
|
|
|
|
int ancestors_only, int dont_parse)
|
|
|
|
|
{
|
|
|
|
|
if (commit != NULL && !(commit->object.flags & COMMON)) {
|
|
|
|
|
struct object *o = (struct object *)commit;
|
|
|
|
|
|
|
|
|
|
if (!ancestors_only)
|
|
|
|
|
o->flags |= COMMON;
|
|
|
|
|
|
|
|
|
|
if (!(o->flags & SEEN))
|
|
|
|
|
rev_list_push(commit, SEEN);
|
|
|
|
|
else {
|
|
|
|
|
struct commit_list *parents;
|
|
|
|
|
|
|
|
|
|
if (!ancestors_only && !(o->flags & POPPED))
|
|
|
|
|
non_common_revs--;
|
|
|
|
|
if (!o->parsed && !dont_parse)
|
|
|
|
|
if (parse_commit(commit))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
for (parents = commit->parents;
|
|
|
|
|
parents;
|
|
|
|
|
parents = parents->next)
|
|
|
|
|
mark_common(parents->item, 0, dont_parse);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Get the next rev to send, ignoring the common.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static const unsigned char *get_rev(void)
|
|
|
|
|
{
|
|
|
|
|
struct commit *commit = NULL;
|
|
|
|
|
|
|
|
|
|
while (commit == NULL) {
|
|
|
|
|
unsigned int mark;
|
|
|
|
|
struct commit_list *parents;
|
|
|
|
|
|
fetch-pack: avoid quadratic behavior in rev_list_push
When we call find_common to start finding common ancestors
with the remote side of a fetch, the first thing we do is
insert the tip of each ref into our rev_list linked list. We
keep the list sorted the whole time with
commit_list_insert_by_date, which means our insertion ends
up doing O(n^2) timestamp comparisons.
We could teach rev_list_push to use an unsorted list, and
then sort it once after we have added each ref. However, in
get_rev, we process the list by popping commits off the
front and adding parents back in timestamp-sorted order. So
that procedure would still operate on the large list.
Instead, we can replace the linked list with a heap-based
priority queue, which can do O(log n) insertion, making the
whole insertion procedure O(n log n).
As a result of switching to the prio_queue struct, we fix
two minor bugs:
1. When we "pop" a commit in get_rev, and when we clear
the rev_list in find_common, we do not take care to
free the "struct commit_list", and just leak its
memory. With the prio_queue implementation, the memory
management is handled for us.
2. In get_rev, we look at the head commit of the list,
possibly push its parents onto the list, and then "pop"
the front of the list off, assuming it is the same
element that we just peeked at. This is typically going
to be the case, but would not be in the face of clock
skew: the parents are inserted by date, and could
potentially be inserted at the head of the list if they
have a timestamp newer than their descendent. In this
case, we would accidentally pop the parent, and never
process it at all.
The new implementation pulls the commit off of the
queue as we examine it, and so does not suffer from
this problem.
With this patch, a fetch of a single commit into a
repository with 50,000 refs went from:
real 0m7.984s
user 0m7.852s
sys 0m0.120s
to:
real 0m2.017s
user 0m1.884s
sys 0m0.124s
Before this patch, a larger case with 370K refs still had
not completed after tens of minutes; with this patch, it
completes in about 12 seconds.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-02 08:24:21 +02:00
|
|
|
if (rev_list.nr == 0 || non_common_revs == 0)
|
2012-10-26 17:53:55 +02:00
|
|
|
return NULL;
|
|
|
|
|
|
fetch-pack: avoid quadratic behavior in rev_list_push
When we call find_common to start finding common ancestors
with the remote side of a fetch, the first thing we do is
insert the tip of each ref into our rev_list linked list. We
keep the list sorted the whole time with
commit_list_insert_by_date, which means our insertion ends
up doing O(n^2) timestamp comparisons.
We could teach rev_list_push to use an unsorted list, and
then sort it once after we have added each ref. However, in
get_rev, we process the list by popping commits off the
front and adding parents back in timestamp-sorted order. So
that procedure would still operate on the large list.
Instead, we can replace the linked list with a heap-based
priority queue, which can do O(log n) insertion, making the
whole insertion procedure O(n log n).
As a result of switching to the prio_queue struct, we fix
two minor bugs:
1. When we "pop" a commit in get_rev, and when we clear
the rev_list in find_common, we do not take care to
free the "struct commit_list", and just leak its
memory. With the prio_queue implementation, the memory
management is handled for us.
2. In get_rev, we look at the head commit of the list,
possibly push its parents onto the list, and then "pop"
the front of the list off, assuming it is the same
element that we just peeked at. This is typically going
to be the case, but would not be in the face of clock
skew: the parents are inserted by date, and could
potentially be inserted at the head of the list if they
have a timestamp newer than their descendent. In this
case, we would accidentally pop the parent, and never
process it at all.
The new implementation pulls the commit off of the
queue as we examine it, and so does not suffer from
this problem.
With this patch, a fetch of a single commit into a
repository with 50,000 refs went from:
real 0m7.984s
user 0m7.852s
sys 0m0.120s
to:
real 0m2.017s
user 0m1.884s
sys 0m0.124s
Before this patch, a larger case with 370K refs still had
not completed after tens of minutes; with this patch, it
completes in about 12 seconds.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-02 08:24:21 +02:00
|
|
|
commit = prio_queue_get(&rev_list);
|
2013-10-24 10:53:01 +02:00
|
|
|
parse_commit(commit);
|
2012-10-26 17:53:55 +02:00
|
|
|
parents = commit->parents;
|
|
|
|
|
|
|
|
|
|
commit->object.flags |= POPPED;
|
|
|
|
|
if (!(commit->object.flags & COMMON))
|
|
|
|
|
non_common_revs--;
|
|
|
|
|
|
|
|
|
|
if (commit->object.flags & COMMON) {
|
|
|
|
|
/* do not send "have", and ignore ancestors */
|
|
|
|
|
commit = NULL;
|
|
|
|
|
mark = COMMON | SEEN;
|
|
|
|
|
} else if (commit->object.flags & COMMON_REF)
|
|
|
|
|
/* send "have", and ignore ancestors */
|
|
|
|
|
mark = COMMON | SEEN;
|
|
|
|
|
else
|
|
|
|
|
/* send "have", also for its ancestors */
|
|
|
|
|
mark = SEEN;
|
|
|
|
|
|
|
|
|
|
while (parents) {
|
|
|
|
|
if (!(parents->item->object.flags & SEEN))
|
|
|
|
|
rev_list_push(parents->item, mark);
|
|
|
|
|
if (mark & COMMON)
|
|
|
|
|
mark_common(parents->item, 1, 0);
|
|
|
|
|
parents = parents->next;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-10 03:22:29 +01:00
|
|
|
return commit->object.oid.hash;
|
2012-10-26 17:53:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
enum ack_type {
|
|
|
|
|
NAK = 0,
|
|
|
|
|
ACK,
|
|
|
|
|
ACK_continue,
|
|
|
|
|
ACK_common,
|
|
|
|
|
ACK_ready
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void consume_shallow_list(struct fetch_pack_args *args, int fd)
|
|
|
|
|
{
|
|
|
|
|
if (args->stateless_rpc && args->depth > 0) {
|
|
|
|
|
/* If we sent a depth we will get back "duplicate"
|
|
|
|
|
* shallow and unshallow commands every time there
|
|
|
|
|
* is a block of have lines exchanged.
|
|
|
|
|
*/
|
pkt-line: provide a LARGE_PACKET_MAX static buffer
Most of the callers of packet_read_line just read into a
static 1000-byte buffer (callers which handle arbitrary
binary data already use LARGE_PACKET_MAX). This works fine
in practice, because:
1. The only variable-sized data in these lines is a ref
name, and refs tend to be a lot shorter than 1000
characters.
2. When sending ref lines, git-core always limits itself
to 1000 byte packets.
However, the only limit given in the protocol specification
in Documentation/technical/protocol-common.txt is
LARGE_PACKET_MAX; the 1000 byte limit is mentioned only in
pack-protocol.txt, and then only describing what we write,
not as a specific limit for readers.
This patch lets us bump the 1000-byte limit to
LARGE_PACKET_MAX. Even though git-core will never write a
packet where this makes a difference, there are two good
reasons to do this:
1. Other git implementations may have followed
protocol-common.txt and used a larger maximum size. We
don't bump into it in practice because it would involve
very long ref names.
2. We may want to increase the 1000-byte limit one day.
Since packets are transferred before any capabilities,
it's difficult to do this in a backwards-compatible
way. But if we bump the size of buffer the readers can
handle, eventually older versions of git will be
obsolete enough that we can justify bumping the
writers, as well. We don't have plans to do this
anytime soon, but there is no reason not to start the
clock ticking now.
Just bumping all of the reading bufs to LARGE_PACKET_MAX
would waste memory. Instead, since most readers just read
into a temporary buffer anyway, let's provide a single
static buffer that all callers can use. We can further wrap
this detail away by having the packet_read_line wrapper just
use the buffer transparently and return a pointer to the
static storage. That covers most of the cases, and the
remaining ones already read into their own LARGE_PACKET_MAX
buffers.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-02-20 21:02:57 +01:00
|
|
|
char *line;
|
|
|
|
|
while ((line = packet_read_line(fd, NULL))) {
|
2013-11-30 21:55:40 +01:00
|
|
|
if (starts_with(line, "shallow "))
|
2012-10-26 17:53:55 +02:00
|
|
|
continue;
|
2013-11-30 21:55:40 +01:00
|
|
|
if (starts_with(line, "unshallow "))
|
2012-10-26 17:53:55 +02:00
|
|
|
continue;
|
|
|
|
|
die("git fetch-pack: expected shallow list");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static enum ack_type get_ack(int fd, unsigned char *result_sha1)
|
|
|
|
|
{
|
pkt-line: provide a LARGE_PACKET_MAX static buffer
Most of the callers of packet_read_line just read into a
static 1000-byte buffer (callers which handle arbitrary
binary data already use LARGE_PACKET_MAX). This works fine
in practice, because:
1. The only variable-sized data in these lines is a ref
name, and refs tend to be a lot shorter than 1000
characters.
2. When sending ref lines, git-core always limits itself
to 1000 byte packets.
However, the only limit given in the protocol specification
in Documentation/technical/protocol-common.txt is
LARGE_PACKET_MAX; the 1000 byte limit is mentioned only in
pack-protocol.txt, and then only describing what we write,
not as a specific limit for readers.
This patch lets us bump the 1000-byte limit to
LARGE_PACKET_MAX. Even though git-core will never write a
packet where this makes a difference, there are two good
reasons to do this:
1. Other git implementations may have followed
protocol-common.txt and used a larger maximum size. We
don't bump into it in practice because it would involve
very long ref names.
2. We may want to increase the 1000-byte limit one day.
Since packets are transferred before any capabilities,
it's difficult to do this in a backwards-compatible
way. But if we bump the size of buffer the readers can
handle, eventually older versions of git will be
obsolete enough that we can justify bumping the
writers, as well. We don't have plans to do this
anytime soon, but there is no reason not to start the
clock ticking now.
Just bumping all of the reading bufs to LARGE_PACKET_MAX
would waste memory. Instead, since most readers just read
into a temporary buffer anyway, let's provide a single
static buffer that all callers can use. We can further wrap
this detail away by having the packet_read_line wrapper just
use the buffer transparently and return a pointer to the
static storage. That covers most of the cases, and the
remaining ones already read into their own LARGE_PACKET_MAX
buffers.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-02-20 21:02:57 +01:00
|
|
|
int len;
|
|
|
|
|
char *line = packet_read_line(fd, &len);
|
2014-06-18 21:56:03 +02:00
|
|
|
const char *arg;
|
2012-10-26 17:53:55 +02:00
|
|
|
|
|
|
|
|
if (!len)
|
|
|
|
|
die("git fetch-pack: expected ACK/NAK, got EOF");
|
|
|
|
|
if (!strcmp(line, "NAK"))
|
|
|
|
|
return NAK;
|
2014-06-18 21:56:03 +02:00
|
|
|
if (skip_prefix(line, "ACK ", &arg)) {
|
|
|
|
|
if (!get_sha1_hex(arg, result_sha1)) {
|
|
|
|
|
arg += 40;
|
|
|
|
|
len -= arg - line;
|
|
|
|
|
if (len < 1)
|
fetch-pack: fix out-of-bounds buffer offset in get_ack
When we read acks from the remote, we expect either:
ACK <sha1>
or
ACK <sha1> <multi-ack-flag>
We parse the "ACK <sha1>" bit from the line, and then start
looking for the flag strings at "line+45"; if we don't have
them, we assume it's of the first type. But if we do have
the first type, then line+45 is not necessarily inside our
string at all!
It turns out that this works most of the time due to the way
we parse the packets. They should come in with a newline,
and packet_read puts an extra NUL into the buffer, so we end
up with:
ACK <sha1>\n\0
with the newline at offset 44 and the NUL at offset 45. We
then strip the newline, putting a NUL at offset 44. So
when we look at "line+45", we are looking past the end of
our string; but it's OK, because we hit the terminator from
the original string.
This breaks down, however, if the other side does not
terminate their packets with a newline. In that case, our
packet is one character shorter, and we start looking
through uninitialized memory for the flag. No known
implementation sends such a packet, so it has never come up
in practice.
This patch tightens the check by looking for a short,
flagless ACK before trying to parse the flag.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-02-20 21:00:28 +01:00
|
|
|
return ACK;
|
2014-06-18 21:56:03 +02:00
|
|
|
if (strstr(arg, "continue"))
|
2012-10-26 17:53:55 +02:00
|
|
|
return ACK_continue;
|
2014-06-18 21:56:03 +02:00
|
|
|
if (strstr(arg, "common"))
|
2012-10-26 17:53:55 +02:00
|
|
|
return ACK_common;
|
2014-06-18 21:56:03 +02:00
|
|
|
if (strstr(arg, "ready"))
|
2012-10-26 17:53:55 +02:00
|
|
|
return ACK_ready;
|
|
|
|
|
return ACK;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
die("git fetch_pack: expected ACK/NAK, got '%s'", line);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void send_request(struct fetch_pack_args *args,
|
|
|
|
|
int fd, struct strbuf *buf)
|
|
|
|
|
{
|
|
|
|
|
if (args->stateless_rpc) {
|
|
|
|
|
send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
|
|
|
|
|
packet_flush(fd);
|
|
|
|
|
} else
|
2013-02-20 21:01:56 +01:00
|
|
|
write_or_die(fd, buf->buf, buf->len);
|
2012-10-26 17:53:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void insert_one_alternate_ref(const struct ref *ref, void *unused)
|
|
|
|
|
{
|
2015-11-10 03:22:20 +01:00
|
|
|
rev_list_insert_ref(NULL, ref->old_oid.hash);
|
2012-10-26 17:53:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define INITIAL_FLUSH 16
|
|
|
|
|
#define PIPESAFE_FLUSH 32
|
|
|
|
|
#define LARGE_FLUSH 1024
|
|
|
|
|
|
|
|
|
|
static int next_flush(struct fetch_pack_args *args, int count)
|
|
|
|
|
{
|
|
|
|
|
int flush_limit = args->stateless_rpc ? LARGE_FLUSH : PIPESAFE_FLUSH;
|
|
|
|
|
|
|
|
|
|
if (count < flush_limit)
|
|
|
|
|
count <<= 1;
|
|
|
|
|
else
|
|
|
|
|
count += flush_limit;
|
|
|
|
|
return count;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int find_common(struct fetch_pack_args *args,
|
|
|
|
|
int fd[2], unsigned char *result_sha1,
|
|
|
|
|
struct ref *refs)
|
|
|
|
|
{
|
|
|
|
|
int fetching;
|
|
|
|
|
int count = 0, flushes = 0, flush_at = INITIAL_FLUSH, retval;
|
|
|
|
|
const unsigned char *sha1;
|
|
|
|
|
unsigned in_vain = 0;
|
|
|
|
|
int got_continue = 0;
|
|
|
|
|
int got_ready = 0;
|
|
|
|
|
struct strbuf req_buf = STRBUF_INIT;
|
|
|
|
|
size_t state_len = 0;
|
|
|
|
|
|
|
|
|
|
if (args->stateless_rpc && multi_ack == 1)
|
|
|
|
|
die("--stateless-rpc requires multi_ack_detailed");
|
|
|
|
|
if (marked)
|
|
|
|
|
for_each_ref(clear_marks, NULL);
|
|
|
|
|
marked = 1;
|
|
|
|
|
|
2015-05-25 20:39:18 +02:00
|
|
|
for_each_ref(rev_list_insert_ref_oid, NULL);
|
2012-10-26 17:53:55 +02:00
|
|
|
for_each_alternate_ref(insert_one_alternate_ref, NULL);
|
|
|
|
|
|
|
|
|
|
fetching = 0;
|
|
|
|
|
for ( ; refs ; refs = refs->next) {
|
2015-11-10 03:22:20 +01:00
|
|
|
unsigned char *remote = refs->old_oid.hash;
|
2012-10-26 17:53:55 +02:00
|
|
|
const char *remote_hex;
|
|
|
|
|
struct object *o;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If that object is complete (i.e. it is an ancestor of a
|
|
|
|
|
* local ref), we tell them we have it but do not have to
|
|
|
|
|
* tell them about its ancestors, which they already know
|
|
|
|
|
* about.
|
|
|
|
|
*
|
|
|
|
|
* We use lookup_object here because we are only
|
|
|
|
|
* interested in the case we *know* the object is
|
|
|
|
|
* reachable and we have already scanned it.
|
|
|
|
|
*/
|
|
|
|
|
if (((o = lookup_object(remote)) != NULL) &&
|
|
|
|
|
(o->flags & COMPLETE)) {
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
remote_hex = sha1_to_hex(remote);
|
|
|
|
|
if (!fetching) {
|
|
|
|
|
struct strbuf c = STRBUF_INIT;
|
|
|
|
|
if (multi_ack == 2) strbuf_addstr(&c, " multi_ack_detailed");
|
|
|
|
|
if (multi_ack == 1) strbuf_addstr(&c, " multi_ack");
|
|
|
|
|
if (no_done) strbuf_addstr(&c, " no-done");
|
|
|
|
|
if (use_sideband == 2) strbuf_addstr(&c, " side-band-64k");
|
|
|
|
|
if (use_sideband == 1) strbuf_addstr(&c, " side-band");
|
|
|
|
|
if (args->use_thin_pack) strbuf_addstr(&c, " thin-pack");
|
|
|
|
|
if (args->no_progress) strbuf_addstr(&c, " no-progress");
|
|
|
|
|
if (args->include_tag) strbuf_addstr(&c, " include-tag");
|
|
|
|
|
if (prefer_ofs_delta) strbuf_addstr(&c, " ofs-delta");
|
|
|
|
|
if (agent_supported) strbuf_addf(&c, " agent=%s",
|
|
|
|
|
git_user_agent_sanitized());
|
|
|
|
|
packet_buf_write(&req_buf, "want %s%s\n", remote_hex, c.buf);
|
|
|
|
|
strbuf_release(&c);
|
|
|
|
|
} else
|
|
|
|
|
packet_buf_write(&req_buf, "want %s\n", remote_hex);
|
|
|
|
|
fetching++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!fetching) {
|
|
|
|
|
strbuf_release(&req_buf);
|
|
|
|
|
packet_flush(fd[1]);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (is_repository_shallow())
|
2013-12-05 14:02:34 +01:00
|
|
|
write_shallow_commits(&req_buf, 1, NULL);
|
2012-10-26 17:53:55 +02:00
|
|
|
if (args->depth > 0)
|
|
|
|
|
packet_buf_write(&req_buf, "deepen %d", args->depth);
|
|
|
|
|
packet_buf_flush(&req_buf);
|
|
|
|
|
state_len = req_buf.len;
|
|
|
|
|
|
|
|
|
|
if (args->depth > 0) {
|
pkt-line: provide a LARGE_PACKET_MAX static buffer
Most of the callers of packet_read_line just read into a
static 1000-byte buffer (callers which handle arbitrary
binary data already use LARGE_PACKET_MAX). This works fine
in practice, because:
1. The only variable-sized data in these lines is a ref
name, and refs tend to be a lot shorter than 1000
characters.
2. When sending ref lines, git-core always limits itself
to 1000 byte packets.
However, the only limit given in the protocol specification
in Documentation/technical/protocol-common.txt is
LARGE_PACKET_MAX; the 1000 byte limit is mentioned only in
pack-protocol.txt, and then only describing what we write,
not as a specific limit for readers.
This patch lets us bump the 1000-byte limit to
LARGE_PACKET_MAX. Even though git-core will never write a
packet where this makes a difference, there are two good
reasons to do this:
1. Other git implementations may have followed
protocol-common.txt and used a larger maximum size. We
don't bump into it in practice because it would involve
very long ref names.
2. We may want to increase the 1000-byte limit one day.
Since packets are transferred before any capabilities,
it's difficult to do this in a backwards-compatible
way. But if we bump the size of buffer the readers can
handle, eventually older versions of git will be
obsolete enough that we can justify bumping the
writers, as well. We don't have plans to do this
anytime soon, but there is no reason not to start the
clock ticking now.
Just bumping all of the reading bufs to LARGE_PACKET_MAX
would waste memory. Instead, since most readers just read
into a temporary buffer anyway, let's provide a single
static buffer that all callers can use. We can further wrap
this detail away by having the packet_read_line wrapper just
use the buffer transparently and return a pointer to the
static storage. That covers most of the cases, and the
remaining ones already read into their own LARGE_PACKET_MAX
buffers.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-02-20 21:02:57 +01:00
|
|
|
char *line;
|
use skip_prefix to avoid magic numbers
It's a common idiom to match a prefix and then skip past it
with a magic number, like:
if (starts_with(foo, "bar"))
foo += 3;
This is easy to get wrong, since you have to count the
prefix string yourself, and there's no compiler check if the
string changes. We can use skip_prefix to avoid the magic
numbers here.
Note that some of these conversions could be much shorter.
For example:
if (starts_with(arg, "--foo=")) {
bar = arg + 6;
continue;
}
could become:
if (skip_prefix(arg, "--foo=", &bar))
continue;
However, I have left it as:
if (skip_prefix(arg, "--foo=", &v)) {
bar = v;
continue;
}
to visually match nearby cases which need to actually
process the string. Like:
if (skip_prefix(arg, "--foo=", &v)) {
bar = atoi(v);
continue;
}
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-06-18 21:47:50 +02:00
|
|
|
const char *arg;
|
2012-10-26 17:53:55 +02:00
|
|
|
unsigned char sha1[20];
|
|
|
|
|
|
|
|
|
|
send_request(args, fd[1], &req_buf);
|
pkt-line: provide a LARGE_PACKET_MAX static buffer
Most of the callers of packet_read_line just read into a
static 1000-byte buffer (callers which handle arbitrary
binary data already use LARGE_PACKET_MAX). This works fine
in practice, because:
1. The only variable-sized data in these lines is a ref
name, and refs tend to be a lot shorter than 1000
characters.
2. When sending ref lines, git-core always limits itself
to 1000 byte packets.
However, the only limit given in the protocol specification
in Documentation/technical/protocol-common.txt is
LARGE_PACKET_MAX; the 1000 byte limit is mentioned only in
pack-protocol.txt, and then only describing what we write,
not as a specific limit for readers.
This patch lets us bump the 1000-byte limit to
LARGE_PACKET_MAX. Even though git-core will never write a
packet where this makes a difference, there are two good
reasons to do this:
1. Other git implementations may have followed
protocol-common.txt and used a larger maximum size. We
don't bump into it in practice because it would involve
very long ref names.
2. We may want to increase the 1000-byte limit one day.
Since packets are transferred before any capabilities,
it's difficult to do this in a backwards-compatible
way. But if we bump the size of buffer the readers can
handle, eventually older versions of git will be
obsolete enough that we can justify bumping the
writers, as well. We don't have plans to do this
anytime soon, but there is no reason not to start the
clock ticking now.
Just bumping all of the reading bufs to LARGE_PACKET_MAX
would waste memory. Instead, since most readers just read
into a temporary buffer anyway, let's provide a single
static buffer that all callers can use. We can further wrap
this detail away by having the packet_read_line wrapper just
use the buffer transparently and return a pointer to the
static storage. That covers most of the cases, and the
remaining ones already read into their own LARGE_PACKET_MAX
buffers.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-02-20 21:02:57 +01:00
|
|
|
while ((line = packet_read_line(fd[0], NULL))) {
|
use skip_prefix to avoid magic numbers
It's a common idiom to match a prefix and then skip past it
with a magic number, like:
if (starts_with(foo, "bar"))
foo += 3;
This is easy to get wrong, since you have to count the
prefix string yourself, and there's no compiler check if the
string changes. We can use skip_prefix to avoid the magic
numbers here.
Note that some of these conversions could be much shorter.
For example:
if (starts_with(arg, "--foo=")) {
bar = arg + 6;
continue;
}
could become:
if (skip_prefix(arg, "--foo=", &bar))
continue;
However, I have left it as:
if (skip_prefix(arg, "--foo=", &v)) {
bar = v;
continue;
}
to visually match nearby cases which need to actually
process the string. Like:
if (skip_prefix(arg, "--foo=", &v)) {
bar = atoi(v);
continue;
}
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-06-18 21:47:50 +02:00
|
|
|
if (skip_prefix(line, "shallow ", &arg)) {
|
|
|
|
|
if (get_sha1_hex(arg, sha1))
|
2012-10-26 17:53:55 +02:00
|
|
|
die("invalid shallow line: %s", line);
|
|
|
|
|
register_shallow(sha1);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
use skip_prefix to avoid magic numbers
It's a common idiom to match a prefix and then skip past it
with a magic number, like:
if (starts_with(foo, "bar"))
foo += 3;
This is easy to get wrong, since you have to count the
prefix string yourself, and there's no compiler check if the
string changes. We can use skip_prefix to avoid the magic
numbers here.
Note that some of these conversions could be much shorter.
For example:
if (starts_with(arg, "--foo=")) {
bar = arg + 6;
continue;
}
could become:
if (skip_prefix(arg, "--foo=", &bar))
continue;
However, I have left it as:
if (skip_prefix(arg, "--foo=", &v)) {
bar = v;
continue;
}
to visually match nearby cases which need to actually
process the string. Like:
if (skip_prefix(arg, "--foo=", &v)) {
bar = atoi(v);
continue;
}
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-06-18 21:47:50 +02:00
|
|
|
if (skip_prefix(line, "unshallow ", &arg)) {
|
|
|
|
|
if (get_sha1_hex(arg, sha1))
|
2012-10-26 17:53:55 +02:00
|
|
|
die("invalid unshallow line: %s", line);
|
|
|
|
|
if (!lookup_object(sha1))
|
|
|
|
|
die("object not found: %s", line);
|
|
|
|
|
/* make sure that it is parsed as shallow */
|
|
|
|
|
if (!parse_object(sha1))
|
|
|
|
|
die("error in object: %s", line);
|
|
|
|
|
if (unregister_shallow(sha1))
|
|
|
|
|
die("no shallow found: %s", line);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
die("expected shallow/unshallow, got %s", line);
|
|
|
|
|
}
|
|
|
|
|
} else if (!args->stateless_rpc)
|
|
|
|
|
send_request(args, fd[1], &req_buf);
|
|
|
|
|
|
|
|
|
|
if (!args->stateless_rpc) {
|
|
|
|
|
/* If we aren't using the stateless-rpc interface
|
|
|
|
|
* we don't need to retain the headers.
|
|
|
|
|
*/
|
|
|
|
|
strbuf_setlen(&req_buf, 0);
|
|
|
|
|
state_len = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
flushes = 0;
|
|
|
|
|
retval = -1;
|
|
|
|
|
while ((sha1 = get_rev())) {
|
|
|
|
|
packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
|
|
|
|
|
if (args->verbose)
|
|
|
|
|
fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
|
|
|
|
|
in_vain++;
|
|
|
|
|
if (flush_at <= ++count) {
|
|
|
|
|
int ack;
|
|
|
|
|
|
|
|
|
|
packet_buf_flush(&req_buf);
|
|
|
|
|
send_request(args, fd[1], &req_buf);
|
|
|
|
|
strbuf_setlen(&req_buf, state_len);
|
|
|
|
|
flushes++;
|
|
|
|
|
flush_at = next_flush(args, count);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We keep one window "ahead" of the other side, and
|
|
|
|
|
* will wait for an ACK only on the next one
|
|
|
|
|
*/
|
|
|
|
|
if (!args->stateless_rpc && count == INITIAL_FLUSH)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
consume_shallow_list(args, fd[0]);
|
|
|
|
|
do {
|
|
|
|
|
ack = get_ack(fd[0], result_sha1);
|
|
|
|
|
if (args->verbose && ack)
|
|
|
|
|
fprintf(stderr, "got ack %d %s\n", ack,
|
|
|
|
|
sha1_to_hex(result_sha1));
|
|
|
|
|
switch (ack) {
|
|
|
|
|
case ACK:
|
|
|
|
|
flushes = 0;
|
|
|
|
|
multi_ack = 0;
|
|
|
|
|
retval = 0;
|
|
|
|
|
goto done;
|
|
|
|
|
case ACK_common:
|
|
|
|
|
case ACK_ready:
|
|
|
|
|
case ACK_continue: {
|
|
|
|
|
struct commit *commit =
|
|
|
|
|
lookup_commit(result_sha1);
|
|
|
|
|
if (!commit)
|
|
|
|
|
die("invalid commit %s", sha1_to_hex(result_sha1));
|
|
|
|
|
if (args->stateless_rpc
|
|
|
|
|
&& ack == ACK_common
|
|
|
|
|
&& !(commit->object.flags & COMMON)) {
|
|
|
|
|
/* We need to replay the have for this object
|
|
|
|
|
* on the next RPC request so the peer knows
|
|
|
|
|
* it is in common with us.
|
|
|
|
|
*/
|
|
|
|
|
const char *hex = sha1_to_hex(result_sha1);
|
|
|
|
|
packet_buf_write(&req_buf, "have %s\n", hex);
|
|
|
|
|
state_len = req_buf.len;
|
|
|
|
|
}
|
|
|
|
|
mark_common(commit, 0, 1);
|
|
|
|
|
retval = 0;
|
|
|
|
|
in_vain = 0;
|
|
|
|
|
got_continue = 1;
|
|
|
|
|
if (ack == ACK_ready) {
|
fetch-pack: avoid quadratic behavior in rev_list_push
When we call find_common to start finding common ancestors
with the remote side of a fetch, the first thing we do is
insert the tip of each ref into our rev_list linked list. We
keep the list sorted the whole time with
commit_list_insert_by_date, which means our insertion ends
up doing O(n^2) timestamp comparisons.
We could teach rev_list_push to use an unsorted list, and
then sort it once after we have added each ref. However, in
get_rev, we process the list by popping commits off the
front and adding parents back in timestamp-sorted order. So
that procedure would still operate on the large list.
Instead, we can replace the linked list with a heap-based
priority queue, which can do O(log n) insertion, making the
whole insertion procedure O(n log n).
As a result of switching to the prio_queue struct, we fix
two minor bugs:
1. When we "pop" a commit in get_rev, and when we clear
the rev_list in find_common, we do not take care to
free the "struct commit_list", and just leak its
memory. With the prio_queue implementation, the memory
management is handled for us.
2. In get_rev, we look at the head commit of the list,
possibly push its parents onto the list, and then "pop"
the front of the list off, assuming it is the same
element that we just peeked at. This is typically going
to be the case, but would not be in the face of clock
skew: the parents are inserted by date, and could
potentially be inserted at the head of the list if they
have a timestamp newer than their descendent. In this
case, we would accidentally pop the parent, and never
process it at all.
The new implementation pulls the commit off of the
queue as we examine it, and so does not suffer from
this problem.
With this patch, a fetch of a single commit into a
repository with 50,000 refs went from:
real 0m7.984s
user 0m7.852s
sys 0m0.120s
to:
real 0m2.017s
user 0m1.884s
sys 0m0.124s
Before this patch, a larger case with 370K refs still had
not completed after tens of minutes; with this patch, it
completes in about 12 seconds.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-02 08:24:21 +02:00
|
|
|
clear_prio_queue(&rev_list);
|
2012-10-26 17:53:55 +02:00
|
|
|
got_ready = 1;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} while (ack);
|
|
|
|
|
flushes--;
|
|
|
|
|
if (got_continue && MAX_IN_VAIN < in_vain) {
|
|
|
|
|
if (args->verbose)
|
|
|
|
|
fprintf(stderr, "giving up\n");
|
|
|
|
|
break; /* give up */
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
done:
|
|
|
|
|
if (!got_ready || !no_done) {
|
|
|
|
|
packet_buf_write(&req_buf, "done\n");
|
|
|
|
|
send_request(args, fd[1], &req_buf);
|
|
|
|
|
}
|
|
|
|
|
if (args->verbose)
|
|
|
|
|
fprintf(stderr, "done\n");
|
|
|
|
|
if (retval != 0) {
|
|
|
|
|
multi_ack = 0;
|
|
|
|
|
flushes++;
|
|
|
|
|
}
|
|
|
|
|
strbuf_release(&req_buf);
|
|
|
|
|
|
2014-02-06 16:10:39 +01:00
|
|
|
if (!got_ready || !no_done)
|
|
|
|
|
consume_shallow_list(args, fd[0]);
|
2012-10-26 17:53:55 +02:00
|
|
|
while (flushes || multi_ack) {
|
|
|
|
|
int ack = get_ack(fd[0], result_sha1);
|
|
|
|
|
if (ack) {
|
|
|
|
|
if (args->verbose)
|
|
|
|
|
fprintf(stderr, "got ack (%d) %s\n", ack,
|
|
|
|
|
sha1_to_hex(result_sha1));
|
|
|
|
|
if (ack == ACK)
|
|
|
|
|
return 0;
|
|
|
|
|
multi_ack = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
flushes--;
|
|
|
|
|
}
|
|
|
|
|
/* it is no error to fetch into a completely empty repo */
|
|
|
|
|
return count ? retval : 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct commit_list *complete;
|
|
|
|
|
|
2015-05-25 20:39:17 +02:00
|
|
|
static int mark_complete(const unsigned char *sha1)
|
2012-10-26 17:53:55 +02:00
|
|
|
{
|
|
|
|
|
struct object *o = parse_object(sha1);
|
|
|
|
|
|
|
|
|
|
while (o && o->type == OBJ_TAG) {
|
|
|
|
|
struct tag *t = (struct tag *) o;
|
|
|
|
|
if (!t->tagged)
|
|
|
|
|
break; /* broken repository */
|
|
|
|
|
o->flags |= COMPLETE;
|
2015-11-10 03:22:29 +01:00
|
|
|
o = parse_object(t->tagged->oid.hash);
|
2012-10-26 17:53:55 +02:00
|
|
|
}
|
|
|
|
|
if (o && o->type == OBJ_COMMIT) {
|
|
|
|
|
struct commit *commit = (struct commit *)o;
|
|
|
|
|
if (!(commit->object.flags & COMPLETE)) {
|
|
|
|
|
commit->object.flags |= COMPLETE;
|
fetch-pack: avoid quadratic list insertion in mark_complete
We insert the commit pointed to by each ref one-by-one into
the "complete" commit_list using insert_by_date. Because
each insertion is O(n), we end up with O(n^2) behavior.
This typically doesn't matter, because the number of refs is
reasonably small. And even if there are a lot of refs, they
often point to a smaller set of objects (in which case the
optimization in commit ea5f220 keeps our "n" small).
However, in pathological repositories (hundreds of thousands
of refs, each pointing to a unique commit), this quadratic
behavior can make a difference. Since we do not care about
the list order until we have finished building it, we can
simply keep it unsorted during the insertion phase, then
sort it afterwards.
On a repository like the one described above, this dropped
the time to do a no-op fetch from 2.0s to 1.7s. On normal
repositories, it probably does not matter at all, but it
does not hurt to protect ourselves from pathological cases.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-02 08:16:23 +02:00
|
|
|
commit_list_insert(commit, &complete);
|
2012-10-26 17:53:55 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-25 20:39:16 +02:00
|
|
|
static int mark_complete_oid(const char *refname, const struct object_id *oid,
|
|
|
|
|
int flag, void *cb_data)
|
|
|
|
|
{
|
2015-05-25 20:39:17 +02:00
|
|
|
return mark_complete(oid->hash);
|
2015-05-25 20:39:16 +02:00
|
|
|
}
|
|
|
|
|
|
2012-10-26 17:53:55 +02:00
|
|
|
static void mark_recent_complete_commits(struct fetch_pack_args *args,
|
|
|
|
|
unsigned long cutoff)
|
|
|
|
|
{
|
|
|
|
|
while (complete && cutoff <= complete->item->date) {
|
|
|
|
|
if (args->verbose)
|
|
|
|
|
fprintf(stderr, "Marking %s as complete\n",
|
2015-11-10 03:22:28 +01:00
|
|
|
oid_to_hex(&complete->item->object.oid));
|
2012-10-26 17:53:55 +02:00
|
|
|
pop_most_recent_commit(&complete, COMPLETE);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void filter_refs(struct fetch_pack_args *args,
|
2013-01-29 23:02:15 +01:00
|
|
|
struct ref **refs,
|
|
|
|
|
struct ref **sought, int nr_sought)
|
2012-10-26 17:53:55 +02:00
|
|
|
{
|
|
|
|
|
struct ref *newlist = NULL;
|
|
|
|
|
struct ref **newtail = &newlist;
|
|
|
|
|
struct ref *ref, *next;
|
2013-01-29 23:02:15 +01:00
|
|
|
int i;
|
2012-10-26 17:53:55 +02:00
|
|
|
|
2013-01-29 23:02:15 +01:00
|
|
|
i = 0;
|
2012-10-26 17:53:55 +02:00
|
|
|
for (ref = *refs; ref; ref = next) {
|
|
|
|
|
int keep = 0;
|
|
|
|
|
next = ref->next;
|
2013-01-29 23:02:15 +01:00
|
|
|
|
2014-06-06 19:24:48 +02:00
|
|
|
if (starts_with(ref->name, "refs/") &&
|
fetch-pack: do not filter out one-level refs
Currently fetching a one-level ref like "refs/foo" does not
work consistently. The outer "git fetch" program filters the
list of refs, checking each against check_refname_format.
Then it feeds the result to do_fetch_pack to actually
negotiate the haves/wants and get the pack. The fetch-pack
code does its own filter, and it behaves differently.
The fetch-pack filter looks for refs in "refs/", and then
feeds everything _after_ the slash (i.e., just "foo") into
check_refname_format. But check_refname_format is not
designed to look at a partial refname. It complains that the
ref has only one component, thinking it is at the root
(i.e., alongside "HEAD"), when in reality we just fed it a
partial refname.
As a result, we omit a ref like "refs/foo" from the pack
request, even though "git fetch" then tries to store the
resulting ref. If we happen to get the object anyway (e.g.,
because the ref is contained in another ref we are
fetching), then the fetch succeeds. But if it is a unique
object, we fail when trying to update "refs/foo".
We can fix this by just passing the whole refname into
check_refname_format; we know the part we were omitting is
"refs/", which is acceptable in a refname. This at least
makes the checks consistent with each other.
This problem happens most commonly with "refs/stash", which
is the only one-level ref in wide use. However, our test
does not use "refs/stash", as we may later want to restrict
it specifically (not because it is one-level, but because
of the semantics of stashes).
We may also want to do away with the multiple levels of
filtering (which can cause problems when they are out of
sync), or even forbid one-level refs entirely. However,
those decisions can come later; this fixes the most
immediate problem, which is the mismatch between the two.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-01-15 11:46:13 +01:00
|
|
|
check_refname_format(ref->name, 0))
|
2012-10-26 17:53:55 +02:00
|
|
|
; /* trash */
|
|
|
|
|
else {
|
2013-01-29 23:02:15 +01:00
|
|
|
while (i < nr_sought) {
|
|
|
|
|
int cmp = strcmp(ref->name, sought[i]->name);
|
2012-10-26 17:53:55 +02:00
|
|
|
if (cmp < 0)
|
|
|
|
|
break; /* definitely do not have it */
|
|
|
|
|
else if (cmp == 0) {
|
|
|
|
|
keep = 1; /* definitely have it */
|
2013-01-29 23:02:15 +01:00
|
|
|
sought[i]->matched = 1;
|
2012-10-26 17:53:55 +02:00
|
|
|
}
|
2013-01-29 23:02:15 +01:00
|
|
|
i++;
|
2012-10-26 17:53:55 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-29 23:02:15 +01:00
|
|
|
if (!keep && args->fetch_all &&
|
2013-11-30 21:55:40 +01:00
|
|
|
(!args->depth || !starts_with(ref->name, "refs/tags/")))
|
2012-10-26 17:53:55 +02:00
|
|
|
keep = 1;
|
|
|
|
|
|
|
|
|
|
if (keep) {
|
|
|
|
|
*newtail = ref;
|
|
|
|
|
ref->next = NULL;
|
|
|
|
|
newtail = &ref->next;
|
|
|
|
|
} else {
|
|
|
|
|
free(ref);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-29 23:02:15 +01:00
|
|
|
/* Append unmatched requests to the list */
|
2015-05-21 22:23:39 +02:00
|
|
|
if ((allow_unadvertised_object_request &
|
|
|
|
|
(ALLOW_TIP_SHA1 | ALLOW_REACHABLE_SHA1))) {
|
2013-01-29 23:02:15 +01:00
|
|
|
for (i = 0; i < nr_sought; i++) {
|
filter_ref: avoid overwriting ref->old_sha1 with garbage
If the server supports allow_tip_sha1_in_want, then
fetch-pack's filter_refs function tries to check whether a
ref is a request for a straight sha1 by running:
if (get_sha1_hex(ref->name, ref->old_sha1))
...
I.e., we are using get_sha1_hex to ask "is this ref name a
sha1?". If it is true, then the contents of ref->old_sha1
will end up unchanged. But if it is false, then get_sha1_hex
makes no guarantees about what it has written. With a ref
name like "abcdefoo", we would overwrite 3 bytes of
ref->old_sha1 before realizing that it was not a sha1.
This is likely not a problem in practice, as anything in
refs->name (besides a sha1) will start with "refs/", meaning
that we would notice on the first character that there is a
problem. Still, we are making assumptions about the state
left in the output when get_sha1_hex returns an error (e.g.,
it could start from the end of the string, or error check
the values only once they were placed in the output). It's
better to be defensive.
We could just check that we have exactly 40 characters of
sha1. But let's be even more careful and make sure that we
have a 40-char hex refname that matches what is in old_sha1.
This is perhaps overly defensive, but spells out our
assumptions clearly.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-03-19 21:34:51 +01:00
|
|
|
unsigned char sha1[20];
|
|
|
|
|
|
2013-01-29 23:02:15 +01:00
|
|
|
ref = sought[i];
|
|
|
|
|
if (ref->matched)
|
|
|
|
|
continue;
|
filter_ref: avoid overwriting ref->old_sha1 with garbage
If the server supports allow_tip_sha1_in_want, then
fetch-pack's filter_refs function tries to check whether a
ref is a request for a straight sha1 by running:
if (get_sha1_hex(ref->name, ref->old_sha1))
...
I.e., we are using get_sha1_hex to ask "is this ref name a
sha1?". If it is true, then the contents of ref->old_sha1
will end up unchanged. But if it is false, then get_sha1_hex
makes no guarantees about what it has written. With a ref
name like "abcdefoo", we would overwrite 3 bytes of
ref->old_sha1 before realizing that it was not a sha1.
This is likely not a problem in practice, as anything in
refs->name (besides a sha1) will start with "refs/", meaning
that we would notice on the first character that there is a
problem. Still, we are making assumptions about the state
left in the output when get_sha1_hex returns an error (e.g.,
it could start from the end of the string, or error check
the values only once they were placed in the output). It's
better to be defensive.
We could just check that we have exactly 40 characters of
sha1. But let's be even more careful and make sure that we
have a 40-char hex refname that matches what is in old_sha1.
This is perhaps overly defensive, but spells out our
assumptions clearly.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-03-19 21:34:51 +01:00
|
|
|
if (get_sha1_hex(ref->name, sha1) ||
|
|
|
|
|
ref->name[40] != '\0' ||
|
2015-11-10 03:22:20 +01:00
|
|
|
hashcmp(sha1, ref->old_oid.hash))
|
2013-01-29 23:02:15 +01:00
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
ref->matched = 1;
|
filter_ref: make a copy of extra "sought" entries
If the server supports allow_tip_sha1_in_want, we add any
unmatched raw-sha1 entries in our "sought" list of refs to
the list of refs we will ask the other side for. We do so by
inserting the original "struct ref" directly into our list,
rather than making a copy. This has several problems.
The most minor problem is that one cannot ever free the
resulting list; it contains structs that are copies of the
remote refs (made earlier by fetch_pack) along with sought
refs that are referenced elsewhere.
But more importantly that we set the ref->next pointer to
NULL, chopping off the remainder of any existing list that
the ref was a part of. We get the set of "sought" refs in
an array rather than a linked list, but that array is often
in turn generated from a list. The test modification in
t5516 demonstrates this. Rather than fetching just an exact
sha1, we fetch that sha1 plus another ref:
- we build a linked list of refs to fetch when do_fetch
calls get_ref_map; the exact sha1 is first, followed by
the named ref ("refs/heads/extra" in this case).
- we pass that linked list to transport_fetch_ref, which
squashes it into an array of pointers
- that array goes to fetch_pack, which calls filter_ref.
There we generate the want list from a mix of what the
remote side has advertised, and the "sought" entry for
the exact sha1. We set the sought entry's "next" pointer
to NULL.
- after we return from transport_fetch_refs, we then try
to update the refs by following the linked list. But our
list is now truncated, and we do not update
refs/heads/extra at all.
We can fix this by making a copy of the ref. There's nothing
that fetch_pack does to it that must be reflected in the
original "sought" list (and indeed, if that were the case we
would have a serious bug, because it is only exact-sha1
entries which are treated this way).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-03-19 21:37:09 +01:00
|
|
|
*newtail = copy_ref(ref);
|
|
|
|
|
newtail = &(*newtail)->next;
|
2013-01-29 23:02:15 +01:00
|
|
|
}
|
|
|
|
|
}
|
2012-10-26 17:53:55 +02:00
|
|
|
*refs = newlist;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void mark_alternate_complete(const struct ref *ref, void *unused)
|
|
|
|
|
{
|
2015-11-10 03:22:20 +01:00
|
|
|
mark_complete(ref->old_oid.hash);
|
2012-10-26 17:53:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int everything_local(struct fetch_pack_args *args,
|
2013-01-29 23:02:15 +01:00
|
|
|
struct ref **refs,
|
|
|
|
|
struct ref **sought, int nr_sought)
|
2012-10-26 17:53:55 +02:00
|
|
|
{
|
|
|
|
|
struct ref *ref;
|
|
|
|
|
int retval;
|
|
|
|
|
unsigned long cutoff = 0;
|
|
|
|
|
|
|
|
|
|
save_commit_buffer = 0;
|
|
|
|
|
|
|
|
|
|
for (ref = *refs; ref; ref = ref->next) {
|
|
|
|
|
struct object *o;
|
|
|
|
|
|
2015-11-10 03:22:20 +01:00
|
|
|
if (!has_object_file(&ref->old_oid))
|
2013-01-27 04:42:09 +01:00
|
|
|
continue;
|
|
|
|
|
|
2015-11-10 03:22:20 +01:00
|
|
|
o = parse_object(ref->old_oid.hash);
|
2012-10-26 17:53:55 +02:00
|
|
|
if (!o)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* We already have it -- which may mean that we were
|
|
|
|
|
* in sync with the other side at some time after
|
|
|
|
|
* that (it is OK if we guess wrong here).
|
|
|
|
|
*/
|
|
|
|
|
if (o->type == OBJ_COMMIT) {
|
|
|
|
|
struct commit *commit = (struct commit *)o;
|
|
|
|
|
if (!cutoff || cutoff < commit->date)
|
|
|
|
|
cutoff = commit->date;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!args->depth) {
|
2015-05-25 20:39:16 +02:00
|
|
|
for_each_ref(mark_complete_oid, NULL);
|
2012-10-26 17:53:55 +02:00
|
|
|
for_each_alternate_ref(mark_alternate_complete, NULL);
|
fetch-pack: avoid quadratic list insertion in mark_complete
We insert the commit pointed to by each ref one-by-one into
the "complete" commit_list using insert_by_date. Because
each insertion is O(n), we end up with O(n^2) behavior.
This typically doesn't matter, because the number of refs is
reasonably small. And even if there are a lot of refs, they
often point to a smaller set of objects (in which case the
optimization in commit ea5f220 keeps our "n" small).
However, in pathological repositories (hundreds of thousands
of refs, each pointing to a unique commit), this quadratic
behavior can make a difference. Since we do not care about
the list order until we have finished building it, we can
simply keep it unsorted during the insertion phase, then
sort it afterwards.
On a repository like the one described above, this dropped
the time to do a no-op fetch from 2.0s to 1.7s. On normal
repositories, it probably does not matter at all, but it
does not hurt to protect ourselves from pathological cases.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-02 08:16:23 +02:00
|
|
|
commit_list_sort_by_date(&complete);
|
2012-10-26 17:53:55 +02:00
|
|
|
if (cutoff)
|
|
|
|
|
mark_recent_complete_commits(args, cutoff);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Mark all complete remote refs as common refs.
|
|
|
|
|
* Don't mark them common yet; the server has to be told so first.
|
|
|
|
|
*/
|
|
|
|
|
for (ref = *refs; ref; ref = ref->next) {
|
2015-11-10 03:22:20 +01:00
|
|
|
struct object *o = deref_tag(lookup_object(ref->old_oid.hash),
|
2012-10-26 17:53:55 +02:00
|
|
|
NULL, 0);
|
|
|
|
|
|
|
|
|
|
if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (!(o->flags & SEEN)) {
|
|
|
|
|
rev_list_push((struct commit *)o, COMMON_REF | SEEN);
|
|
|
|
|
|
|
|
|
|
mark_common((struct commit *)o, 1, 1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-29 23:02:15 +01:00
|
|
|
filter_refs(args, refs, sought, nr_sought);
|
2012-10-26 17:53:55 +02:00
|
|
|
|
|
|
|
|
for (retval = 1, ref = *refs; ref ; ref = ref->next) {
|
2015-11-10 03:22:20 +01:00
|
|
|
const unsigned char *remote = ref->old_oid.hash;
|
2012-10-26 17:53:55 +02:00
|
|
|
struct object *o;
|
|
|
|
|
|
|
|
|
|
o = lookup_object(remote);
|
|
|
|
|
if (!o || !(o->flags & COMPLETE)) {
|
|
|
|
|
retval = 0;
|
|
|
|
|
if (!args->verbose)
|
|
|
|
|
continue;
|
|
|
|
|
fprintf(stderr,
|
|
|
|
|
"want %s (%s)\n", sha1_to_hex(remote),
|
|
|
|
|
ref->name);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!args->verbose)
|
|
|
|
|
continue;
|
|
|
|
|
fprintf(stderr,
|
|
|
|
|
"already have %s (%s)\n", sha1_to_hex(remote),
|
|
|
|
|
ref->name);
|
|
|
|
|
}
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int sideband_demux(int in, int out, void *data)
|
|
|
|
|
{
|
|
|
|
|
int *xd = data;
|
|
|
|
|
|
|
|
|
|
int ret = recv_sideband("fetch-pack", xd[0], out);
|
|
|
|
|
close(out);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int get_pack(struct fetch_pack_args *args,
|
|
|
|
|
int xd[2], char **pack_lockfile)
|
|
|
|
|
{
|
|
|
|
|
struct async demux;
|
|
|
|
|
int do_keep = args->keep_pack;
|
2015-09-24 23:07:54 +02:00
|
|
|
const char *cmd_name;
|
|
|
|
|
struct pack_header header;
|
|
|
|
|
int pass_header = 0;
|
2014-08-19 21:09:35 +02:00
|
|
|
struct child_process cmd = CHILD_PROCESS_INIT;
|
2013-05-26 03:16:17 +02:00
|
|
|
int ret;
|
2012-10-26 17:53:55 +02:00
|
|
|
|
|
|
|
|
memset(&demux, 0, sizeof(demux));
|
|
|
|
|
if (use_sideband) {
|
|
|
|
|
/* xd[] is talking with upload-pack; subprocess reads from
|
|
|
|
|
* xd[0], spits out band#2 to stderr, and feeds us band#1
|
|
|
|
|
* through demux->out.
|
|
|
|
|
*/
|
|
|
|
|
demux.proc = sideband_demux;
|
|
|
|
|
demux.data = xd;
|
|
|
|
|
demux.out = -1;
|
|
|
|
|
if (start_async(&demux))
|
|
|
|
|
die("fetch-pack: unable to fork off sideband"
|
|
|
|
|
" demultiplexer");
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
demux.out = xd[0];
|
|
|
|
|
|
|
|
|
|
if (!args->keep_pack && unpack_limit) {
|
|
|
|
|
|
|
|
|
|
if (read_pack_header(demux.out, &header))
|
|
|
|
|
die("protocol error: bad pack header");
|
2015-09-24 23:07:54 +02:00
|
|
|
pass_header = 1;
|
2012-10-26 17:53:55 +02:00
|
|
|
if (ntohl(header.hdr_entries) < unpack_limit)
|
|
|
|
|
do_keep = 0;
|
|
|
|
|
else
|
|
|
|
|
do_keep = 1;
|
|
|
|
|
}
|
|
|
|
|
|
2013-05-26 03:16:15 +02:00
|
|
|
if (alternate_shallow_file) {
|
2015-09-24 23:07:54 +02:00
|
|
|
argv_array_push(&cmd.args, "--shallow-file");
|
|
|
|
|
argv_array_push(&cmd.args, alternate_shallow_file);
|
2013-05-26 03:16:15 +02:00
|
|
|
}
|
|
|
|
|
|
2012-10-26 17:53:55 +02:00
|
|
|
if (do_keep) {
|
|
|
|
|
if (pack_lockfile)
|
|
|
|
|
cmd.out = -1;
|
2015-09-24 23:07:54 +02:00
|
|
|
cmd_name = "index-pack";
|
|
|
|
|
argv_array_push(&cmd.args, cmd_name);
|
|
|
|
|
argv_array_push(&cmd.args, "--stdin");
|
2012-10-26 17:53:55 +02:00
|
|
|
if (!args->quiet && !args->no_progress)
|
2015-09-24 23:07:54 +02:00
|
|
|
argv_array_push(&cmd.args, "-v");
|
2012-10-26 17:53:55 +02:00
|
|
|
if (args->use_thin_pack)
|
2015-09-24 23:07:54 +02:00
|
|
|
argv_array_push(&cmd.args, "--fix-thin");
|
2012-10-26 17:53:55 +02:00
|
|
|
if (args->lock_pack || unpack_limit) {
|
2015-09-24 23:07:54 +02:00
|
|
|
char hostname[256];
|
|
|
|
|
if (gethostname(hostname, sizeof(hostname)))
|
|
|
|
|
xsnprintf(hostname, sizeof(hostname), "localhost");
|
|
|
|
|
argv_array_pushf(&cmd.args,
|
|
|
|
|
"--keep=fetch-pack %"PRIuMAX " on %s",
|
|
|
|
|
(uintmax_t)getpid(), hostname);
|
2012-10-26 17:53:55 +02:00
|
|
|
}
|
2013-05-26 03:16:17 +02:00
|
|
|
if (args->check_self_contained_and_connected)
|
2015-09-24 23:07:54 +02:00
|
|
|
argv_array_push(&cmd.args, "--check-self-contained-and-connected");
|
2012-10-26 17:53:55 +02:00
|
|
|
}
|
|
|
|
|
else {
|
2015-09-24 23:07:54 +02:00
|
|
|
cmd_name = "unpack-objects";
|
|
|
|
|
argv_array_push(&cmd.args, cmd_name);
|
2012-10-26 17:53:55 +02:00
|
|
|
if (args->quiet || args->no_progress)
|
2015-09-24 23:07:54 +02:00
|
|
|
argv_array_push(&cmd.args, "-q");
|
2013-05-26 03:16:17 +02:00
|
|
|
args->check_self_contained_and_connected = 0;
|
2012-10-26 17:53:55 +02:00
|
|
|
}
|
2015-09-24 23:07:54 +02:00
|
|
|
|
|
|
|
|
if (pass_header)
|
|
|
|
|
argv_array_pushf(&cmd.args, "--pack_header=%"PRIu32",%"PRIu32,
|
|
|
|
|
ntohl(header.hdr_version),
|
|
|
|
|
ntohl(header.hdr_entries));
|
2012-10-26 17:53:55 +02:00
|
|
|
if (fetch_fsck_objects >= 0
|
|
|
|
|
? fetch_fsck_objects
|
|
|
|
|
: transfer_fsck_objects >= 0
|
|
|
|
|
? transfer_fsck_objects
|
|
|
|
|
: 0)
|
2015-09-24 23:07:54 +02:00
|
|
|
argv_array_push(&cmd.args, "--strict");
|
2012-10-26 17:53:55 +02:00
|
|
|
|
|
|
|
|
cmd.in = demux.out;
|
|
|
|
|
cmd.git_cmd = 1;
|
|
|
|
|
if (start_command(&cmd))
|
2013-09-18 15:41:18 +02:00
|
|
|
die("fetch-pack: unable to fork off %s", cmd_name);
|
2012-10-26 17:53:55 +02:00
|
|
|
if (do_keep && pack_lockfile) {
|
|
|
|
|
*pack_lockfile = index_pack_lockfile(cmd.out);
|
|
|
|
|
close(cmd.out);
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-22 15:36:02 +02:00
|
|
|
if (!use_sideband)
|
|
|
|
|
/* Closed by start_command() */
|
|
|
|
|
xd[0] = -1;
|
|
|
|
|
|
2013-05-26 03:16:17 +02:00
|
|
|
ret = finish_command(&cmd);
|
|
|
|
|
if (!ret || (args->check_self_contained_and_connected && ret == 1))
|
|
|
|
|
args->self_contained_and_connected =
|
|
|
|
|
args->check_self_contained_and_connected &&
|
|
|
|
|
ret == 0;
|
|
|
|
|
else
|
2013-09-18 15:41:18 +02:00
|
|
|
die("%s failed", cmd_name);
|
2012-10-26 17:53:55 +02:00
|
|
|
if (use_sideband && finish_async(&demux))
|
|
|
|
|
die("error in sideband demultiplexer");
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-29 23:02:15 +01:00
|
|
|
static int cmp_ref_by_name(const void *a_, const void *b_)
|
|
|
|
|
{
|
|
|
|
|
const struct ref *a = *((const struct ref **)a_);
|
|
|
|
|
const struct ref *b = *((const struct ref **)b_);
|
|
|
|
|
return strcmp(a->name, b->name);
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-26 17:53:55 +02:00
|
|
|
static struct ref *do_fetch_pack(struct fetch_pack_args *args,
|
|
|
|
|
int fd[2],
|
|
|
|
|
const struct ref *orig_ref,
|
2013-01-29 23:02:15 +01:00
|
|
|
struct ref **sought, int nr_sought,
|
2013-12-05 14:02:39 +01:00
|
|
|
struct shallow_info *si,
|
2012-10-26 17:53:55 +02:00
|
|
|
char **pack_lockfile)
|
|
|
|
|
{
|
|
|
|
|
struct ref *ref = copy_ref_list(orig_ref);
|
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
const char *agent_feature;
|
|
|
|
|
int agent_len;
|
|
|
|
|
|
|
|
|
|
sort_ref_list(&ref, ref_compare_name);
|
2013-01-29 23:02:15 +01:00
|
|
|
qsort(sought, nr_sought, sizeof(*sought), cmp_ref_by_name);
|
2012-10-26 17:53:55 +02:00
|
|
|
|
2015-06-17 13:48:14 +02:00
|
|
|
if ((args->depth > 0 || is_repository_shallow()) && !server_supports("shallow"))
|
2012-10-26 17:53:55 +02:00
|
|
|
die("Server does not support shallow clients");
|
|
|
|
|
if (server_supports("multi_ack_detailed")) {
|
|
|
|
|
if (args->verbose)
|
|
|
|
|
fprintf(stderr, "Server supports multi_ack_detailed\n");
|
|
|
|
|
multi_ack = 2;
|
|
|
|
|
if (server_supports("no-done")) {
|
|
|
|
|
if (args->verbose)
|
|
|
|
|
fprintf(stderr, "Server supports no-done\n");
|
|
|
|
|
if (args->stateless_rpc)
|
|
|
|
|
no_done = 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (server_supports("multi_ack")) {
|
|
|
|
|
if (args->verbose)
|
|
|
|
|
fprintf(stderr, "Server supports multi_ack\n");
|
|
|
|
|
multi_ack = 1;
|
|
|
|
|
}
|
|
|
|
|
if (server_supports("side-band-64k")) {
|
|
|
|
|
if (args->verbose)
|
|
|
|
|
fprintf(stderr, "Server supports side-band-64k\n");
|
|
|
|
|
use_sideband = 2;
|
|
|
|
|
}
|
|
|
|
|
else if (server_supports("side-band")) {
|
|
|
|
|
if (args->verbose)
|
|
|
|
|
fprintf(stderr, "Server supports side-band\n");
|
|
|
|
|
use_sideband = 1;
|
|
|
|
|
}
|
2013-01-29 23:02:15 +01:00
|
|
|
if (server_supports("allow-tip-sha1-in-want")) {
|
|
|
|
|
if (args->verbose)
|
|
|
|
|
fprintf(stderr, "Server supports allow-tip-sha1-in-want\n");
|
2015-05-21 22:23:38 +02:00
|
|
|
allow_unadvertised_object_request |= ALLOW_TIP_SHA1;
|
2013-01-29 23:02:15 +01:00
|
|
|
}
|
2015-05-21 22:23:39 +02:00
|
|
|
if (server_supports("allow-reachable-sha1-in-want")) {
|
|
|
|
|
if (args->verbose)
|
|
|
|
|
fprintf(stderr, "Server supports allow-reachable-sha1-in-want\n");
|
|
|
|
|
allow_unadvertised_object_request |= ALLOW_REACHABLE_SHA1;
|
|
|
|
|
}
|
2012-10-26 17:53:55 +02:00
|
|
|
if (!server_supports("thin-pack"))
|
|
|
|
|
args->use_thin_pack = 0;
|
|
|
|
|
if (!server_supports("no-progress"))
|
|
|
|
|
args->no_progress = 0;
|
|
|
|
|
if (!server_supports("include-tag"))
|
|
|
|
|
args->include_tag = 0;
|
|
|
|
|
if (server_supports("ofs-delta")) {
|
|
|
|
|
if (args->verbose)
|
|
|
|
|
fprintf(stderr, "Server supports ofs-delta\n");
|
|
|
|
|
} else
|
|
|
|
|
prefer_ofs_delta = 0;
|
|
|
|
|
|
|
|
|
|
if ((agent_feature = server_feature_value("agent", &agent_len))) {
|
|
|
|
|
agent_supported = 1;
|
|
|
|
|
if (args->verbose && agent_len)
|
|
|
|
|
fprintf(stderr, "Server version is %.*s\n",
|
|
|
|
|
agent_len, agent_feature);
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-29 23:02:15 +01:00
|
|
|
if (everything_local(args, &ref, sought, nr_sought)) {
|
2012-10-26 17:53:55 +02:00
|
|
|
packet_flush(fd[1]);
|
|
|
|
|
goto all_done;
|
|
|
|
|
}
|
|
|
|
|
if (find_common(args, fd, sha1, ref) < 0)
|
|
|
|
|
if (!args->keep_pack)
|
|
|
|
|
/* When cloning, it is not unusual to have
|
|
|
|
|
* no common commit.
|
|
|
|
|
*/
|
|
|
|
|
warning("no common commits");
|
|
|
|
|
|
|
|
|
|
if (args->stateless_rpc)
|
|
|
|
|
packet_flush(fd[1]);
|
2013-05-26 03:16:15 +02:00
|
|
|
if (args->depth > 0)
|
2013-12-05 14:02:34 +01:00
|
|
|
setup_alternate_shallow(&shallow_lock, &alternate_shallow_file,
|
|
|
|
|
NULL);
|
2013-12-05 14:02:40 +01:00
|
|
|
else if (si->nr_ours || si->nr_theirs)
|
2013-12-05 14:02:39 +01:00
|
|
|
alternate_shallow_file = setup_temporary_shallow(si->shallow);
|
2013-08-26 04:17:26 +02:00
|
|
|
else
|
|
|
|
|
alternate_shallow_file = NULL;
|
2012-10-26 17:53:55 +02:00
|
|
|
if (get_pack(args, fd, pack_lockfile))
|
|
|
|
|
die("git fetch-pack: fetch failed.");
|
|
|
|
|
|
|
|
|
|
all_done:
|
|
|
|
|
return ref;
|
|
|
|
|
}
|
|
|
|
|
|
2014-08-07 18:21:20 +02:00
|
|
|
static void fetch_pack_config(void)
|
2012-10-26 17:53:55 +02:00
|
|
|
{
|
2014-08-07 18:21:20 +02:00
|
|
|
git_config_get_int("fetch.unpacklimit", &fetch_unpack_limit);
|
|
|
|
|
git_config_get_int("transfer.unpacklimit", &transfer_unpack_limit);
|
|
|
|
|
git_config_get_bool("repack.usedeltabaseoffset", &prefer_ofs_delta);
|
|
|
|
|
git_config_get_bool("fetch.fsckobjects", &fetch_fsck_objects);
|
|
|
|
|
git_config_get_bool("transfer.fsckobjects", &transfer_fsck_objects);
|
2012-10-26 17:53:55 +02:00
|
|
|
|
2014-08-07 18:21:20 +02:00
|
|
|
git_config(git_default_config, NULL);
|
2012-10-26 17:53:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void fetch_pack_setup(void)
|
|
|
|
|
{
|
|
|
|
|
static int did_setup;
|
|
|
|
|
if (did_setup)
|
|
|
|
|
return;
|
2014-08-07 18:21:20 +02:00
|
|
|
fetch_pack_config();
|
2012-10-26 17:53:55 +02:00
|
|
|
if (0 <= transfer_unpack_limit)
|
|
|
|
|
unpack_limit = transfer_unpack_limit;
|
|
|
|
|
else if (0 <= fetch_unpack_limit)
|
|
|
|
|
unpack_limit = fetch_unpack_limit;
|
|
|
|
|
did_setup = 1;
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-29 23:02:15 +01:00
|
|
|
static int remove_duplicates_in_refs(struct ref **ref, int nr)
|
|
|
|
|
{
|
|
|
|
|
struct string_list names = STRING_LIST_INIT_NODUP;
|
|
|
|
|
int src, dst;
|
|
|
|
|
|
|
|
|
|
for (src = dst = 0; src < nr; src++) {
|
|
|
|
|
struct string_list_item *item;
|
|
|
|
|
item = string_list_insert(&names, ref[src]->name);
|
|
|
|
|
if (item->util)
|
|
|
|
|
continue; /* already have it */
|
|
|
|
|
item->util = ref[src];
|
|
|
|
|
if (src != dst)
|
|
|
|
|
ref[dst] = ref[src];
|
|
|
|
|
dst++;
|
|
|
|
|
}
|
|
|
|
|
for (src = dst; src < nr; src++)
|
|
|
|
|
ref[src] = NULL;
|
|
|
|
|
string_list_clear(&names, 0);
|
|
|
|
|
return dst;
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-05 14:02:39 +01:00
|
|
|
static void update_shallow(struct fetch_pack_args *args,
|
2013-12-05 14:02:40 +01:00
|
|
|
struct ref **sought, int nr_sought,
|
2013-12-05 14:02:39 +01:00
|
|
|
struct shallow_info *si)
|
2013-12-05 14:02:37 +01:00
|
|
|
{
|
2013-12-05 14:02:40 +01:00
|
|
|
struct sha1_array ref = SHA1_ARRAY_INIT;
|
|
|
|
|
int *status;
|
2013-12-05 14:02:39 +01:00
|
|
|
int i;
|
|
|
|
|
|
2013-12-05 14:02:37 +01:00
|
|
|
if (args->depth > 0 && alternate_shallow_file) {
|
|
|
|
|
if (*alternate_shallow_file == '\0') { /* --unshallow */
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 11:38:57 +02:00
|
|
|
unlink_or_warn(git_path_shallow());
|
2013-12-05 14:02:37 +01:00
|
|
|
rollback_lock_file(&shallow_lock);
|
|
|
|
|
} else
|
|
|
|
|
commit_lock_file(&shallow_lock);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2013-12-05 14:02:39 +01:00
|
|
|
|
|
|
|
|
if (!si->shallow || !si->shallow->nr)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (args->cloning) {
|
|
|
|
|
/*
|
|
|
|
|
* remote is shallow, but this is a clone, there are
|
|
|
|
|
* no objects in repo to worry about. Accept any
|
|
|
|
|
* shallow points that exist in the pack (iow in repo
|
|
|
|
|
* after get_pack() and reprepare_packed_git())
|
|
|
|
|
*/
|
|
|
|
|
struct sha1_array extra = SHA1_ARRAY_INIT;
|
|
|
|
|
unsigned char (*sha1)[20] = si->shallow->sha1;
|
|
|
|
|
for (i = 0; i < si->shallow->nr; i++)
|
|
|
|
|
if (has_sha1_file(sha1[i]))
|
|
|
|
|
sha1_array_append(&extra, sha1[i]);
|
|
|
|
|
if (extra.nr) {
|
|
|
|
|
setup_alternate_shallow(&shallow_lock,
|
|
|
|
|
&alternate_shallow_file,
|
|
|
|
|
&extra);
|
|
|
|
|
commit_lock_file(&shallow_lock);
|
|
|
|
|
}
|
|
|
|
|
sha1_array_clear(&extra);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2013-12-05 14:02:40 +01:00
|
|
|
|
|
|
|
|
if (!si->nr_ours && !si->nr_theirs)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
remove_nonexistent_theirs_shallow(si);
|
|
|
|
|
if (!si->nr_ours && !si->nr_theirs)
|
|
|
|
|
return;
|
|
|
|
|
for (i = 0; i < nr_sought; i++)
|
2015-11-10 03:22:20 +01:00
|
|
|
sha1_array_append(&ref, sought[i]->old_oid.hash);
|
2013-12-05 14:02:40 +01:00
|
|
|
si->ref = &ref;
|
|
|
|
|
|
2013-12-05 14:02:42 +01:00
|
|
|
if (args->update_shallow) {
|
|
|
|
|
/*
|
|
|
|
|
* remote is also shallow, .git/shallow may be updated
|
|
|
|
|
* so all refs can be accepted. Make sure we only add
|
|
|
|
|
* shallow roots that are actually reachable from new
|
|
|
|
|
* refs.
|
|
|
|
|
*/
|
|
|
|
|
struct sha1_array extra = SHA1_ARRAY_INIT;
|
|
|
|
|
unsigned char (*sha1)[20] = si->shallow->sha1;
|
|
|
|
|
assign_shallow_commits_to_refs(si, NULL, NULL);
|
|
|
|
|
if (!si->nr_ours && !si->nr_theirs) {
|
|
|
|
|
sha1_array_clear(&ref);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
for (i = 0; i < si->nr_ours; i++)
|
|
|
|
|
sha1_array_append(&extra, sha1[si->ours[i]]);
|
|
|
|
|
for (i = 0; i < si->nr_theirs; i++)
|
|
|
|
|
sha1_array_append(&extra, sha1[si->theirs[i]]);
|
|
|
|
|
setup_alternate_shallow(&shallow_lock,
|
|
|
|
|
&alternate_shallow_file,
|
|
|
|
|
&extra);
|
|
|
|
|
commit_lock_file(&shallow_lock);
|
|
|
|
|
sha1_array_clear(&extra);
|
|
|
|
|
sha1_array_clear(&ref);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-05 14:02:40 +01:00
|
|
|
/*
|
|
|
|
|
* remote is also shallow, check what ref is safe to update
|
|
|
|
|
* without updating .git/shallow
|
|
|
|
|
*/
|
|
|
|
|
status = xcalloc(nr_sought, sizeof(*status));
|
|
|
|
|
assign_shallow_commits_to_refs(si, NULL, status);
|
|
|
|
|
if (si->nr_ours || si->nr_theirs) {
|
|
|
|
|
for (i = 0; i < nr_sought; i++)
|
|
|
|
|
if (status[i])
|
|
|
|
|
sought[i]->status = REF_STATUS_REJECT_SHALLOW;
|
|
|
|
|
}
|
|
|
|
|
free(status);
|
|
|
|
|
sha1_array_clear(&ref);
|
2013-12-05 14:02:37 +01:00
|
|
|
}
|
|
|
|
|
|
2012-10-26 17:53:55 +02:00
|
|
|
struct ref *fetch_pack(struct fetch_pack_args *args,
|
|
|
|
|
int fd[], struct child_process *conn,
|
|
|
|
|
const struct ref *ref,
|
|
|
|
|
const char *dest,
|
2013-01-29 23:02:15 +01:00
|
|
|
struct ref **sought, int nr_sought,
|
2013-12-05 14:02:39 +01:00
|
|
|
struct sha1_array *shallow,
|
2012-10-26 17:53:55 +02:00
|
|
|
char **pack_lockfile)
|
|
|
|
|
{
|
|
|
|
|
struct ref *ref_cpy;
|
2013-12-05 14:02:39 +01:00
|
|
|
struct shallow_info si;
|
2012-10-26 17:53:55 +02:00
|
|
|
|
|
|
|
|
fetch_pack_setup();
|
2013-01-29 23:02:15 +01:00
|
|
|
if (nr_sought)
|
|
|
|
|
nr_sought = remove_duplicates_in_refs(sought, nr_sought);
|
2012-10-26 17:53:55 +02:00
|
|
|
|
|
|
|
|
if (!ref) {
|
|
|
|
|
packet_flush(fd[1]);
|
|
|
|
|
die("no matching remote head");
|
|
|
|
|
}
|
2013-12-05 14:02:39 +01:00
|
|
|
prepare_shallow_info(&si, shallow);
|
|
|
|
|
ref_cpy = do_fetch_pack(args, fd, ref, sought, nr_sought,
|
|
|
|
|
&si, pack_lockfile);
|
2012-10-26 17:53:55 +02:00
|
|
|
reprepare_packed_git();
|
2013-12-05 14:02:40 +01:00
|
|
|
update_shallow(args, sought, nr_sought, &si);
|
2013-12-05 14:02:39 +01:00
|
|
|
clear_shallow_info(&si);
|
2012-10-26 17:53:55 +02:00
|
|
|
return ref_cpy;
|
|
|
|
|
}
|
