* Re: [RFC/PATCH] define the way new representation types are encoded in the pack
From: Jakub Narebski @ 2011-10-28 13:41 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git, Nicolas Pitre, Shawn O. Pearce, Jeff King
In-Reply-To: <7v62j9veh3.fsf@alter.siamese.dyndns.org>
Junio C Hamano <gitster@pobox.com> writes:
> When bit 4-6 encodes type 5, the first byte is used this way:
>
> - Bit 0-3 denotes the real "extended" representation type. Because types
> 0-7 can already be encoded without using the extended format, we can
> offset the type by 8 (i.e. if bit 0-3 says 3, it means representation
> type 11 = 3 + 8);
Why not use third byte for that instead?
--
Jakub Narębski
^ permalink raw reply
* Re: git alias and --help
From: Jakub Narebski @ 2011-10-28 13:27 UTC (permalink / raw)
To: Gelonida N; +Cc: git, Jakub Narebski
In-Reply-To: <j8ds01$fc7$1@dough.gmane.org>
Gelonida N <gelonida@gmail.com> writes:
[...]
> Another small detail:
>
> Let's assume I have following alias:
>
> log = log --name-status
>
>
> In this case I directly get the help text for git log
> if I typed 'git log --help' (or 'git help log').
> I don't even see, that my log is in reality aliased.
That is because it doesn't work: git does not allow for aliasing its
built-in commands.
--
Jakub Narębski
^ permalink raw reply
* Re: git alias and --help
From: Jakub Narebski @ 2011-10-28 13:26 UTC (permalink / raw)
To: Miles Bader; +Cc: Junio C Hamano, Gelonida N, git, Jakub Narebski
In-Reply-To: <buoty6t9937.fsf@dhlpc061.dev.necel.com>
Miles Bader <miles@gnu.org> writes:
> Junio C Hamano <gitster@pobox.com> writes:
> > > > git branch --help
> > >
> > > How about "git help branch"?
> >
> > The reason why we do not do what you seem to be suggesting is because
> > giving the same behaviour to "git b --help" as "git branch --help" is
> > wrong.
>
> I agree with Gelonida's followup: although what you say makes sense,
> it's still pretty annoying behavior for the very common case of a
> simple renaming alias...
>
> E.g., I have "co" aliased to "checkout", and so my fingers are very
> very inclined to say "co" when I mean checkout... including when
> asking for help. I actually end up typing "git co --help", grumbling,
> and retyping with the full command name, quite reguarly.
>
> What I've often wished is that git's help system would output
> something like:
>
> $ git help co
> `git co' is aliased to `checkout'
>
> Here's the help entry for `checkout':
>
> GIT-CHECKOUT(1) Git Manual GIT-CHECKOUT(1)
Wouldn't it be more useful to say something like this:
$ git co --help
`git co' is aliased to `checkout'
You can see help entry for `checkout' with "git checkout --help"
Then help is only copy'n'paste away.
(This helping text probably should be controlled by some advice.*
config variable).
P.S. I wonder if allowing to run command if you specify unambiguous
prefix would be a good replacement for such aliases?
--
Jakub Narębski
^ permalink raw reply
* Re: Q: "git diff" using tag names
From: Jakub Narebski @ 2011-10-28 13:21 UTC (permalink / raw)
To: Ulrich Windl; +Cc: git, Jakub Narebski
In-Reply-To: <4EAABC15020000A100007D9D@gwsmtp1.uni-regensburg.de>
"Ulrich Windl" <Ulrich.Windl@rz.uni-regensburg.de> writes:
> When using a somewhat older git (of SLES11 SP1 SDK),
Nb. you can check version of git with "git --version".
> I could not
> find a way to "git diff" between two tag names; I can only diff
> between two commit numbers. I can display a changeset using "git
> show", but that's not what I wanted.
>
> Is it possible to get the diff I want using older versions, and is
> such a feature implemented in the current version? If so, since
> when?
From the very beginning in Git you can use tag name where you need
commit identifier; Git would use commit that tag points to (will
dereference or peel a tag).
That is not possible in some [censored] version control systems; I am
looking at you, Subversion!
So if you can do
$ git show v0.9
$ git show v1.0
you can also do
$ git diff v0.9 v1.0
and
$ git log v0.9..v1.0
--
Jakub Narębski
^ permalink raw reply
* Re: [PATCH 00/28] Store references hierarchically in cache
From: Ramkumar Ramachandra @ 2011-10-28 13:07 UTC (permalink / raw)
To: mhagger
Cc: Junio C Hamano, git, Jeff King, Drew Northup, Jakub Narebski,
Heiko Voigt, Johan Herland, Julian Phillips
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
Hi Michael,
Michael Haggerty writes:
> Therefore, this patch series changes the data structure used to store
> the reference cache from a single array of pointers-to-struct into a
> tree-like structure in which each subdirectory of the reference
> namespace is stored as an array of pointers-to-entry and entries can
> be either references or subdirectories containing more references.
Very nice! I like the idea. Can't wait to start reading the series.
> * refs/replace is almost *always* needed even though it often
> doesn't even exist. Thus the presence of many loose references
> slows down *many* git commands for no reason whatsoever.
Was this one of your primary inspirations for writing this series?
> * When a new reference is created, is_refname_available() is called
> to see whether there is another another reference whose name
> conflicts with the new one. Currently this loads and iterates
> through *all* references. But there are only a few refnames that
> can possibly conflict; for example, given the refname
> "refs/heads/foo/bar", the only possible conflicts are with
> "refs/heads/foo" and "refs/heads/foo/bar/*". Therefore it is
> silly to load and iterate through the whole refname hierarchy.
Hm, the original design does sound quite sub-optimal. I suppose it
was written when Git didn't have so many refs in so many
subdirectories.
> * "git for-each-ref" is capable of searching a subtree of the
> references. But currently this causes all references to be
> loaded.
Ah. I was using git for-each-ref to write a filter-branch like thing
earlier, and I was wondering why it was so slow.
> * the time to create a new branch goes from 180 ms to less than 10 ms
> (my test resolution only includes two decimal places) and the time
> to checkout a new branch does the same.
I'm interested in seeing how the callgraph changed. Assuming you used
Valgrind to profile it, could you publish the outputs?
> * the time for a "git filter-branch" of all commits (which used to
> scale like N^2) goes from 4 hours to 13 minutes. (Since
> filter-branch necessarily *creates* lots of loose references, the
> savings are also there if the references are originally packed.)
This is seriously awesome.
> The efficiency gains are such that some operations are now faster with
> loose references than with packed references; however, some operations
> with packed references slow down a bit.
Curiously, why do operations with packed references slow down? (I'll
probably find out in a few minutes after reading the series, but I'm
asking anyway because it it's very non-obvious to me now)
> These changes do not increase the amount of space per reference needed
> for the reference cache, but they do add one similarly-sized entry for
> each subdirectory (for each of loose and packed). I don't think that
> the space increase should be significant in any reasonable situation.
>
> After these changes, there is a benefit to sharding the reference
> namespace, especially for loose references.
Hm, I wonder what this means for Git hosting services.
> Patches 11-24 change most of the internal functions to work with
> "struct ref_entry *" (namely the kind of ref_entry that holds a
> directory of references) instead of "struct ref_dir *". The reason
> for this change it to allow these functions access to the "flag" and
> "name" fields that are stored in ref_entry and thereby avoid having to
> store redundant information in "struct ref_dir" (which would increase
> the size of *every* ref_entry because of its presence in the union).
Hm, I was wondering why the series was looking so intimidating. Is it
not possible to squash all (or atleast some) of these together?
> From: Michael Haggerty <mhagger@alum.mit.edu>
Nit: Can't you configure your email client to put this in the "From: "
header of your emails?
Thanks for the interesting read.
-- Ram
^ permalink raw reply
* Re: Q: "git diff" using tag names
From: Alexey Shumkin @ 2011-10-28 12:59 UTC (permalink / raw)
To: Ulrich Windl; +Cc: git
In-Reply-To: <4EAABC15020000A100007D9D@gwsmtp1.uni-regensburg.de>
Tag is a pointer to a commit (if to say simply)
e.g. in my repo
$ git show-ref --tags --abbrev=7
-->8--
676f194 refs/tags/v2.6.7
b23c481 refs/tags/v2.6.8
-->8--
so
$ git diff v2.6.7..v2.6.8
is equivalent to
$ git diff 676f194..b23c481
etc
> Hi,
>
> when using a somewhat older git (of SLES11 SP1 SDK), I could not find
> a way to "git diff" between two tag names; I can only diff between
> two commit numbers. I can display a changeset using "git show", but
> that's not what I wanted. Is it possible to get the diff I want using
> older versions, and is such a feature implemented in the current
> version? If so, since when?
>
> As I'm not subscribed to the list, I'd appreciate CC'ed replies.
> Thank you.
>
> Greeting
> Ulrich
>
>
^ permalink raw reply
* Q: "git diff" using tag names
From: Ulrich Windl @ 2011-10-28 12:28 UTC (permalink / raw)
To: git
Hi,
when using a somewhat older git (of SLES11 SP1 SDK), I could not find a way to "git diff" between two tag names; I can only diff between two commit numbers. I can display a changeset using "git show", but that's not what I wanted.
Is it possible to get the diff I want using older versions, and is such a feature implemented in the current version? If so, since when?
As I'm not subscribed to the list, I'd appreciate CC'ed replies. Thank you.
Greeting
Ulrich
^ permalink raw reply
* [PATCH 26/28] is_refname_available(): query only possibly-conflicting references
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Instead of iterating through all of the references, inquire more
pointedly about the references that could conflict with the new name.
This requires checking for a few individual references, plus iterating
through a small subtree of the rest of the references (and usually the
subtree iteration ends without having to recurse). A big benefit is
that populating the whole loose reference cache (which can be very
expensive) can usually be avoided.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 40 +++++++++++++++++++++++++++++++++-------
1 files changed, 33 insertions(+), 7 deletions(-)
diff --git a/refs.c b/refs.c
index 88ef9dd..6a7f9c3 100644
--- a/refs.c
+++ b/refs.c
@@ -658,7 +658,7 @@ static int name_conflict_fn(const char *existingrefname, const unsigned char *sh
int flags, void *cb_data)
{
struct name_conflict_cb *data = (struct name_conflict_cb *)cb_data;
- if (data->oldrefname && !strcmp(data->oldrefname, existingrefname))
+ if (!strcmp(data->oldrefname, existingrefname))
return 0;
if (names_conflict(data->refname, existingrefname)) {
data->conflicting_refname = existingrefname;
@@ -669,22 +669,48 @@ static int name_conflict_fn(const char *existingrefname, const unsigned char *sh
/*
* Return true iff a reference named refname could be created without
- * conflicting with the name of an existing reference. If oldrefname
- * is non-NULL, ignore potential conflicts with oldrefname (e.g.,
- * because oldrefname is scheduled for deletion in the same
+ * conflicting with the name of an existing reference in direntry. If
+ * oldrefname is non-NULL, ignore potential conflicts with oldrefname
+ * (e.g., because oldrefname is scheduled for deletion in the same
* operation).
*/
static int is_refname_available(const char *refname, const char *oldrefname,
struct ref_entry *direntry)
{
+ int prefixlen = strlen(refname);
+ char *prefix;
+ char *slash;
struct name_conflict_cb data;
+
+ assert(direntry->flag & REF_DIR);
+
+ if (!oldrefname)
+ oldrefname = ""; /* invalid; cannot match any existing refname */
+
+ /* Check whether a prefix of refname is an existing reference: */
+ prefix = xmalloc(prefixlen + 2);
+ memcpy(prefix, refname, prefixlen + 1);
+ for (slash = strchr(prefix, '/'); slash; slash = strchr(slash + 1, '/')) {
+ *slash = '\0';
+ if (strcmp(oldrefname, prefix)) {
+ struct ref_entry *entry = find_ref(direntry, prefix);
+ if (entry) {
+ error("'%s' exists; cannot create '%s'", prefix, refname);
+ free(prefix);
+ return 0;
+ }
+ }
+ *slash = '/';
+ }
+
+ /* Check whether refname is a proper prefix of an existing reference: */
+ prefix[prefixlen++] = '/';
+ prefix[prefixlen] = '\0';
data.refname = refname;
data.oldrefname = oldrefname;
data.conflicting_refname = NULL;
- assert(direntry->flag & REF_DIR);
-
- if (do_for_each_ref_in_dir(direntry, 0, "", name_conflict_fn,
+ if (do_for_each_ref_in_dir(direntry, 0, prefix, name_conflict_fn,
0, DO_FOR_EACH_INCLUDE_BROKEN,
&data)) {
error("'%s' exists; cannot create '%s'",
--
1.7.7
^ permalink raw reply related
* [PATCH 23/28] struct ref_dir: store a reference to the enclosing ref_cache
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
This means that it contains enough information to serve as the sole
argument to get_ref_dir(), which will be changed in the next commit.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 21 ++++++++++++++++-----
1 files changed, 16 insertions(+), 5 deletions(-)
diff --git a/refs.c b/refs.c
index 98c8569..6b2b2f6 100644
--- a/refs.c
+++ b/refs.c
@@ -143,6 +143,8 @@ struct ref_value {
unsigned char peeled[20];
};
+struct ref_cache;
+
struct ref_dir {
int nr, alloc;
@@ -150,6 +152,12 @@ struct ref_dir {
int sorted;
struct ref_entry **entries;
+
+ /*
+ * A pointer to the ref_cache that contains this ref_dir, or
+ * NULL if this ref_dir is used for extra_refs.
+ */
+ struct ref_cache *ref_cache;
};
/* ISSYMREF=0x01, ISPACKED=0x02, and ISBROKEN=0x04 are public interfaces */
@@ -261,7 +269,8 @@ static void clear_ref_dir(struct ref_dir *dir)
* dirname is the name of the directory with a trailing slash (e.g.,
* "refs/heads/") or "" for the top-level directory.
*/
-static struct ref_entry *create_dir_entry(const char *dirname)
+static struct ref_entry *create_dir_entry(struct ref_cache *ref_cache,
+ const char *dirname)
{
struct ref_entry *direntry;
if (*dirname) {
@@ -275,6 +284,7 @@ static struct ref_entry *create_dir_entry(const char *dirname)
direntry->name[0] = '\0';
}
direntry->flag = REF_DIR;
+ direntry->u.subdir.ref_cache = ref_cache;
return direntry;
}
@@ -354,7 +364,8 @@ static struct ref_entry *find_containing_direntry(struct ref_entry *direntry,
direntry = NULL;
break;
}
- entry = create_dir_entry(refname_copy);
+ entry = create_dir_entry(direntry->u.subdir.ref_cache,
+ refname_copy);
add_entry(direntry, entry);
}
slash[1] = tmp;
@@ -771,7 +782,7 @@ static void read_packed_refs(FILE *f, struct ref_entry *direntry)
void add_extra_ref(const char *refname, const unsigned char *sha1, int flag)
{
if (!extra_refs)
- extra_refs = create_dir_entry("");
+ extra_refs = create_dir_entry(NULL, "");
add_ref(extra_refs, create_ref_entry(refname, sha1, flag));
}
@@ -789,7 +800,7 @@ static struct ref_entry *get_packed_refs(struct ref_cache *refs)
const char *packed_refs_file;
FILE *f;
- refs->packed = create_dir_entry("");
+ refs->packed = create_dir_entry(refs, "");
if (*refs->name)
packed_refs_file = git_path_submodule(refs->name, "packed-refs");
else
@@ -881,7 +892,7 @@ static void get_ref_dir(struct ref_cache *refs, const char *dirname)
static struct ref_entry *get_loose_refs(struct ref_cache *refs)
{
if (!refs->loose) {
- refs->loose = create_dir_entry("");
+ refs->loose = create_dir_entry(refs, "");
get_ref_dir(refs, "refs/");
}
return refs->loose;
--
1.7.7
^ permalink raw reply related
* [PATCH 22/28] sort_ref_dir(): take (ref_entry *) instead of (ref_dir *)
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 16 +++++++++-------
1 files changed, 9 insertions(+), 7 deletions(-)
diff --git a/refs.c b/refs.c
index c3ee93d..98c8569 100644
--- a/refs.c
+++ b/refs.c
@@ -285,7 +285,7 @@ static int ref_entry_cmp(const void *a, const void *b)
return strcmp(one->name, two->name);
}
-static void sort_ref_dir(struct ref_dir *dir);
+static void sort_ref_dir(struct ref_entry *direntry);
/*
* Return the entry with the given refname from the ref_dir
@@ -313,7 +313,7 @@ static struct ref_entry *search_ref_dir(struct ref_entry *direntry, const char *
* references one after the other to a single subdirectory
* doesn't require *any* intermediate sorting.
*/
- sort_ref_dir(dir);
+ sort_ref_dir(direntry);
len = strlen(refname) + 1;
e = xmalloc(sizeof(struct ref_entry) + len);
@@ -424,11 +424,13 @@ static int is_dup_ref(const struct ref_entry *ref1, const struct ref_entry *ref2
* Sort the entries in dir (if they are not already sorted). Sort
* only dir itself, not its subdirectories.
*/
-static void sort_ref_dir(struct ref_dir *dir)
+static void sort_ref_dir(struct ref_entry *direntry)
{
int i, j;
struct ref_entry *last = NULL;
-
+ struct ref_dir *dir;
+ assert(direntry->flag & REF_DIR);
+ dir = &direntry->u.subdir;
if (dir->sorted == dir->nr)
return; /* This directory is already sorted and de-duped */
@@ -479,7 +481,7 @@ static int do_for_each_ref_in_dir(struct ref_entry *direntry, int offset,
struct ref_dir *dir;
assert(direntry->flag & REF_DIR);
dir = &direntry->u.subdir;
- sort_ref_dir(dir);
+ sort_ref_dir(direntry);
for (i = offset; i < dir->nr; i++) {
struct ref_entry *entry = dir->entries[i];
int retval;
@@ -508,8 +510,8 @@ static int do_for_each_ref_in_dirs(struct ref_entry *direntry1,
assert(direntry2->flag & REF_DIR);
dir1 = &direntry1->u.subdir;
dir2 = &direntry2->u.subdir;
- sort_ref_dir(dir1);
- sort_ref_dir(dir2);
+ sort_ref_dir(direntry1);
+ sort_ref_dir(direntry2);
while (1) {
struct ref_entry *e1, *e2, *entry;
int cmp;
--
1.7.7
^ permalink raw reply related
* [PATCH 21/28] do_for_each_ref_in_dir*(): take (ref_entry *) instead of (ref_dir *)
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 38 ++++++++++++++++++++++----------------
1 files changed, 22 insertions(+), 16 deletions(-)
diff --git a/refs.c b/refs.c
index 3567d56..c3ee93d 100644
--- a/refs.c
+++ b/refs.c
@@ -471,17 +471,20 @@ static int do_one_ref(const char *base, each_ref_fn fn, int trim,
return fn(entry->name + trim, entry->u.value.sha1, entry->flag, cb_data);
}
-static int do_for_each_ref_in_dir(struct ref_dir *dir, int offset,
+static int do_for_each_ref_in_dir(struct ref_entry *direntry, int offset,
const char *base,
each_ref_fn fn, int trim, int flags, void *cb_data)
{
int i;
+ struct ref_dir *dir;
+ assert(direntry->flag & REF_DIR);
+ dir = &direntry->u.subdir;
sort_ref_dir(dir);
for (i = offset; i < dir->nr; i++) {
struct ref_entry *entry = dir->entries[i];
int retval;
if (entry->flag & REF_DIR) {
- retval = do_for_each_ref_in_dir(&entry->u.subdir, 0,
+ retval = do_for_each_ref_in_dir(entry, 0,
base, fn, trim, flags, cb_data);
} else {
retval = do_one_ref(base, fn, trim, flags, cb_data, entry);
@@ -492,25 +495,30 @@ static int do_for_each_ref_in_dir(struct ref_dir *dir, int offset,
return 0;
}
-static int do_for_each_ref_in_dirs(struct ref_dir *dir1,
- struct ref_dir *dir2,
+static int do_for_each_ref_in_dirs(struct ref_entry *direntry1,
+ struct ref_entry *direntry2,
const char *base, each_ref_fn fn, int trim,
int flags, void *cb_data)
{
int retval;
int i1 = 0, i2 = 0;
+ struct ref_dir *dir1, *dir2;
+ assert(direntry1->flag & REF_DIR);
+ assert(direntry2->flag & REF_DIR);
+ dir1 = &direntry1->u.subdir;
+ dir2 = &direntry2->u.subdir;
sort_ref_dir(dir1);
sort_ref_dir(dir2);
while (1) {
struct ref_entry *e1, *e2, *entry;
int cmp;
if (i1 == dir1->nr) {
- return do_for_each_ref_in_dir(dir2, i2,
+ return do_for_each_ref_in_dir(direntry2, i2,
base, fn, trim, flags, cb_data);
}
if (i2 == dir2->nr) {
- return do_for_each_ref_in_dir(dir1, i1,
+ return do_for_each_ref_in_dir(direntry1, i1,
base, fn, trim, flags, cb_data);
}
e1 = dir1->entries[i1];
@@ -520,7 +528,7 @@ static int do_for_each_ref_in_dirs(struct ref_dir *dir1,
if ((e1->flag & REF_DIR) && (e2->flag & REF_DIR)) {
/* Both are directories; descend them in parallel. */
retval = do_for_each_ref_in_dirs(
- &e1->u.subdir, &e2->u.subdir,
+ e1, e2,
base, fn, trim, flags, cb_data);
i1++;
i2++;
@@ -543,7 +551,7 @@ static int do_for_each_ref_in_dirs(struct ref_dir *dir1,
}
if (entry->flag & REF_DIR) {
retval = do_for_each_ref_in_dir(
- &entry->u.subdir, 0,
+ entry, 0,
base, fn, trim, flags, cb_data);
} else {
retval = do_one_ref(base, fn, trim, flags, cb_data, entry);
@@ -605,7 +613,7 @@ static int is_refname_available(const char *refname, const char *oldrefname,
assert(direntry->flag & REF_DIR);
- if (do_for_each_ref_in_dir(&direntry->u.subdir, 0, "", name_conflict_fn,
+ if (do_for_each_ref_in_dir(direntry, 0, "", name_conflict_fn,
0, DO_FOR_EACH_INCLUDE_BROKEN,
&data)) {
error("'%s' exists; cannot create '%s'",
@@ -1196,21 +1204,20 @@ static int do_for_each_ref(const char *submodule, const char *base, each_ref_fn
if (extra_direntry)
retval = do_for_each_ref_in_dir(
- &extra_direntry->u.subdir, 0,
+ extra_direntry, 0,
base, fn, trim, flags, cb_data);
if (!retval) {
if (packed_direntry && loose_direntry)
retval = do_for_each_ref_in_dirs(
- &packed_direntry->u.subdir,
- &loose_direntry->u.subdir,
+ packed_direntry, loose_direntry,
base, fn, trim, flags, cb_data);
else if (packed_direntry)
retval = do_for_each_ref_in_dir(
- &packed_direntry->u.subdir, 0,
+ packed_direntry, 0,
base, fn, trim, flags, cb_data);
else if (loose_direntry)
retval = do_for_each_ref_in_dir(
- &loose_direntry->u.subdir, 0,
+ loose_direntry, 0,
base, fn, trim, flags, cb_data);
}
@@ -1668,8 +1675,7 @@ static int repack_without_ref(const char *refname)
unable_to_lock_error(git_path("packed-refs"), errno);
return error("cannot delete '%s' from packed refs", refname);
}
- do_for_each_ref_in_dir(&packed->u.subdir, 0,
- "", repack_without_ref_fn, 0, 0, &data);
+ do_for_each_ref_in_dir(packed, 0, "", repack_without_ref_fn, 0, 0, &data);
return commit_lock_file(&packlock);
}
--
1.7.7
^ permalink raw reply related
* [PATCH 20/28] add_entry(): take (ref_entry *) instead of (ref_dir *)
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 12 +++++++-----
1 files changed, 7 insertions(+), 5 deletions(-)
diff --git a/refs.c b/refs.c
index e91cc15..3567d56 100644
--- a/refs.c
+++ b/refs.c
@@ -234,8 +234,11 @@ static void free_ref_entry(struct ref_entry *entry)
* stored directly in dir; no recursion into subdirectories is
* done.
*/
-static void add_entry_to_dir(struct ref_dir *dir, struct ref_entry *entry)
+static void add_entry(struct ref_entry *direntry, struct ref_entry *entry)
{
+ struct ref_dir *dir;
+ assert(direntry->flag & REF_DIR);
+ dir = &direntry->u.subdir;
ALLOC_GROW(dir->entries, dir->nr + 1, dir->alloc);
dir->entries[dir->nr++] = entry;
}
@@ -352,7 +355,7 @@ static struct ref_entry *find_containing_direntry(struct ref_entry *direntry,
break;
}
entry = create_dir_entry(refname_copy);
- add_entry_to_dir(&direntry->u.subdir, entry);
+ add_entry(direntry, entry);
}
slash[1] = tmp;
assert(entry->flag & REF_DIR);
@@ -390,7 +393,7 @@ static int add_ref(struct ref_entry *direntry, struct ref_entry *ref)
direntry = find_containing_direntry(direntry, ref->name, 1);
if (!direntry)
return -1;
- add_entry_to_dir(&direntry->u.subdir, ref);
+ add_entry(direntry, ref);
return 0;
}
@@ -858,8 +861,7 @@ static void get_ref_dir(struct ref_cache *refs, const char *dirname)
hashclr(sha1);
flag |= REF_ISBROKEN;
}
- add_entry_to_dir(&direntry->u.subdir,
- create_ref_entry(refname, sha1, flag));
+ add_entry(direntry, create_ref_entry(refname, sha1, flag));
}
free(refname);
closedir(d);
--
1.7.7
^ permalink raw reply related
* [PATCH 15/28] find_ref(): take (ref_entry *) instead of (ref_dir *)
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 14 ++++++++------
1 files changed, 8 insertions(+), 6 deletions(-)
diff --git a/refs.c b/refs.c
index 6bda033..e7d4482 100644
--- a/refs.c
+++ b/refs.c
@@ -363,10 +363,12 @@ static struct ref_dir *find_containing_dir(struct ref_dir *dir,
* subdirectories as necessary. If the name is not found or it
* corresponds to a directory entry, return NULL.
*/
-static struct ref_entry *find_ref(struct ref_dir *dir, const char *refname)
+static struct ref_entry *find_ref(struct ref_entry *direntry, const char *refname)
{
struct ref_entry *entry;
- dir = find_containing_dir(dir, refname, 0);
+ struct ref_dir *dir;
+ assert(direntry->flag & REF_DIR);
+ dir = find_containing_dir(&direntry->u.subdir, refname, 0);
if (!dir)
return NULL;
entry = search_ref_dir(dir, refname);
@@ -881,7 +883,7 @@ static int resolve_gitlink_packed_ref(struct ref_cache *refs,
struct ref_entry *ref;
struct ref_entry *direntry = get_packed_refs(refs);
- ref = find_ref(&direntry->u.subdir, refname);
+ ref = find_ref(direntry, refname);
if (ref == NULL)
return -1;
@@ -953,7 +955,7 @@ int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sh
static int get_packed_ref(const char *refname, unsigned char *sha1)
{
struct ref_entry *packed = get_packed_refs(get_ref_cache(NULL));
- struct ref_entry *entry = find_ref(&packed->u.subdir, refname);
+ struct ref_entry *entry = find_ref(packed, refname);
if (entry) {
hashcpy(sha1, entry->u.value.sha1);
return 0;
@@ -1113,7 +1115,7 @@ int peel_ref(const char *refname, unsigned char *sha1)
if ((flag & REF_ISPACKED)) {
struct ref_entry *direntry = get_packed_refs(get_ref_cache(NULL));
- struct ref_entry *r = find_ref(&direntry->u.subdir, refname);
+ struct ref_entry *r = find_ref(direntry, refname);
if (r != NULL && r->flag & REF_KNOWS_PEELED) {
hashcpy(sha1, r->u.value.peeled);
@@ -1650,7 +1652,7 @@ static int repack_without_ref(const char *refname)
{
struct repack_without_ref_sb data;
struct ref_entry *packed = get_packed_refs(get_ref_cache(NULL));
- if (find_ref(&packed->u.subdir, refname) == NULL)
+ if (find_ref(packed, refname) == NULL)
return 0;
data.refname = refname;
data.fd = hold_lock_file_for_update(&packlock, git_path("packed-refs"), 0);
--
1.7.7
^ permalink raw reply related
* [PATCH 14/28] is_refname_available(): take (ref_entry *) instead of (ref_dir *)
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 12 +++++++-----
1 files changed, 7 insertions(+), 5 deletions(-)
diff --git a/refs.c b/refs.c
index d6d5d0e..6bda033 100644
--- a/refs.c
+++ b/refs.c
@@ -586,14 +586,16 @@ static int name_conflict_fn(const char *existingrefname, const unsigned char *sh
* operation).
*/
static int is_refname_available(const char *refname, const char *oldrefname,
- struct ref_dir *dir)
+ struct ref_entry *direntry)
{
struct name_conflict_cb data;
data.refname = refname;
data.oldrefname = oldrefname;
data.conflicting_refname = NULL;
- if (do_for_each_ref_in_dir(dir, 0, "", name_conflict_fn,
+ assert(direntry->flag & REF_DIR);
+
+ if (do_for_each_ref_in_dir(&direntry->u.subdir, 0, "", name_conflict_fn,
0, DO_FOR_EACH_INCLUDE_BROKEN,
&data)) {
error("'%s' exists; cannot create '%s'",
@@ -1567,7 +1569,7 @@ static struct ref_lock *lock_ref_sha1_basic(const char *refname,
*/
if (missing &&
!is_refname_available(refname, NULL,
- &get_packed_refs(get_ref_cache(NULL))->u.subdir)) {
+ get_packed_refs(get_ref_cache(NULL)))) {
last_errno = ENOTDIR;
goto error_return;
}
@@ -1728,10 +1730,10 @@ int rename_ref(const char *oldrefname, const char *newrefname, const char *logms
if (!symref)
return error("refname %s not found", oldrefname);
- if (!is_refname_available(newrefname, oldrefname, &get_packed_refs(refs)->u.subdir))
+ if (!is_refname_available(newrefname, oldrefname, get_packed_refs(refs)))
return 1;
- if (!is_refname_available(newrefname, oldrefname, &get_loose_refs(refs)->u.subdir))
+ if (!is_refname_available(newrefname, oldrefname, get_loose_refs(refs)))
return 1;
if (log && rename(git_path("logs/%s", oldrefname), git_path(TMP_RENAMED_LOG)))
--
1.7.7
^ permalink raw reply related
* [PATCH 13/28] get_loose_refs(): return (ref_entry *) instead of (ref_dir *)
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 9 +++++----
1 files changed, 5 insertions(+), 4 deletions(-)
diff --git a/refs.c b/refs.c
index 425fdaa..d6d5d0e 100644
--- a/refs.c
+++ b/refs.c
@@ -855,13 +855,13 @@ static void get_ref_dir(struct ref_cache *refs, const char *dirname)
}
}
-static struct ref_dir *get_loose_refs(struct ref_cache *refs)
+static struct ref_entry *get_loose_refs(struct ref_cache *refs)
{
if (!refs->loose) {
refs->loose = create_dir_entry("");
get_ref_dir(refs, "refs/");
}
- return &refs->loose->u.subdir;
+ return refs->loose;
}
/* We allow "recursive" symbolic refs. Only within reason, though */
@@ -1173,7 +1173,8 @@ static int do_for_each_ref(const char *submodule, const char *base, each_ref_fn
struct ref_dir *extra_dir = extra_refs ? &extra_refs->u.subdir : NULL;
struct ref_entry *packed_direntry = get_packed_refs(refs);
struct ref_dir *packed_dir = &packed_direntry->u.subdir;
- struct ref_dir *loose_dir = get_loose_refs(refs);
+ struct ref_entry *loose_direntry = get_loose_refs(refs);
+ struct ref_dir *loose_dir = &loose_direntry->u.subdir;
if (base && *base) {
if (extra_dir)
@@ -1730,7 +1731,7 @@ int rename_ref(const char *oldrefname, const char *newrefname, const char *logms
if (!is_refname_available(newrefname, oldrefname, &get_packed_refs(refs)->u.subdir))
return 1;
- if (!is_refname_available(newrefname, oldrefname, get_loose_refs(refs)))
+ if (!is_refname_available(newrefname, oldrefname, &get_loose_refs(refs)->u.subdir))
return 1;
if (log && rename(git_path("logs/%s", oldrefname), git_path(TMP_RENAMED_LOG)))
--
1.7.7
^ permalink raw reply related
* [PATCH 17/28] add_ref(): take (ref_entry *) instead of (ref_dir *)
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 10 ++++++----
1 files changed, 6 insertions(+), 4 deletions(-)
diff --git a/refs.c b/refs.c
index f402d39..f5aaafe 100644
--- a/refs.c
+++ b/refs.c
@@ -380,9 +380,11 @@ static struct ref_entry *find_ref(struct ref_entry *direntry, const char *refnam
* subdirectories as necessary. dir must represent the top-level
* directory. Return 0 on success.
*/
-static int add_ref(struct ref_dir *dir, struct ref_entry *ref)
+static int add_ref(struct ref_entry *direntry, struct ref_entry *ref)
{
- dir = find_containing_dir(dir, ref->name, 1);
+ struct ref_dir *dir;
+ assert(direntry->flag & REF_DIR);
+ dir = find_containing_dir(&direntry->u.subdir, ref->name, 1);
if (!dir)
return -1;
add_entry_to_dir(dir, ref);
@@ -738,7 +740,7 @@ static void read_packed_refs(FILE *f, struct ref_entry *direntry)
refname = parse_ref_line(refline, sha1);
if (refname) {
last = create_ref_entry(refname, sha1, flag);
- add_ref(&direntry->u.subdir, last);
+ add_ref(direntry, last);
continue;
}
if (last &&
@@ -754,7 +756,7 @@ void add_extra_ref(const char *refname, const unsigned char *sha1, int flag)
{
if (!extra_refs)
extra_refs = create_dir_entry("");
- add_ref(&extra_refs->u.subdir, create_ref_entry(refname, sha1, flag));
+ add_ref(extra_refs, create_ref_entry(refname, sha1, flag));
}
void clear_extra_refs(void)
--
1.7.7
^ permalink raw reply related
* [PATCH 11/28] refs: wrap top-level ref_dirs in ref_entries
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Wrap the top-level ref_dirs in REF_DIR style ref_entries so that we
have the flag and name available when dealing with them. This
affects:
* cache_ref::loose
* cache_ref::packed
* extra_refs
The next several commits will expand the use of ref_entry as opposed
to ref_dir, culminating in the ability of a ref_entry representing a
directory of loose references to load itself only when used.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 54 ++++++++++++++++++++++++++++++------------------------
1 files changed, 30 insertions(+), 24 deletions(-)
diff --git a/refs.c b/refs.c
index bdd90c5..673fa04 100644
--- a/refs.c
+++ b/refs.c
@@ -256,7 +256,7 @@ static void clear_ref_dir(struct ref_dir *dir)
/*
* Create a struct ref_entry object for the specified dirname.
* dirname is the name of the directory with a trailing slash (e.g.,
- * "refs/heads/").
+ * "refs/heads/") or "" for the top-level directory.
*/
static struct ref_entry *create_dir_entry(const char *dirname)
{
@@ -609,28 +609,28 @@ static int is_refname_available(const char *refname, const char *oldrefname,
*/
static struct ref_cache {
struct ref_cache *next;
- char did_loose;
- char did_packed;
- struct ref_dir loose;
- struct ref_dir packed;
+ struct ref_entry *loose;
+ struct ref_entry *packed;
/* The submodule name, or "" for the main repo. */
char name[FLEX_ARRAY];
} *ref_cache;
-static struct ref_dir extra_refs;
+static struct ref_entry *extra_refs;
static void clear_packed_ref_cache(struct ref_cache *refs)
{
- if (refs->did_packed)
- clear_ref_dir(&refs->packed);
- refs->did_packed = 0;
+ if (refs->packed) {
+ free_ref_entry(refs->packed);
+ refs->packed = NULL;
+ }
}
static void clear_loose_ref_cache(struct ref_cache *refs)
{
- if (refs->did_loose)
- clear_ref_dir(&refs->loose);
- refs->did_loose = 0;
+ if (refs->loose) {
+ free_ref_entry(refs->loose);
+ refs->loose = NULL;
+ }
}
static struct ref_cache *create_ref_cache(const char *submodule)
@@ -747,32 +747,37 @@ static void read_packed_refs(FILE *f, struct ref_dir *dir)
void add_extra_ref(const char *refname, const unsigned char *sha1, int flag)
{
- add_ref(&extra_refs, create_ref_entry(refname, sha1, flag));
+ if (!extra_refs)
+ extra_refs = create_dir_entry("");
+ add_ref(&extra_refs->u.subdir, create_ref_entry(refname, sha1, flag));
}
void clear_extra_refs(void)
{
- clear_ref_dir(&extra_refs);
+ if (extra_refs) {
+ free_ref_entry(extra_refs);
+ extra_refs = NULL;
+ }
}
static struct ref_dir *get_packed_refs(struct ref_cache *refs)
{
- if (!refs->did_packed) {
+ if (!refs->packed) {
const char *packed_refs_file;
FILE *f;
+ refs->packed = create_dir_entry("");
if (*refs->name)
packed_refs_file = git_path_submodule(refs->name, "packed-refs");
else
packed_refs_file = git_path("packed-refs");
f = fopen(packed_refs_file, "r");
if (f) {
- read_packed_refs(f, &refs->packed);
+ read_packed_refs(f, &refs->packed->u.subdir);
fclose(f);
}
- refs->did_packed = 1;
}
- return &refs->packed;
+ return &refs->packed->u.subdir;
}
/*
@@ -789,7 +794,7 @@ static void get_ref_dir(struct ref_cache *refs, const char *dirname)
assert(dirnamelen && dirname[dirnamelen - 1] == '/');
- dir = find_containing_dir(&refs->loose, dirname, 1);
+ dir = find_containing_dir(&refs->loose->u.subdir, dirname, 1);
if (*refs->name)
path = git_path_submodule(refs->name, "%s", dirname);
@@ -852,11 +857,11 @@ static void get_ref_dir(struct ref_cache *refs, const char *dirname)
static struct ref_dir *get_loose_refs(struct ref_cache *refs)
{
- if (!refs->did_loose) {
+ if (!refs->loose) {
+ refs->loose = create_dir_entry("");
get_ref_dir(refs, "refs/");
- refs->did_loose = 1;
}
- return &refs->loose;
+ return &refs->loose->u.subdir;
}
/* We allow "recursive" symbolic refs. Only within reason, though */
@@ -1165,12 +1170,13 @@ static int do_for_each_ref(const char *submodule, const char *base, each_ref_fn
{
int retval = 0;
struct ref_cache *refs = get_ref_cache(submodule);
- struct ref_dir *extra_dir = &extra_refs;
+ struct ref_dir *extra_dir = extra_refs ? &extra_refs->u.subdir : NULL;
struct ref_dir *packed_dir = get_packed_refs(refs);
struct ref_dir *loose_dir = get_loose_refs(refs);
if (base && *base) {
- extra_dir = find_containing_dir(extra_dir, base, 0);
+ if (extra_dir)
+ extra_dir = find_containing_dir(extra_dir, base, 0);
packed_dir = find_containing_dir(packed_dir, base, 0);
loose_dir = find_containing_dir(loose_dir, base, 0);
}
--
1.7.7
^ permalink raw reply related
* [PATCH 10/28] get_ref_dir(): keep track of the current ref_dir
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Look up the ref_dir that will hold the new entries once at the start
of processing of a directory. This eliminates the need to search down
the reference tree to find the place to put each new reference.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 43 ++++++++++++++++++++++++++-----------------
1 files changed, 26 insertions(+), 17 deletions(-)
diff --git a/refs.c b/refs.c
index 515b44c..bdd90c5 100644
--- a/refs.c
+++ b/refs.c
@@ -775,29 +775,36 @@ static struct ref_dir *get_packed_refs(struct ref_cache *refs)
return &refs->packed;
}
-static void get_ref_dir(struct ref_cache *refs, const char *base,
- struct ref_dir *dir)
+/*
+ * dirname must match the name associated with dir; in particular, it
+ * must end with '/'.
+ */
+static void get_ref_dir(struct ref_cache *refs, const char *dirname)
{
DIR *d;
- const char *path;
+ char *path;
+ int dirnamelen = strlen(dirname);
+ int pathlen;
+ struct ref_dir *dir;
+
+ assert(dirnamelen && dirname[dirnamelen - 1] == '/');
+
+ dir = find_containing_dir(&refs->loose, dirname, 1);
if (*refs->name)
- path = git_path_submodule(refs->name, "%s", base);
+ path = git_path_submodule(refs->name, "%s", dirname);
else
- path = git_path("%s", base);
-
+ path = git_path("%s", dirname);
+ pathlen = strlen(path);
+ assert(pathlen && path[pathlen - 1] == '/');
+ path[pathlen - 1] = '\0';
d = opendir(path);
if (d) {
struct dirent *de;
- int baselen = strlen(base);
- char *refname = xmalloc(baselen + 257);
-
- memcpy(refname, base, baselen);
- if (baselen && base[baselen-1] != '/')
- refname[baselen++] = '/';
-
+ char *refname = xmalloc(dirnamelen + 257);
+ memcpy(refname, dirname, dirnamelen);
while ((de = readdir(d)) != NULL) {
unsigned char sha1[20];
struct stat st;
@@ -812,14 +819,16 @@ static void get_ref_dir(struct ref_cache *refs, const char *base,
continue;
if (has_extension(de->d_name, ".lock"))
continue;
- memcpy(refname + baselen, de->d_name, namelen+1);
+ memcpy(refname + dirnamelen, de->d_name, namelen+1);
refdir = *refs->name
? git_path_submodule(refs->name, "%s", refname)
: git_path("%s", refname);
if (stat(refdir, &st) < 0)
continue;
if (S_ISDIR(st.st_mode)) {
- get_ref_dir(refs, refname, dir);
+ refname[dirnamelen + namelen] = '/';
+ refname[dirnamelen + namelen + 1] = '\0';
+ get_ref_dir(refs, refname);
continue;
}
if (*refs->name) {
@@ -834,7 +843,7 @@ static void get_ref_dir(struct ref_cache *refs, const char *base,
hashclr(sha1);
flag |= REF_ISBROKEN;
}
- add_ref(dir, create_ref_entry(refname, sha1, flag));
+ add_entry_to_dir(dir, create_ref_entry(refname, sha1, flag));
}
free(refname);
closedir(d);
@@ -844,7 +853,7 @@ static void get_ref_dir(struct ref_cache *refs, const char *base,
static struct ref_dir *get_loose_refs(struct ref_cache *refs)
{
if (!refs->did_loose) {
- get_ref_dir(refs, "refs", &refs->loose);
+ get_ref_dir(refs, "refs/");
refs->did_loose = 1;
}
return &refs->loose;
--
1.7.7
^ permalink raw reply related
* [PATCH 18/28] find_containing_direntry(): use (ref_entry *) instead of (ref_dir *)
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Change type of both argument and return value.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 78 ++++++++++++++++++++++++++++++++--------------------------------
1 files changed, 39 insertions(+), 39 deletions(-)
diff --git a/refs.c b/refs.c
index f5aaafe..35b3ff2 100644
--- a/refs.c
+++ b/refs.c
@@ -324,38 +324,40 @@ static struct ref_entry *search_ref_dir(struct ref_dir *dir, const char *refname
}
/*
- * If refname is a reference name, find the ref_dir within the dir
+ * If refname is a reference name, find the ref_entry within the dir
* tree that should hold refname. If refname is a directory name
- * (i.e., ends in '/'), then return that ref_dir itself. dir must
- * represent the top-level directory. Recurse into subdirectories as
- * necessary. If mkdir is set, then create any missing directories;
- * otherwise, return NULL if the desired directory cannot be found.
+ * (i.e., "" or ends in '/'), then return that ref_entry itself. dir
+ * must represent the top-level directory. Recurse into
+ * subdirectories as necessary. If mkdir is set, then create any
+ * missing directories; otherwise, return NULL if the desired
+ * directory cannot be found.
*/
-static struct ref_dir *find_containing_dir(struct ref_dir *dir,
- const char *refname, int mkdir)
+static struct ref_entry *find_containing_direntry(struct ref_entry *direntry,
+ const char *refname, int mkdir)
{
char *refname_copy = xstrdup(refname);
char *slash;
- struct ref_entry *entry;
+ assert(direntry->flag & REF_DIR);
for (slash = strchr(refname_copy, '/'); slash; slash = strchr(slash + 1, '/')) {
char tmp = slash[1];
+ struct ref_entry *entry;
slash[1] = '\0';
- entry = search_ref_dir(dir, refname_copy);
+ entry = search_ref_dir(&direntry->u.subdir, refname_copy);
if (!entry) {
if (!mkdir) {
- dir = NULL;
+ direntry = NULL;
break;
}
entry = create_dir_entry(refname_copy);
- add_entry_to_dir(dir, entry);
+ add_entry_to_dir(&direntry->u.subdir, entry);
}
slash[1] = tmp;
assert(entry->flag & REF_DIR);
- dir = &entry->u.subdir;
+ direntry = entry;
}
free(refname_copy);
- return dir;
+ return direntry;
}
/*
@@ -366,12 +368,11 @@ static struct ref_dir *find_containing_dir(struct ref_dir *dir,
static struct ref_entry *find_ref(struct ref_entry *direntry, const char *refname)
{
struct ref_entry *entry;
- struct ref_dir *dir;
assert(direntry->flag & REF_DIR);
- dir = find_containing_dir(&direntry->u.subdir, refname, 0);
- if (!dir)
+ direntry = find_containing_direntry(direntry, refname, 0);
+ if (!direntry)
return NULL;
- entry = search_ref_dir(dir, refname);
+ entry = search_ref_dir(&direntry->u.subdir, refname);
return (entry && !(entry->flag & REF_DIR)) ? entry : NULL;
}
@@ -382,12 +383,11 @@ static struct ref_entry *find_ref(struct ref_entry *direntry, const char *refnam
*/
static int add_ref(struct ref_entry *direntry, struct ref_entry *ref)
{
- struct ref_dir *dir;
assert(direntry->flag & REF_DIR);
- dir = find_containing_dir(&direntry->u.subdir, ref->name, 1);
- if (!dir)
+ direntry = find_containing_direntry(direntry, ref->name, 1);
+ if (!direntry)
return -1;
- add_entry_to_dir(dir, ref);
+ add_entry_to_dir(&direntry->u.subdir, ref);
return 0;
}
@@ -797,11 +797,11 @@ static void get_ref_dir(struct ref_cache *refs, const char *dirname)
char *path;
int dirnamelen = strlen(dirname);
int pathlen;
- struct ref_dir *dir;
+ struct ref_entry *direntry;
assert(dirnamelen && dirname[dirnamelen - 1] == '/');
- dir = find_containing_dir(&refs->loose->u.subdir, dirname, 1);
+ direntry = find_containing_direntry(refs->loose, dirname, 1);
if (*refs->name)
path = git_path_submodule(refs->name, "%s", dirname);
@@ -855,7 +855,8 @@ static void get_ref_dir(struct ref_cache *refs, const char *dirname)
hashclr(sha1);
flag |= REF_ISBROKEN;
}
- add_entry_to_dir(dir, create_ref_entry(refname, sha1, flag));
+ add_entry_to_dir(&direntry->u.subdir,
+ create_ref_entry(refname, sha1, flag));
}
free(refname);
closedir(d);
@@ -1177,35 +1178,34 @@ static int do_for_each_ref(const char *submodule, const char *base, each_ref_fn
{
int retval = 0;
struct ref_cache *refs = get_ref_cache(submodule);
- struct ref_dir *extra_dir = extra_refs ? &extra_refs->u.subdir : NULL;
+ struct ref_entry *extra_direntry = extra_refs;
struct ref_entry *packed_direntry = get_packed_refs(refs);
- struct ref_dir *packed_dir = &packed_direntry->u.subdir;
struct ref_entry *loose_direntry = get_loose_refs(refs);
- struct ref_dir *loose_dir = &loose_direntry->u.subdir;
if (base && *base) {
- if (extra_dir)
- extra_dir = find_containing_dir(extra_dir, base, 0);
- packed_dir = find_containing_dir(packed_dir, base, 0);
- loose_dir = find_containing_dir(loose_dir, base, 0);
+ if (extra_direntry)
+ extra_direntry = find_containing_direntry(extra_direntry, base, 0);
+ packed_direntry = find_containing_direntry(packed_direntry, base, 0);
+ loose_direntry = find_containing_direntry(loose_direntry, base, 0);
}
- if (extra_dir)
+ if (extra_direntry)
retval = do_for_each_ref_in_dir(
- extra_dir, 0,
+ &extra_direntry->u.subdir, 0,
base, fn, trim, flags, cb_data);
if (!retval) {
- if (packed_dir && loose_dir)
+ if (packed_direntry && loose_direntry)
retval = do_for_each_ref_in_dirs(
- packed_dir, loose_dir,
+ &packed_direntry->u.subdir,
+ &loose_direntry->u.subdir,
base, fn, trim, flags, cb_data);
- else if (packed_dir)
+ else if (packed_direntry)
retval = do_for_each_ref_in_dir(
- packed_dir, 0,
+ &packed_direntry->u.subdir, 0,
base, fn, trim, flags, cb_data);
- else if (loose_dir)
+ else if (loose_direntry)
retval = do_for_each_ref_in_dir(
- loose_dir, 0,
+ &loose_direntry->u.subdir, 0,
base, fn, trim, flags, cb_data);
}
--
1.7.7
^ permalink raw reply related
* [PATCH 27/28] read_packed_refs(): keep track of the directory being worked in
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Packed references are stored in $GIT_DIR/packed-refs sorted, so
adjacent ones are pretty likely to be in the same directory. So while
reading them, keep track of the last directory used, and reuse it if
possible to avoid searching the reference namespace from the root each
time.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 16 +++++++++++++++-
1 files changed, 15 insertions(+), 1 deletions(-)
diff --git a/refs.c b/refs.c
index 6a7f9c3..6a19d19 100644
--- a/refs.c
+++ b/refs.c
@@ -831,6 +831,7 @@ static const char *parse_ref_line(char *line, unsigned char *sha1)
static void read_packed_refs(FILE *f, struct ref_entry *direntry)
{
struct ref_entry *last = NULL;
+ struct ref_entry *current_direntry = NULL;
char refline[PATH_MAX];
int flag = REF_ISPACKED;
@@ -850,8 +851,21 @@ static void read_packed_refs(FILE *f, struct ref_entry *direntry)
refname = parse_ref_line(refline, sha1);
if (refname) {
+ if (current_direntry) {
+ char *slash = strrchr(refname, '/');
+ if (!slash
+ || strncmp(current_direntry->name, refname,
+ slash - refname + 1)
+ || current_direntry->name[slash - refname + 1] != '\0')
+ /* The new refname does not go in current_direntry */
+ current_direntry = NULL;
+ }
+ if (!current_direntry)
+ current_direntry = find_containing_direntry(
+ direntry, refname, 1);
+
last = create_ref_entry(refname, sha1, flag);
- add_ref(direntry, last);
+ add_entry(current_direntry, last);
continue;
}
if (last &&
--
1.7.7
^ permalink raw reply related
* [PATCH 12/28] get_packed_refs(): return (ref_entry *) instead of (ref_dir *)
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 33 +++++++++++++++++----------------
1 files changed, 17 insertions(+), 16 deletions(-)
diff --git a/refs.c b/refs.c
index 673fa04..425fdaa 100644
--- a/refs.c
+++ b/refs.c
@@ -760,7 +760,7 @@ void clear_extra_refs(void)
}
}
-static struct ref_dir *get_packed_refs(struct ref_cache *refs)
+static struct ref_entry *get_packed_refs(struct ref_cache *refs)
{
if (!refs->packed) {
const char *packed_refs_file;
@@ -777,7 +777,7 @@ static struct ref_dir *get_packed_refs(struct ref_cache *refs)
fclose(f);
}
}
- return &refs->packed->u.subdir;
+ return refs->packed;
}
/*
@@ -877,9 +877,9 @@ static int resolve_gitlink_packed_ref(struct ref_cache *refs,
const char *refname, unsigned char *sha1)
{
struct ref_entry *ref;
- struct ref_dir *dir = get_packed_refs(refs);
+ struct ref_entry *direntry = get_packed_refs(refs);
- ref = find_ref(dir, refname);
+ ref = find_ref(&direntry->u.subdir, refname);
if (ref == NULL)
return -1;
@@ -950,8 +950,8 @@ int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sh
*/
static int get_packed_ref(const char *refname, unsigned char *sha1)
{
- struct ref_dir *packed = get_packed_refs(get_ref_cache(NULL));
- struct ref_entry *entry = find_ref(packed, refname);
+ struct ref_entry *packed = get_packed_refs(get_ref_cache(NULL));
+ struct ref_entry *entry = find_ref(&packed->u.subdir, refname);
if (entry) {
hashcpy(sha1, entry->u.value.sha1);
return 0;
@@ -1110,8 +1110,8 @@ int peel_ref(const char *refname, unsigned char *sha1)
return -1;
if ((flag & REF_ISPACKED)) {
- struct ref_dir *dir = get_packed_refs(get_ref_cache(NULL));
- struct ref_entry *r = find_ref(dir, refname);
+ struct ref_entry *direntry = get_packed_refs(get_ref_cache(NULL));
+ struct ref_entry *r = find_ref(&direntry->u.subdir, refname);
if (r != NULL && r->flag & REF_KNOWS_PEELED) {
hashcpy(sha1, r->u.value.peeled);
@@ -1171,7 +1171,8 @@ static int do_for_each_ref(const char *submodule, const char *base, each_ref_fn
int retval = 0;
struct ref_cache *refs = get_ref_cache(submodule);
struct ref_dir *extra_dir = extra_refs ? &extra_refs->u.subdir : NULL;
- struct ref_dir *packed_dir = get_packed_refs(refs);
+ struct ref_entry *packed_direntry = get_packed_refs(refs);
+ struct ref_dir *packed_dir = &packed_direntry->u.subdir;
struct ref_dir *loose_dir = get_loose_refs(refs);
if (base && *base) {
@@ -1564,7 +1565,8 @@ static struct ref_lock *lock_ref_sha1_basic(const char *refname,
* name is a proper prefix of our refname.
*/
if (missing &&
- !is_refname_available(refname, NULL, get_packed_refs(get_ref_cache(NULL)))) {
+ !is_refname_available(refname, NULL,
+ &get_packed_refs(get_ref_cache(NULL))->u.subdir)) {
last_errno = ENOTDIR;
goto error_return;
}
@@ -1644,10 +1646,8 @@ static struct lock_file packlock;
static int repack_without_ref(const char *refname)
{
struct repack_without_ref_sb data;
- struct ref_dir *packed;
-
- packed = get_packed_refs(get_ref_cache(NULL));
- if (find_ref(packed, refname) == NULL)
+ struct ref_entry *packed = get_packed_refs(get_ref_cache(NULL));
+ if (find_ref(&packed->u.subdir, refname) == NULL)
return 0;
data.refname = refname;
data.fd = hold_lock_file_for_update(&packlock, git_path("packed-refs"), 0);
@@ -1655,7 +1655,8 @@ static int repack_without_ref(const char *refname)
unable_to_lock_error(git_path("packed-refs"), errno);
return error("cannot delete '%s' from packed refs", refname);
}
- do_for_each_ref_in_dir(packed, 0, "", repack_without_ref_fn, 0, 0, &data);
+ do_for_each_ref_in_dir(&packed->u.subdir, 0,
+ "", repack_without_ref_fn, 0, 0, &data);
return commit_lock_file(&packlock);
}
@@ -1726,7 +1727,7 @@ int rename_ref(const char *oldrefname, const char *newrefname, const char *logms
if (!symref)
return error("refname %s not found", oldrefname);
- if (!is_refname_available(newrefname, oldrefname, get_packed_refs(refs)))
+ if (!is_refname_available(newrefname, oldrefname, &get_packed_refs(refs)->u.subdir))
return 1;
if (!is_refname_available(newrefname, oldrefname, get_loose_refs(refs)))
--
1.7.7
^ permalink raw reply related
* [PATCH 16/28] read_packed_refs(): take (ref_entry *) instead of (ref_dir *)
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 7 ++++---
1 files changed, 4 insertions(+), 3 deletions(-)
diff --git a/refs.c b/refs.c
index e7d4482..f402d39 100644
--- a/refs.c
+++ b/refs.c
@@ -715,12 +715,13 @@ static const char *parse_ref_line(char *line, unsigned char *sha1)
return line;
}
-static void read_packed_refs(FILE *f, struct ref_dir *dir)
+static void read_packed_refs(FILE *f, struct ref_entry *direntry)
{
struct ref_entry *last = NULL;
char refline[PATH_MAX];
int flag = REF_ISPACKED;
+ assert(direntry->flag & REF_DIR);
while (fgets(refline, sizeof(refline), f)) {
unsigned char sha1[20];
const char *refname;
@@ -737,7 +738,7 @@ static void read_packed_refs(FILE *f, struct ref_dir *dir)
refname = parse_ref_line(refline, sha1);
if (refname) {
last = create_ref_entry(refname, sha1, flag);
- add_ref(dir, last);
+ add_ref(&direntry->u.subdir, last);
continue;
}
if (last &&
@@ -777,7 +778,7 @@ static struct ref_entry *get_packed_refs(struct ref_cache *refs)
packed_refs_file = git_path("packed-refs");
f = fopen(packed_refs_file, "r");
if (f) {
- read_packed_refs(f, &refs->packed->u.subdir);
+ read_packed_refs(f, refs->packed);
fclose(f);
}
}
--
1.7.7
^ permalink raw reply related
* [PATCH 24/28] read_loose_refs(): take a (ref_entry *) as argument
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Rename get_ref_dir() to read_loose_refs(), and change its signature.
This is another step towards reading loose references one directory
at a time.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 21 +++++++++++----------
1 files changed, 11 insertions(+), 10 deletions(-)
diff --git a/refs.c b/refs.c
index 6b2b2f6..f3910de 100644
--- a/refs.c
+++ b/refs.c
@@ -815,21 +815,20 @@ static struct ref_entry *get_packed_refs(struct ref_cache *refs)
}
/*
- * dirname must match the name associated with dir; in particular, it
- * must end with '/'.
+ * Fill direntry with loose references read from the filesystem.
*/
-static void get_ref_dir(struct ref_cache *refs, const char *dirname)
+static void read_loose_refs(struct ref_entry *direntry)
{
DIR *d;
char *path;
+ char *dirname = direntry->name;
int dirnamelen = strlen(dirname);
int pathlen;
- struct ref_entry *direntry;
-
- assert(dirnamelen && dirname[dirnamelen - 1] == '/');
-
- direntry = find_containing_direntry(refs->loose, dirname, 1);
+ struct ref_cache *refs;
+ assert(direntry->flag & REF_DIR);
+ assert(dirnamelen && direntry->name[dirnamelen - 1] == '/');
+ refs = direntry->u.subdir.ref_cache;
if (*refs->name)
path = git_path_submodule(refs->name, "%s", dirname);
else
@@ -867,7 +866,9 @@ static void get_ref_dir(struct ref_cache *refs, const char *dirname)
if (S_ISDIR(st.st_mode)) {
refname[dirnamelen + namelen] = '/';
refname[dirnamelen + namelen + 1] = '\0';
- get_ref_dir(refs, refname);
+ read_loose_refs(find_containing_direntry(
+ refs->loose,
+ refname, 1));
continue;
}
if (*refs->name) {
@@ -893,7 +894,7 @@ static struct ref_entry *get_loose_refs(struct ref_cache *refs)
{
if (!refs->loose) {
refs->loose = create_dir_entry(refs, "");
- get_ref_dir(refs, "refs/");
+ read_loose_refs(find_containing_direntry(refs->loose, "refs/", 1));
}
return refs->loose;
}
--
1.7.7
^ permalink raw reply related
* [PATCH 19/28] search_ref_dir(): take (ref_entry *) instead of (ref_dir *)
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 9 ++++++---
1 files changed, 6 insertions(+), 3 deletions(-)
diff --git a/refs.c b/refs.c
index 35b3ff2..e91cc15 100644
--- a/refs.c
+++ b/refs.c
@@ -288,11 +288,14 @@ static void sort_ref_dir(struct ref_dir *dir);
* Return the entry with the given refname from the ref_dir
* (non-recursively). Return NULL if no such entry is found.
*/
-static struct ref_entry *search_ref_dir(struct ref_dir *dir, const char *refname)
+static struct ref_entry *search_ref_dir(struct ref_entry *direntry, const char *refname)
{
struct ref_entry *e, **r;
int len;
+ struct ref_dir *dir;
+ assert(direntry->flag & REF_DIR);
+ dir = &direntry->u.subdir;
if (refname == NULL || !dir->nr)
return NULL;
@@ -342,7 +345,7 @@ static struct ref_entry *find_containing_direntry(struct ref_entry *direntry,
char tmp = slash[1];
struct ref_entry *entry;
slash[1] = '\0';
- entry = search_ref_dir(&direntry->u.subdir, refname_copy);
+ entry = search_ref_dir(direntry, refname_copy);
if (!entry) {
if (!mkdir) {
direntry = NULL;
@@ -372,7 +375,7 @@ static struct ref_entry *find_ref(struct ref_entry *direntry, const char *refnam
direntry = find_containing_direntry(direntry, refname, 0);
if (!direntry)
return NULL;
- entry = search_ref_dir(&direntry->u.subdir, refname);
+ entry = search_ref_dir(direntry, refname);
return (entry && !(entry->flag & REF_DIR)) ? entry : NULL;
}
--
1.7.7
^ permalink raw reply related
* [PATCH 25/28] refs: read loose references lazily
From: mhagger @ 2011-10-28 12:28 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Jeff King, Drew Northup, Jakub Narebski, Heiko Voigt,
Johan Herland, Julian Phillips, Michael Haggerty
In-Reply-To: <1319804921-17545-1-git-send-email-mhagger@alum.mit.edu>
From: Michael Haggerty <mhagger@alum.mit.edu>
Instead of reading the whole directory of loose references the first
time any are needed, only read them on demand, one directory at a
time.
Use a new ref_entry flag value REF_DIR_INCOMPLETE to indicate that the
entry represents a REF_DIR that hasn't been read yet. Whenever any
entries from such a directory are needed, read all of the loose
references from that directory.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
---
refs.c | 112 ++++++++++++++++++++++++++++++++++++++++++++++++++--------------
1 files changed, 88 insertions(+), 24 deletions(-)
diff --git a/refs.c b/refs.c
index f3910de..88ef9dd 100644
--- a/refs.c
+++ b/refs.c
@@ -138,6 +138,12 @@ int check_refname_format(const char *refname, int flags)
struct ref_entry;
+/*
+ * Information used (along with the information in ref_entry) to
+ * describe a single cached reference. This data structure only
+ * occurs embedded in a union in struct ref_entry, and only when
+ * (ref_entry->flag & REF_DIR) is zero.
+ */
struct ref_value {
unsigned char sha1[20];
unsigned char peeled[20];
@@ -145,6 +151,34 @@ struct ref_value {
struct ref_cache;
+/*
+ * Information used (along with the information in ref_entry) to
+ * describe a level in the hierarchy of references. This data
+ * structure only occurs embedded in a union in struct ref_entry, and
+ * only when (ref_entry.flag & REF_DIR) is nonzero. In that case,
+ * (ref_entry.flag & REF_DIR) can take the following values:
+ *
+ * REF_DIR_COMPLETE -- a directory of loose or packed references,
+ * already read.
+ *
+ * REF_DIR_INCOMPLETE -- a directory of loose references that
+ * hasn't been read yet (nor has any of its subdirectories).
+ *
+ * Entries within a directory are stored within a growable array of
+ * pointers to ref_entries (entries, nr, alloc). Entries 0 <= i <
+ * sorted are sorted by their component name in strcmp() order and the
+ * remaining entries are unsorted.
+ *
+ * Loose references are read lazily, one directory at a time. When a
+ * directory of loose references is read, then all of the references
+ * in that directory are stored, and REF_DIR_INCOMPLETE stubs are
+ * created for any subdirectories, but the subdirectories themselves
+ * are not read. The reading is triggered either by search_ref_dir()
+ * (called when single references are added or interrogated), by
+ * sort_ref_dir(), or by iteration over a subdirectory of references
+ * using one of the for_each_ref*() functions (which calls
+ * sort_ref_dir() for each subdirectory).
+ */
struct ref_dir {
int nr, alloc;
@@ -162,19 +196,33 @@ struct ref_dir {
/* ISSYMREF=0x01, ISPACKED=0x02, and ISBROKEN=0x04 are public interfaces */
#define REF_KNOWS_PEELED 0x08
-#define REF_DIR 0x10
+
+/* If any of these bits are set, the entry represents a directory: */
+#define REF_DIR 0x30
+
+/* A directory that has already been fully read. */
+#define REF_DIR_COMPLETE 0x10
+
+/* A directory of loose references that has not yet been fully read. */
+#define REF_DIR_INCOMPLETE 0x20
/*
* A ref_entry represents either a reference or a "subdirectory" of
- * references. Each directory in the reference namespace is
- * represented by a ref_entry with (flags & REF_DIR) set and
- * containing a subdir member that holds the entries in that
- * directory. References are represented by a ref_entry with (flags &
- * REF_DIR) unset and a value member that describes the reference's
- * value. The flag member is at the ref_entry level, but it is also
- * needed to interpret the contents of the value field (in other
- * words, a ref_value object is not very much use without the
- * enclosing ref_entry).
+ * references.
+ *
+ * Each directory in the reference namespace is represented by a
+ * ref_entry with (flags & REF_DIR) set and containing a subdir member
+ * that holds the entries in that directory that have been read so
+ * far. If (flags & REF_DIR) == REF_DIR_INCOMPLETE, then the
+ * directory and its subdirectories haven't been read yet.
+ * REF_DIR_INCOMPLETE is only used for loose references.
+ *
+ * References are represented by a ref_entry with (flags & REF_DIR) ==
+ * 0 and a value member that describes the reference's value. The
+ * flag member is at the ref_entry level, but it is also needed to
+ * interpret the contents of the value field (in other words, a
+ * ref_value object is not very much use without the enclosing
+ * ref_entry).
*
* Reference names cannot end with slash and directories' names are
* always stored with a trailing slash (except for the top-level
@@ -264,13 +312,15 @@ static void clear_ref_dir(struct ref_dir *dir)
dir->entries = NULL;
}
+static void read_loose_refs(struct ref_entry *direntry);
+
/*
* Create a struct ref_entry object for the specified dirname.
* dirname is the name of the directory with a trailing slash (e.g.,
* "refs/heads/") or "" for the top-level directory.
*/
static struct ref_entry *create_dir_entry(struct ref_cache *ref_cache,
- const char *dirname)
+ const char *dirname, int flag)
{
struct ref_entry *direntry;
if (*dirname) {
@@ -283,7 +333,7 @@ static struct ref_entry *create_dir_entry(struct ref_cache *ref_cache,
direntry = xcalloc(1, sizeof(struct ref_entry) + 1);
direntry->name[0] = '\0';
}
- direntry->flag = REF_DIR;
+ direntry->flag = flag;
direntry->u.subdir.ref_cache = ref_cache;
return direntry;
}
@@ -308,6 +358,7 @@ static struct ref_entry *search_ref_dir(struct ref_entry *direntry, const char *
struct ref_dir *dir;
assert(direntry->flag & REF_DIR);
+ read_loose_refs(direntry);
dir = &direntry->u.subdir;
if (refname == NULL || !dir->nr)
return NULL;
@@ -364,8 +415,14 @@ static struct ref_entry *find_containing_direntry(struct ref_entry *direntry,
direntry = NULL;
break;
}
+ /*
+ * If search_ref_dir() above didn't make the
+ * entry spring into existence, then this must
+ * not be an unread loose reference tree, so
+ * the correct flag is REF_DIR_COMPLETE.
+ */
entry = create_dir_entry(direntry->u.subdir.ref_cache,
- refname_copy);
+ refname_copy, REF_DIR_COMPLETE);
add_entry(direntry, entry);
}
slash[1] = tmp;
@@ -441,6 +498,7 @@ static void sort_ref_dir(struct ref_entry *direntry)
struct ref_entry *last = NULL;
struct ref_dir *dir;
assert(direntry->flag & REF_DIR);
+ read_loose_refs(direntry);
dir = &direntry->u.subdir;
if (dir->sorted == dir->nr)
return; /* This directory is already sorted and de-duped */
@@ -491,8 +549,8 @@ static int do_for_each_ref_in_dir(struct ref_entry *direntry, int offset,
int i;
struct ref_dir *dir;
assert(direntry->flag & REF_DIR);
- dir = &direntry->u.subdir;
sort_ref_dir(direntry);
+ dir = &direntry->u.subdir;
for (i = offset; i < dir->nr; i++) {
struct ref_entry *entry = dir->entries[i];
int retval;
@@ -519,10 +577,10 @@ static int do_for_each_ref_in_dirs(struct ref_entry *direntry1,
assert(direntry1->flag & REF_DIR);
assert(direntry2->flag & REF_DIR);
- dir1 = &direntry1->u.subdir;
- dir2 = &direntry2->u.subdir;
sort_ref_dir(direntry1);
sort_ref_dir(direntry2);
+ dir1 = &direntry1->u.subdir;
+ dir2 = &direntry2->u.subdir;
while (1) {
struct ref_entry *e1, *e2, *entry;
int cmp;
@@ -782,7 +840,7 @@ static void read_packed_refs(FILE *f, struct ref_entry *direntry)
void add_extra_ref(const char *refname, const unsigned char *sha1, int flag)
{
if (!extra_refs)
- extra_refs = create_dir_entry(NULL, "");
+ extra_refs = create_dir_entry(NULL, "", REF_DIR_COMPLETE);
add_ref(extra_refs, create_ref_entry(refname, sha1, flag));
}
@@ -800,7 +858,7 @@ static struct ref_entry *get_packed_refs(struct ref_cache *refs)
const char *packed_refs_file;
FILE *f;
- refs->packed = create_dir_entry(refs, "");
+ refs->packed = create_dir_entry(refs, "", REF_DIR_COMPLETE);
if (*refs->name)
packed_refs_file = git_path_submodule(refs->name, "packed-refs");
else
@@ -822,11 +880,14 @@ static void read_loose_refs(struct ref_entry *direntry)
DIR *d;
char *path;
char *dirname = direntry->name;
- int dirnamelen = strlen(dirname);
+ int dirnamelen;
int pathlen;
struct ref_cache *refs;
assert(direntry->flag & REF_DIR);
+ if ((direntry->flag & REF_DIR) != REF_DIR_INCOMPLETE)
+ return;
+ dirnamelen = strlen(dirname);
assert(dirnamelen && direntry->name[dirnamelen - 1] == '/');
refs = direntry->u.subdir.ref_cache;
if (*refs->name)
@@ -864,11 +925,12 @@ static void read_loose_refs(struct ref_entry *direntry)
if (stat(refdir, &st) < 0)
continue;
if (S_ISDIR(st.st_mode)) {
+ struct ref_entry *subdirentry;
refname[dirnamelen + namelen] = '/';
refname[dirnamelen + namelen + 1] = '\0';
- read_loose_refs(find_containing_direntry(
- refs->loose,
- refname, 1));
+ subdirentry = create_dir_entry(direntry->u.subdir.ref_cache,
+ refname, REF_DIR_INCOMPLETE);
+ add_entry(direntry, subdirentry);
continue;
}
if (*refs->name) {
@@ -888,13 +950,15 @@ static void read_loose_refs(struct ref_entry *direntry)
free(refname);
closedir(d);
}
+ direntry->flag = REF_DIR_COMPLETE;
}
static struct ref_entry *get_loose_refs(struct ref_cache *refs)
{
if (!refs->loose) {
- refs->loose = create_dir_entry(refs, "");
- read_loose_refs(find_containing_direntry(refs->loose, "refs/", 1));
+ refs->loose = create_dir_entry(refs, "", REF_DIR_COMPLETE);
+ add_entry(refs->loose,
+ create_dir_entry(refs, "refs/", REF_DIR_INCOMPLETE));
}
return refs->loose;
}
--
1.7.7
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox