2005-06-06 22:31:29 +02:00
|
|
|
#include "cache.h"
|
2006-12-19 23:34:12 +01:00
|
|
|
#include "refs.h"
|
2006-11-19 22:22:44 +01:00
|
|
|
#include "object.h"
|
|
|
|
#include "tag.h"
|
2007-09-28 17:28:54 +02:00
|
|
|
#include "dir.h"
|
2005-06-06 22:31:29 +02:00
|
|
|
|
2012-04-10 07:30:13 +02:00
|
|
|
/*
|
|
|
|
* Make sure "ref" is something reasonable to have under ".git/refs/";
|
|
|
|
* We do not like it if:
|
|
|
|
*
|
|
|
|
* - any path component of it begins with ".", or
|
|
|
|
* - it has double dots "..", or
|
|
|
|
* - it has ASCII control character, "~", "^", ":" or SP, anywhere, or
|
|
|
|
* - it ends with a "/".
|
|
|
|
* - it ends with ".lock"
|
|
|
|
* - it contains a "\" (backslash)
|
|
|
|
*/
|
2006-11-22 08:36:35 +01:00
|
|
|
|
2012-04-10 07:30:13 +02:00
|
|
|
/* Return true iff ch is not allowed in reference names. */
|
|
|
|
static inline int bad_ref_char(int ch)
|
|
|
|
{
|
|
|
|
if (((unsigned) ch) <= ' ' || ch == 0x7f ||
|
|
|
|
ch == '~' || ch == '^' || ch == ':' || ch == '\\')
|
|
|
|
return 1;
|
|
|
|
/* 2.13 Pattern Matching Notation */
|
|
|
|
if (ch == '*' || ch == '?' || ch == '[') /* Unsupported */
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to read one refname component from the front of refname. Return
|
|
|
|
* the length of the component found, or -1 if the component is not
|
|
|
|
* legal.
|
|
|
|
*/
|
|
|
|
static int check_refname_component(const char *refname, int flags)
|
|
|
|
{
|
|
|
|
const char *cp;
|
|
|
|
char last = '\0';
|
|
|
|
|
|
|
|
for (cp = refname; ; cp++) {
|
|
|
|
char ch = *cp;
|
|
|
|
if (ch == '\0' || ch == '/')
|
|
|
|
break;
|
|
|
|
if (bad_ref_char(ch))
|
|
|
|
return -1; /* Illegal character in refname. */
|
|
|
|
if (last == '.' && ch == '.')
|
|
|
|
return -1; /* Refname contains "..". */
|
|
|
|
if (last == '@' && ch == '{')
|
|
|
|
return -1; /* Refname contains "@{". */
|
|
|
|
last = ch;
|
|
|
|
}
|
|
|
|
if (cp == refname)
|
2012-04-10 07:30:22 +02:00
|
|
|
return 0; /* Component has zero length. */
|
2012-04-10 07:30:13 +02:00
|
|
|
if (refname[0] == '.') {
|
|
|
|
if (!(flags & REFNAME_DOT_COMPONENT))
|
|
|
|
return -1; /* Component starts with '.'. */
|
|
|
|
/*
|
|
|
|
* Even if leading dots are allowed, don't allow "."
|
|
|
|
* as a component (".." is prevented by a rule above).
|
|
|
|
*/
|
|
|
|
if (refname[1] == '\0')
|
|
|
|
return -1; /* Component equals ".". */
|
|
|
|
}
|
|
|
|
if (cp - refname >= 5 && !memcmp(cp - 5, ".lock", 5))
|
|
|
|
return -1; /* Refname ends with ".lock". */
|
|
|
|
return cp - refname;
|
|
|
|
}
|
|
|
|
|
|
|
|
int check_refname_format(const char *refname, int flags)
|
|
|
|
{
|
|
|
|
int component_len, component_count = 0;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
/* We are at the start of a path component. */
|
|
|
|
component_len = check_refname_component(refname, flags);
|
2012-04-10 07:30:22 +02:00
|
|
|
if (component_len <= 0) {
|
2012-04-10 07:30:13 +02:00
|
|
|
if ((flags & REFNAME_REFSPEC_PATTERN) &&
|
|
|
|
refname[0] == '*' &&
|
|
|
|
(refname[1] == '\0' || refname[1] == '/')) {
|
|
|
|
/* Accept one wildcard as a full refname component. */
|
|
|
|
flags &= ~REFNAME_REFSPEC_PATTERN;
|
|
|
|
component_len = 1;
|
|
|
|
} else {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
component_count++;
|
|
|
|
if (refname[component_len] == '\0')
|
|
|
|
break;
|
|
|
|
/* Skip to next component. */
|
|
|
|
refname += component_len + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (refname[component_len - 1] == '.')
|
|
|
|
return -1; /* Refname ends with '.'. */
|
|
|
|
if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2)
|
|
|
|
return -1; /* Refname has only one component. */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct ref_entry;
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
|
2012-04-27 00:27:07 +02:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-04-10 07:30:23 +02:00
|
|
|
struct ref_value {
|
2013-04-14 14:54:17 +02:00
|
|
|
/*
|
|
|
|
* The name of the object to which this reference resolves
|
|
|
|
* (which may be a tag object). If REF_ISBROKEN, this is
|
|
|
|
* null. If REF_ISSYMREF, then this is the name of the object
|
|
|
|
* referred to by the last reference in the symlink chain.
|
|
|
|
*/
|
2012-04-10 07:30:23 +02:00
|
|
|
unsigned char sha1[20];
|
2013-04-14 14:54:17 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If REF_KNOWS_PEELED, then this field holds the peeled value
|
|
|
|
* of this reference, or null if the reference is known not to
|
2013-04-22 21:52:21 +02:00
|
|
|
* be peelable. See the documentation for peel_ref() for an
|
|
|
|
* exact definition of "peelable".
|
2013-04-14 14:54:17 +02:00
|
|
|
*/
|
2012-04-10 07:30:23 +02:00
|
|
|
unsigned char peeled[20];
|
|
|
|
};
|
|
|
|
|
2012-04-27 00:27:05 +02:00
|
|
|
struct ref_cache;
|
|
|
|
|
2012-04-27 00:27:07 +02:00
|
|
|
/*
|
|
|
|
* 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 set. In that case,
|
|
|
|
* (ref_entry.flag & REF_INCOMPLETE) determines whether the references
|
|
|
|
* in the directory have already been read:
|
|
|
|
*
|
|
|
|
* (ref_entry.flag & REF_INCOMPLETE) unset -- a directory of loose
|
|
|
|
* or packed references, already read.
|
|
|
|
*
|
|
|
|
* (ref_entry.flag & REF_INCOMPLETE) set -- 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_INCOMPLETE stubs are created
|
|
|
|
* for any subdirectories, but the subdirectories themselves are not
|
|
|
|
* read. The reading is triggered by get_ref_dir().
|
|
|
|
*/
|
2012-04-10 07:30:24 +02:00
|
|
|
struct ref_dir {
|
2011-09-30 00:11:42 +02:00
|
|
|
int nr, alloc;
|
ref_array: keep track of whether references are sorted
Keep track of how many entries at the beginning of a ref_array are already
sorted. In sort_ref_array(), return early if the the array is already
sorted (i.e., if no new references has been appended to the end of the
list since the last call to sort_ref_array()).
Sort ref_arrays only when needed, namely in search_ref_array() and in
do_for_each_ref(). However, never call sort_ref_array() on the
extra_refs, because extra_refs can contain multiple entries with the same
name and because sort_ref_array() not only sorts, but de-dups its
contents.
This change is currently not useful, because entries are not added to
ref_arrays after they are created. But in a moment they will be...
Implementation note: we could store a binary "sorted" value instead of
an integer, but storing the number of sorted entries leaves the way
open for a couple of possible future optimizations:
* In sort_ref_array(), sort *only* the unsorted entries, then merge
them with the sorted entries. This should be faster if most of the
entries are already sorted.
* Teach search_ref_array() to do a binary search of any sorted
entries, and if unsuccessful do a linear search of any unsorted
entries. This would avoid the need to sort the list every time that
search_ref_array() is called, and (given some intelligence about how
often to sort) could significantly improve the speed in certain
hypothetical usage patterns.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-01-17 06:50:32 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Entries with index 0 <= i < sorted are sorted by name. New
|
|
|
|
* entries are appended to the list unsorted, and are sorted
|
|
|
|
* only when required; thus we avoid the need to sort the list
|
|
|
|
* after the addition of every reference.
|
|
|
|
*/
|
|
|
|
int sorted;
|
|
|
|
|
2012-04-27 00:27:05 +02:00
|
|
|
/* A pointer to the ref_cache that contains this ref_dir. */
|
|
|
|
struct ref_cache *ref_cache;
|
|
|
|
|
2012-04-10 07:30:24 +02:00
|
|
|
struct ref_entry **entries;
|
2011-09-30 00:11:42 +02:00
|
|
|
};
|
|
|
|
|
2013-04-14 14:54:16 +02:00
|
|
|
/*
|
|
|
|
* Bit values for ref_entry::flag. REF_ISSYMREF=0x01,
|
|
|
|
* REF_ISPACKED=0x02, and REF_ISBROKEN=0x04 are public values; see
|
|
|
|
* refs.h.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The field ref_entry->u.value.peeled of this value entry contains
|
|
|
|
* the correct peeled value for the reference, which might be
|
|
|
|
* null_sha1 if the reference is not a tag or if it is broken.
|
|
|
|
*/
|
2012-04-10 07:30:26 +02:00
|
|
|
#define REF_KNOWS_PEELED 0x08
|
2012-04-27 00:27:07 +02:00
|
|
|
|
|
|
|
/* ref_entry represents a directory of references */
|
2012-04-10 07:30:26 +02:00
|
|
|
#define REF_DIR 0x10
|
2006-11-19 22:22:44 +01:00
|
|
|
|
2012-04-27 00:27:07 +02:00
|
|
|
/*
|
|
|
|
* Entry has not yet been read from disk (used only for REF_DIR
|
|
|
|
* entries representing loose references)
|
|
|
|
*/
|
|
|
|
#define REF_INCOMPLETE 0x20
|
|
|
|
|
2012-04-10 07:30:26 +02:00
|
|
|
/*
|
|
|
|
* A ref_entry represents either a reference or a "subdirectory" of
|
2012-04-27 00:27:07 +02:00
|
|
|
* 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_INCOMPLETE) is set, then the directory and
|
|
|
|
* its subdirectories haven't been read yet. REF_INCOMPLETE is only
|
|
|
|
* used for loose reference directories.
|
|
|
|
*
|
|
|
|
* 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).
|
2012-04-10 07:30:26 +02:00
|
|
|
*
|
|
|
|
* Reference names cannot end with slash and directories' names are
|
|
|
|
* always stored with a trailing slash (except for the top-level
|
|
|
|
* directory, which is always denoted by ""). This has two nice
|
|
|
|
* consequences: (1) when the entries in each subdir are sorted
|
|
|
|
* lexicographically by name (as they usually are), the references in
|
|
|
|
* a whole tree can be generated in lexicographic order by traversing
|
|
|
|
* the tree in left-to-right, depth-first order; (2) the names of
|
|
|
|
* references and subdirectories cannot conflict, and therefore the
|
|
|
|
* presence of an empty subdirectory does not block the creation of a
|
|
|
|
* similarly-named reference. (The fact that reference names with the
|
|
|
|
* same leading components can conflict *with each other* is a
|
|
|
|
* separate issue that is regulated by is_refname_available().)
|
|
|
|
*
|
|
|
|
* Please note that the name field contains the fully-qualified
|
|
|
|
* reference (or subdirectory) name. Space could be saved by only
|
|
|
|
* storing the relative names. But that would require the full names
|
|
|
|
* to be generated on the fly when iterating in do_for_each_ref(), and
|
|
|
|
* would break callback functions, who have always been able to assume
|
|
|
|
* that the name strings that they are passed will not be freed during
|
|
|
|
* the iteration.
|
|
|
|
*/
|
2012-04-10 07:30:13 +02:00
|
|
|
struct ref_entry {
|
|
|
|
unsigned char flag; /* ISSYMREF? ISPACKED? */
|
2012-04-10 07:30:23 +02:00
|
|
|
union {
|
2012-04-10 07:30:26 +02:00
|
|
|
struct ref_value value; /* if not (flags&REF_DIR) */
|
|
|
|
struct ref_dir subdir; /* if (flags&REF_DIR) */
|
2012-04-10 07:30:23 +02:00
|
|
|
} u;
|
2012-04-10 07:30:26 +02:00
|
|
|
/*
|
|
|
|
* The full name of the reference (e.g., "refs/heads/master")
|
|
|
|
* or the full name of the directory with a trailing slash
|
|
|
|
* (e.g., "refs/heads/"):
|
|
|
|
*/
|
2012-04-10 07:30:13 +02:00
|
|
|
char name[FLEX_ARRAY];
|
|
|
|
};
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
|
2012-04-27 00:27:07 +02:00
|
|
|
static void read_loose_refs(const char *dirname, struct ref_dir *dir);
|
|
|
|
|
2012-04-27 00:27:03 +02:00
|
|
|
static struct ref_dir *get_ref_dir(struct ref_entry *entry)
|
|
|
|
{
|
2012-04-27 00:27:07 +02:00
|
|
|
struct ref_dir *dir;
|
2012-04-27 00:27:03 +02:00
|
|
|
assert(entry->flag & REF_DIR);
|
2012-04-27 00:27:07 +02:00
|
|
|
dir = &entry->u.subdir;
|
|
|
|
if (entry->flag & REF_INCOMPLETE) {
|
|
|
|
read_loose_refs(entry->name, dir);
|
|
|
|
entry->flag &= ~REF_INCOMPLETE;
|
|
|
|
}
|
|
|
|
return dir;
|
2012-04-27 00:27:03 +02:00
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:22 +01:00
|
|
|
static struct ref_entry *create_ref_entry(const char *refname,
|
|
|
|
const unsigned char *sha1, int flag,
|
|
|
|
int check_name)
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
{
|
|
|
|
int len;
|
2011-12-12 06:38:22 +01:00
|
|
|
struct ref_entry *ref;
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
|
2011-11-17 01:54:32 +01:00
|
|
|
if (check_name &&
|
2011-12-12 06:38:09 +01:00
|
|
|
check_refname_format(refname, REFNAME_ALLOW_ONELEVEL|REFNAME_DOT_COMPONENT))
|
|
|
|
die("Reference has invalid format: '%s'", refname);
|
2011-12-12 06:38:22 +01:00
|
|
|
len = strlen(refname) + 1;
|
|
|
|
ref = xmalloc(sizeof(struct ref_entry) + len);
|
2012-04-10 07:30:23 +02:00
|
|
|
hashcpy(ref->u.value.sha1, sha1);
|
|
|
|
hashclr(ref->u.value.peeled);
|
2011-12-12 06:38:22 +01:00
|
|
|
memcpy(ref->name, refname, len);
|
|
|
|
ref->flag = flag;
|
|
|
|
return ref;
|
|
|
|
}
|
|
|
|
|
2012-04-10 07:30:26 +02:00
|
|
|
static void clear_ref_dir(struct ref_dir *dir);
|
|
|
|
|
2012-04-10 07:30:21 +02:00
|
|
|
static void free_ref_entry(struct ref_entry *entry)
|
|
|
|
{
|
2012-05-20 08:49:32 +02:00
|
|
|
if (entry->flag & REF_DIR) {
|
|
|
|
/*
|
|
|
|
* Do not use get_ref_dir() here, as that might
|
|
|
|
* trigger the reading of loose refs.
|
|
|
|
*/
|
|
|
|
clear_ref_dir(&entry->u.subdir);
|
|
|
|
}
|
2012-04-10 07:30:21 +02:00
|
|
|
free(entry);
|
|
|
|
}
|
|
|
|
|
2012-04-10 07:30:26 +02:00
|
|
|
/*
|
|
|
|
* Add a ref_entry to the end of dir (unsorted). Entry is always
|
|
|
|
* stored directly in dir; no recursion into subdirectories is
|
|
|
|
* done.
|
|
|
|
*/
|
|
|
|
static void add_entry_to_dir(struct ref_dir *dir, struct ref_entry *entry)
|
2011-12-12 06:38:22 +01:00
|
|
|
{
|
2012-04-10 07:30:26 +02:00
|
|
|
ALLOC_GROW(dir->entries, dir->nr + 1, dir->alloc);
|
|
|
|
dir->entries[dir->nr++] = entry;
|
2012-05-24 14:16:50 +02:00
|
|
|
/* optimize for the case that entries are added in order */
|
|
|
|
if (dir->nr == 1 ||
|
|
|
|
(dir->nr == dir->sorted + 1 &&
|
|
|
|
strcmp(dir->entries[dir->nr - 2]->name,
|
|
|
|
dir->entries[dir->nr - 1]->name) < 0))
|
|
|
|
dir->sorted = dir->nr;
|
2007-04-17 03:42:50 +02:00
|
|
|
}
|
|
|
|
|
2012-04-10 07:30:26 +02:00
|
|
|
/*
|
|
|
|
* Clear and free all entries in dir, recursively.
|
|
|
|
*/
|
2012-04-10 07:30:24 +02:00
|
|
|
static void clear_ref_dir(struct ref_dir *dir)
|
2012-04-10 07:30:13 +02:00
|
|
|
{
|
|
|
|
int i;
|
2012-04-10 07:30:24 +02:00
|
|
|
for (i = 0; i < dir->nr; i++)
|
|
|
|
free_ref_entry(dir->entries[i]);
|
|
|
|
free(dir->entries);
|
|
|
|
dir->sorted = dir->nr = dir->alloc = 0;
|
|
|
|
dir->entries = NULL;
|
2012-04-10 07:30:13 +02:00
|
|
|
}
|
|
|
|
|
2012-04-10 07:30:26 +02:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-04-27 00:27:05 +02:00
|
|
|
static struct ref_entry *create_dir_entry(struct ref_cache *ref_cache,
|
2012-05-22 20:50:52 +02:00
|
|
|
const char *dirname, size_t len,
|
|
|
|
int incomplete)
|
2012-04-10 07:30:26 +02:00
|
|
|
{
|
|
|
|
struct ref_entry *direntry;
|
|
|
|
direntry = xcalloc(1, sizeof(struct ref_entry) + len + 1);
|
2012-05-22 20:50:52 +02:00
|
|
|
memcpy(direntry->name, dirname, len);
|
|
|
|
direntry->name[len] = '\0';
|
2012-04-27 00:27:05 +02:00
|
|
|
direntry->u.subdir.ref_cache = ref_cache;
|
2012-04-27 00:27:07 +02:00
|
|
|
direntry->flag = REF_DIR | (incomplete ? REF_INCOMPLETE : 0);
|
2012-04-10 07:30:26 +02:00
|
|
|
return direntry;
|
|
|
|
}
|
|
|
|
|
2011-09-30 00:11:42 +02:00
|
|
|
static int ref_entry_cmp(const void *a, const void *b)
|
2007-04-17 03:42:50 +02:00
|
|
|
{
|
2011-09-30 00:11:42 +02:00
|
|
|
struct ref_entry *one = *(struct ref_entry **)a;
|
|
|
|
struct ref_entry *two = *(struct ref_entry **)b;
|
|
|
|
return strcmp(one->name, two->name);
|
|
|
|
}
|
2007-04-17 03:42:50 +02:00
|
|
|
|
2012-04-10 07:30:24 +02:00
|
|
|
static void sort_ref_dir(struct ref_dir *dir);
|
2012-04-10 07:30:13 +02:00
|
|
|
|
2012-05-22 23:03:29 +02:00
|
|
|
struct string_slice {
|
|
|
|
size_t len;
|
|
|
|
const char *str;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int ref_entry_cmp_sslice(const void *key_, const void *ent_)
|
|
|
|
{
|
|
|
|
struct string_slice *key = (struct string_slice *)key_;
|
|
|
|
struct ref_entry *ent = *(struct ref_entry **)ent_;
|
|
|
|
int entlen = strlen(ent->name);
|
|
|
|
int cmplen = key->len < entlen ? key->len : entlen;
|
|
|
|
int cmp = memcmp(key->str, ent->name, cmplen);
|
|
|
|
if (cmp)
|
|
|
|
return cmp;
|
|
|
|
return key->len - entlen;
|
|
|
|
}
|
|
|
|
|
2012-04-10 07:30:26 +02:00
|
|
|
/*
|
2013-04-22 21:52:26 +02:00
|
|
|
* Return the index of the entry with the given refname from the
|
|
|
|
* ref_dir (non-recursively), sorting dir if necessary. Return -1 if
|
|
|
|
* no such entry is found. dir must already be complete.
|
2012-04-10 07:30:26 +02:00
|
|
|
*/
|
2013-04-22 21:52:26 +02:00
|
|
|
static int search_ref_dir(struct ref_dir *dir, const char *refname, size_t len)
|
2012-04-10 07:30:13 +02:00
|
|
|
{
|
2012-05-22 23:03:29 +02:00
|
|
|
struct ref_entry **r;
|
|
|
|
struct string_slice key;
|
2012-04-10 07:30:13 +02:00
|
|
|
|
2012-04-10 07:30:26 +02:00
|
|
|
if (refname == NULL || !dir->nr)
|
2013-04-22 21:52:26 +02:00
|
|
|
return -1;
|
2012-04-10 07:30:13 +02:00
|
|
|
|
2012-04-10 07:30:24 +02:00
|
|
|
sort_ref_dir(dir);
|
2012-05-22 23:03:29 +02:00
|
|
|
key.len = len;
|
|
|
|
key.str = refname;
|
|
|
|
r = bsearch(&key, dir->entries, dir->nr, sizeof(*dir->entries),
|
|
|
|
ref_entry_cmp_sslice);
|
2012-04-10 07:30:13 +02:00
|
|
|
|
|
|
|
if (r == NULL)
|
2013-04-22 21:52:26 +02:00
|
|
|
return -1;
|
2012-04-10 07:30:13 +02:00
|
|
|
|
2013-04-22 21:52:26 +02:00
|
|
|
return r - dir->entries;
|
2012-04-10 07:30:13 +02:00
|
|
|
}
|
|
|
|
|
2012-04-25 00:45:11 +02:00
|
|
|
/*
|
|
|
|
* Search for a directory entry directly within dir (without
|
|
|
|
* recursing). Sort dir if necessary. subdirname must be a directory
|
|
|
|
* name (i.e., end in '/'). If mkdir is set, then create the
|
|
|
|
* directory if it is missing; otherwise, return NULL if the desired
|
2012-04-27 00:27:07 +02:00
|
|
|
* directory cannot be found. dir must already be complete.
|
2012-04-25 00:45:11 +02:00
|
|
|
*/
|
2012-04-27 00:27:04 +02:00
|
|
|
static struct ref_dir *search_for_subdir(struct ref_dir *dir,
|
2012-05-22 20:50:58 +02:00
|
|
|
const char *subdirname, size_t len,
|
|
|
|
int mkdir)
|
2012-04-25 00:45:11 +02:00
|
|
|
{
|
2013-04-22 21:52:26 +02:00
|
|
|
int entry_index = search_ref_dir(dir, subdirname, len);
|
|
|
|
struct ref_entry *entry;
|
|
|
|
if (entry_index == -1) {
|
2012-04-25 00:45:11 +02:00
|
|
|
if (!mkdir)
|
|
|
|
return NULL;
|
2012-04-27 00:27:07 +02:00
|
|
|
/*
|
|
|
|
* Since dir is complete, the absence of a subdir
|
|
|
|
* means that the subdir really doesn't exist;
|
|
|
|
* therefore, create an empty record for it but mark
|
|
|
|
* the record complete.
|
|
|
|
*/
|
2012-05-22 20:50:52 +02:00
|
|
|
entry = create_dir_entry(dir->ref_cache, subdirname, len, 0);
|
2012-04-25 00:45:11 +02:00
|
|
|
add_entry_to_dir(dir, entry);
|
2013-04-22 21:52:26 +02:00
|
|
|
} else {
|
|
|
|
entry = dir->entries[entry_index];
|
2012-04-25 00:45:11 +02:00
|
|
|
}
|
2012-04-27 00:27:04 +02:00
|
|
|
return get_ref_dir(entry);
|
2012-04-25 00:45:11 +02:00
|
|
|
}
|
|
|
|
|
2012-04-10 07:30:26 +02:00
|
|
|
/*
|
|
|
|
* If refname is a reference name, find the ref_dir 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
|
2012-04-27 00:27:07 +02:00
|
|
|
* represent the top-level directory and must already be complete.
|
|
|
|
* Sort ref_dirs and recurse into subdirectories as necessary. If
|
|
|
|
* mkdir is set, then create any missing directories; otherwise,
|
|
|
|
* return NULL if the desired directory cannot be found.
|
2012-04-10 07:30:26 +02:00
|
|
|
*/
|
|
|
|
static struct ref_dir *find_containing_dir(struct ref_dir *dir,
|
|
|
|
const char *refname, int mkdir)
|
|
|
|
{
|
2012-04-27 00:27:00 +02:00
|
|
|
const char *slash;
|
|
|
|
for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
|
2012-05-22 20:50:58 +02:00
|
|
|
size_t dirnamelen = slash - refname + 1;
|
2012-04-27 00:27:04 +02:00
|
|
|
struct ref_dir *subdir;
|
2012-05-22 20:50:58 +02:00
|
|
|
subdir = search_for_subdir(dir, refname, dirnamelen, mkdir);
|
2012-05-04 00:12:54 +02:00
|
|
|
if (!subdir) {
|
|
|
|
dir = NULL;
|
2012-04-25 00:45:11 +02:00
|
|
|
break;
|
2012-04-10 07:30:26 +02:00
|
|
|
}
|
2012-04-27 00:27:04 +02:00
|
|
|
dir = subdir;
|
2012-04-10 07:30:26 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return dir;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the value entry with the given name in dir, sorting ref_dirs
|
|
|
|
* and recursing into 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)
|
|
|
|
{
|
2013-04-22 21:52:26 +02:00
|
|
|
int entry_index;
|
2012-04-10 07:30:26 +02:00
|
|
|
struct ref_entry *entry;
|
|
|
|
dir = find_containing_dir(dir, refname, 0);
|
|
|
|
if (!dir)
|
|
|
|
return NULL;
|
2013-04-22 21:52:26 +02:00
|
|
|
entry_index = search_ref_dir(dir, refname, strlen(refname));
|
|
|
|
if (entry_index == -1)
|
|
|
|
return NULL;
|
|
|
|
entry = dir->entries[entry_index];
|
|
|
|
return (entry->flag & REF_DIR) ? NULL : entry;
|
2012-04-10 07:30:26 +02:00
|
|
|
}
|
|
|
|
|
2013-04-22 21:52:27 +02:00
|
|
|
/*
|
|
|
|
* Remove the entry with the given name from dir, recursing into
|
|
|
|
* subdirectories as necessary. If refname is the name of a directory
|
|
|
|
* (i.e., ends with '/'), then remove the directory and its contents.
|
|
|
|
* If the removal was successful, return the number of entries
|
|
|
|
* remaining in the directory entry that contained the deleted entry.
|
|
|
|
* If the name was not found, return -1. Please note that this
|
|
|
|
* function only deletes the entry from the cache; it does not delete
|
|
|
|
* it from the filesystem or ensure that other cache entries (which
|
|
|
|
* might be symbolic references to the removed entry) are updated.
|
|
|
|
* Nor does it remove any containing dir entries that might be made
|
|
|
|
* empty by the removal. dir must represent the top-level directory
|
|
|
|
* and must already be complete.
|
|
|
|
*/
|
|
|
|
static int remove_entry(struct ref_dir *dir, const char *refname)
|
|
|
|
{
|
|
|
|
int refname_len = strlen(refname);
|
|
|
|
int entry_index;
|
|
|
|
struct ref_entry *entry;
|
|
|
|
int is_dir = refname[refname_len - 1] == '/';
|
|
|
|
if (is_dir) {
|
|
|
|
/*
|
|
|
|
* refname represents a reference directory. Remove
|
|
|
|
* the trailing slash; otherwise we will get the
|
|
|
|
* directory *representing* refname rather than the
|
|
|
|
* one *containing* it.
|
|
|
|
*/
|
|
|
|
char *dirname = xmemdupz(refname, refname_len - 1);
|
|
|
|
dir = find_containing_dir(dir, dirname, 0);
|
|
|
|
free(dirname);
|
|
|
|
} else {
|
|
|
|
dir = find_containing_dir(dir, refname, 0);
|
|
|
|
}
|
|
|
|
if (!dir)
|
|
|
|
return -1;
|
|
|
|
entry_index = search_ref_dir(dir, refname, refname_len);
|
|
|
|
if (entry_index == -1)
|
|
|
|
return -1;
|
|
|
|
entry = dir->entries[entry_index];
|
|
|
|
|
|
|
|
memmove(&dir->entries[entry_index],
|
|
|
|
&dir->entries[entry_index + 1],
|
|
|
|
(dir->nr - entry_index - 1) * sizeof(*dir->entries)
|
|
|
|
);
|
|
|
|
dir->nr--;
|
|
|
|
if (dir->sorted > entry_index)
|
|
|
|
dir->sorted--;
|
|
|
|
free_ref_entry(entry);
|
|
|
|
return dir->nr;
|
|
|
|
}
|
|
|
|
|
2012-04-10 07:30:26 +02:00
|
|
|
/*
|
|
|
|
* Add a ref_entry to the ref_dir (unsorted), recursing into
|
|
|
|
* 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)
|
|
|
|
{
|
|
|
|
dir = find_containing_dir(dir, ref->name, 1);
|
|
|
|
if (!dir)
|
|
|
|
return -1;
|
|
|
|
add_entry_to_dir(dir, ref);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:15 +01:00
|
|
|
/*
|
|
|
|
* Emit a warning and return true iff ref1 and ref2 have the same name
|
|
|
|
* and the same sha1. Die if they have the same name but different
|
|
|
|
* sha1s.
|
|
|
|
*/
|
|
|
|
static int is_dup_ref(const struct ref_entry *ref1, const struct ref_entry *ref2)
|
|
|
|
{
|
2012-04-10 07:30:26 +02:00
|
|
|
if (strcmp(ref1->name, ref2->name))
|
2011-12-12 06:38:15 +01:00
|
|
|
return 0;
|
2012-04-10 07:30:26 +02:00
|
|
|
|
|
|
|
/* Duplicate name; make sure that they don't conflict: */
|
|
|
|
|
|
|
|
if ((ref1->flag & REF_DIR) || (ref2->flag & REF_DIR))
|
|
|
|
/* This is impossible by construction */
|
|
|
|
die("Reference directory conflict: %s", ref1->name);
|
|
|
|
|
|
|
|
if (hashcmp(ref1->u.value.sha1, ref2->u.value.sha1))
|
|
|
|
die("Duplicated ref, and SHA1s don't match: %s", ref1->name);
|
|
|
|
|
|
|
|
warning("Duplicated ref: %s", ref1->name);
|
|
|
|
return 1;
|
2011-12-12 06:38:15 +01:00
|
|
|
}
|
|
|
|
|
ref_array: keep track of whether references are sorted
Keep track of how many entries at the beginning of a ref_array are already
sorted. In sort_ref_array(), return early if the the array is already
sorted (i.e., if no new references has been appended to the end of the
list since the last call to sort_ref_array()).
Sort ref_arrays only when needed, namely in search_ref_array() and in
do_for_each_ref(). However, never call sort_ref_array() on the
extra_refs, because extra_refs can contain multiple entries with the same
name and because sort_ref_array() not only sorts, but de-dups its
contents.
This change is currently not useful, because entries are not added to
ref_arrays after they are created. But in a moment they will be...
Implementation note: we could store a binary "sorted" value instead of
an integer, but storing the number of sorted entries leaves the way
open for a couple of possible future optimizations:
* In sort_ref_array(), sort *only* the unsorted entries, then merge
them with the sorted entries. This should be faster if most of the
entries are already sorted.
* Teach search_ref_array() to do a binary search of any sorted
entries, and if unsuccessful do a linear search of any unsorted
entries. This would avoid the need to sort the list every time that
search_ref_array() is called, and (given some intelligence about how
often to sort) could significantly improve the speed in certain
hypothetical usage patterns.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-01-17 06:50:32 +01:00
|
|
|
/*
|
2012-04-10 07:30:26 +02:00
|
|
|
* Sort the entries in dir non-recursively (if they are not already
|
|
|
|
* sorted) and remove any duplicate entries.
|
ref_array: keep track of whether references are sorted
Keep track of how many entries at the beginning of a ref_array are already
sorted. In sort_ref_array(), return early if the the array is already
sorted (i.e., if no new references has been appended to the end of the
list since the last call to sort_ref_array()).
Sort ref_arrays only when needed, namely in search_ref_array() and in
do_for_each_ref(). However, never call sort_ref_array() on the
extra_refs, because extra_refs can contain multiple entries with the same
name and because sort_ref_array() not only sorts, but de-dups its
contents.
This change is currently not useful, because entries are not added to
ref_arrays after they are created. But in a moment they will be...
Implementation note: we could store a binary "sorted" value instead of
an integer, but storing the number of sorted entries leaves the way
open for a couple of possible future optimizations:
* In sort_ref_array(), sort *only* the unsorted entries, then merge
them with the sorted entries. This should be faster if most of the
entries are already sorted.
* Teach search_ref_array() to do a binary search of any sorted
entries, and if unsuccessful do a linear search of any unsorted
entries. This would avoid the need to sort the list every time that
search_ref_array() is called, and (given some intelligence about how
often to sort) could significantly improve the speed in certain
hypothetical usage patterns.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-01-17 06:50:32 +01:00
|
|
|
*/
|
2012-04-10 07:30:24 +02:00
|
|
|
static void sort_ref_dir(struct ref_dir *dir)
|
2011-09-30 00:11:42 +02:00
|
|
|
{
|
2011-12-12 06:38:15 +01:00
|
|
|
int i, j;
|
2012-04-10 07:30:25 +02:00
|
|
|
struct ref_entry *last = NULL;
|
2007-04-17 03:42:50 +02:00
|
|
|
|
ref_array: keep track of whether references are sorted
Keep track of how many entries at the beginning of a ref_array are already
sorted. In sort_ref_array(), return early if the the array is already
sorted (i.e., if no new references has been appended to the end of the
list since the last call to sort_ref_array()).
Sort ref_arrays only when needed, namely in search_ref_array() and in
do_for_each_ref(). However, never call sort_ref_array() on the
extra_refs, because extra_refs can contain multiple entries with the same
name and because sort_ref_array() not only sorts, but de-dups its
contents.
This change is currently not useful, because entries are not added to
ref_arrays after they are created. But in a moment they will be...
Implementation note: we could store a binary "sorted" value instead of
an integer, but storing the number of sorted entries leaves the way
open for a couple of possible future optimizations:
* In sort_ref_array(), sort *only* the unsorted entries, then merge
them with the sorted entries. This should be faster if most of the
entries are already sorted.
* Teach search_ref_array() to do a binary search of any sorted
entries, and if unsuccessful do a linear search of any unsorted
entries. This would avoid the need to sort the list every time that
search_ref_array() is called, and (given some intelligence about how
often to sort) could significantly improve the speed in certain
hypothetical usage patterns.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-01-17 06:50:32 +01:00
|
|
|
/*
|
|
|
|
* This check also prevents passing a zero-length array to qsort(),
|
|
|
|
* which is a problem on some platforms.
|
|
|
|
*/
|
2012-04-10 07:30:24 +02:00
|
|
|
if (dir->sorted == dir->nr)
|
2011-09-30 00:11:42 +02:00
|
|
|
return;
|
2007-04-17 03:42:50 +02:00
|
|
|
|
2012-04-10 07:30:24 +02:00
|
|
|
qsort(dir->entries, dir->nr, sizeof(*dir->entries), ref_entry_cmp);
|
2007-04-17 03:42:50 +02:00
|
|
|
|
2012-04-10 07:30:25 +02:00
|
|
|
/* Remove any duplicates: */
|
|
|
|
for (i = 0, j = 0; j < dir->nr; j++) {
|
|
|
|
struct ref_entry *entry = dir->entries[j];
|
|
|
|
if (last && is_dup_ref(last, entry))
|
|
|
|
free_ref_entry(entry);
|
|
|
|
else
|
|
|
|
last = dir->entries[i++] = entry;
|
2011-09-30 00:11:42 +02:00
|
|
|
}
|
2012-04-10 07:30:25 +02:00
|
|
|
dir->sorted = dir->nr = i;
|
2011-09-30 00:11:42 +02:00
|
|
|
}
|
2007-04-17 03:42:50 +02:00
|
|
|
|
2013-04-22 21:52:11 +02:00
|
|
|
/* Include broken references in a do_for_each_ref*() iteration: */
|
|
|
|
#define DO_FOR_EACH_INCLUDE_BROKEN 0x01
|
2007-04-17 03:42:50 +02:00
|
|
|
|
2013-04-22 21:52:18 +02:00
|
|
|
/*
|
|
|
|
* Return true iff the reference described by entry can be resolved to
|
|
|
|
* an object in the database. Emit a warning if the referred-to
|
|
|
|
* object does not exist.
|
|
|
|
*/
|
|
|
|
static int ref_resolves_to_object(struct ref_entry *entry)
|
|
|
|
{
|
|
|
|
if (entry->flag & REF_ISBROKEN)
|
|
|
|
return 0;
|
|
|
|
if (!has_sha1_file(entry->u.value.sha1)) {
|
|
|
|
error("%s does not point to a valid object!", entry->name);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-04-22 21:52:12 +02:00
|
|
|
/*
|
|
|
|
* current_ref is a performance hack: when iterating over references
|
|
|
|
* using the for_each_ref*() functions, current_ref is set to the
|
|
|
|
* current reference's entry before calling the callback function. If
|
|
|
|
* the callback function calls peel_ref(), then peel_ref() first
|
|
|
|
* checks whether the reference to be peeled is the current reference
|
|
|
|
* (it usually is) and if so, returns that reference's peeled version
|
|
|
|
* if it is available. This avoids a refname lookup in a common case.
|
|
|
|
*/
|
2012-04-10 07:30:13 +02:00
|
|
|
static struct ref_entry *current_ref;
|
2007-04-17 03:42:50 +02:00
|
|
|
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
typedef int each_ref_entry_fn(struct ref_entry *entry, void *cb_data);
|
|
|
|
|
|
|
|
struct ref_entry_cb {
|
|
|
|
const char *base;
|
|
|
|
int trim;
|
|
|
|
int flags;
|
|
|
|
each_ref_fn *fn;
|
|
|
|
void *cb_data;
|
|
|
|
};
|
|
|
|
|
2013-04-22 21:52:11 +02:00
|
|
|
/*
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
* Handle one reference in a do_for_each_ref*()-style iteration,
|
|
|
|
* calling an each_ref_fn for each entry.
|
2013-04-22 21:52:11 +02:00
|
|
|
*/
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
static int do_one_ref(struct ref_entry *entry, void *cb_data)
|
2012-04-10 07:30:13 +02:00
|
|
|
{
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
struct ref_entry_cb *data = cb_data;
|
2012-04-10 07:30:14 +02:00
|
|
|
int retval;
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
if (prefixcmp(entry->name, data->base))
|
2012-04-10 07:30:13 +02:00
|
|
|
return 0;
|
2007-04-17 03:42:50 +02:00
|
|
|
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
if (!(data->flags & DO_FOR_EACH_INCLUDE_BROKEN) &&
|
2013-04-22 21:52:18 +02:00
|
|
|
!ref_resolves_to_object(entry))
|
|
|
|
return 0;
|
|
|
|
|
2012-04-10 07:30:13 +02:00
|
|
|
current_ref = entry;
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
retval = data->fn(entry->name + data->trim, entry->u.value.sha1,
|
|
|
|
entry->flag, data->cb_data);
|
2012-04-10 07:30:14 +02:00
|
|
|
current_ref = NULL;
|
|
|
|
return retval;
|
2012-04-10 07:30:13 +02:00
|
|
|
}
|
2007-04-17 03:42:50 +02:00
|
|
|
|
2012-04-10 07:30:15 +02:00
|
|
|
/*
|
2012-04-10 07:30:24 +02:00
|
|
|
* Call fn for each reference in dir that has index in the range
|
2012-04-10 07:30:26 +02:00
|
|
|
* offset <= index < dir->nr. Recurse into subdirectories that are in
|
|
|
|
* that index range, sorting them before iterating. This function
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
* does not sort dir itself; it should be sorted beforehand. fn is
|
|
|
|
* called for all references, including broken ones.
|
2012-04-10 07:30:15 +02:00
|
|
|
*/
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
static int do_for_each_entry_in_dir(struct ref_dir *dir, int offset,
|
|
|
|
each_ref_entry_fn fn, void *cb_data)
|
2012-04-10 07:30:15 +02:00
|
|
|
{
|
|
|
|
int i;
|
2012-04-10 07:30:24 +02:00
|
|
|
assert(dir->sorted == dir->nr);
|
|
|
|
for (i = offset; i < dir->nr; i++) {
|
2012-04-10 07:30:26 +02:00
|
|
|
struct ref_entry *entry = dir->entries[i];
|
|
|
|
int retval;
|
|
|
|
if (entry->flag & REF_DIR) {
|
2012-04-27 00:27:03 +02:00
|
|
|
struct ref_dir *subdir = get_ref_dir(entry);
|
|
|
|
sort_ref_dir(subdir);
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
retval = do_for_each_entry_in_dir(subdir, 0, fn, cb_data);
|
2012-04-10 07:30:26 +02:00
|
|
|
} else {
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
retval = fn(entry, cb_data);
|
2012-04-10 07:30:26 +02:00
|
|
|
}
|
2012-04-10 07:30:15 +02:00
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-04-10 07:30:16 +02:00
|
|
|
/*
|
2012-04-10 07:30:24 +02:00
|
|
|
* Call fn for each reference in the union of dir1 and dir2, in order
|
2012-04-10 07:30:26 +02:00
|
|
|
* by refname. Recurse into subdirectories. If a value entry appears
|
|
|
|
* in both dir1 and dir2, then only process the version that is in
|
|
|
|
* dir2. The input dirs must already be sorted, but subdirs will be
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
* sorted as needed. fn is called for all references, including
|
|
|
|
* broken ones.
|
2012-04-10 07:30:16 +02:00
|
|
|
*/
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
static int do_for_each_entry_in_dirs(struct ref_dir *dir1,
|
|
|
|
struct ref_dir *dir2,
|
|
|
|
each_ref_entry_fn fn, void *cb_data)
|
2012-04-10 07:30:16 +02:00
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
int i1 = 0, i2 = 0;
|
|
|
|
|
2012-04-10 07:30:24 +02:00
|
|
|
assert(dir1->sorted == dir1->nr);
|
|
|
|
assert(dir2->sorted == dir2->nr);
|
2012-04-10 07:30:26 +02:00
|
|
|
while (1) {
|
|
|
|
struct ref_entry *e1, *e2;
|
|
|
|
int cmp;
|
|
|
|
if (i1 == dir1->nr) {
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
return do_for_each_entry_in_dir(dir2, i2, fn, cb_data);
|
2012-04-10 07:30:26 +02:00
|
|
|
}
|
|
|
|
if (i2 == dir2->nr) {
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
return do_for_each_entry_in_dir(dir1, i1, fn, cb_data);
|
2012-04-10 07:30:26 +02:00
|
|
|
}
|
|
|
|
e1 = dir1->entries[i1];
|
|
|
|
e2 = dir2->entries[i2];
|
|
|
|
cmp = strcmp(e1->name, e2->name);
|
|
|
|
if (cmp == 0) {
|
|
|
|
if ((e1->flag & REF_DIR) && (e2->flag & REF_DIR)) {
|
|
|
|
/* Both are directories; descend them in parallel. */
|
2012-04-27 00:27:03 +02:00
|
|
|
struct ref_dir *subdir1 = get_ref_dir(e1);
|
|
|
|
struct ref_dir *subdir2 = get_ref_dir(e2);
|
|
|
|
sort_ref_dir(subdir1);
|
|
|
|
sort_ref_dir(subdir2);
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
retval = do_for_each_entry_in_dirs(
|
|
|
|
subdir1, subdir2, fn, cb_data);
|
2012-04-10 07:30:26 +02:00
|
|
|
i1++;
|
|
|
|
i2++;
|
|
|
|
} else if (!(e1->flag & REF_DIR) && !(e2->flag & REF_DIR)) {
|
|
|
|
/* Both are references; ignore the one from dir1. */
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
retval = fn(e2, cb_data);
|
2012-04-10 07:30:26 +02:00
|
|
|
i1++;
|
|
|
|
i2++;
|
|
|
|
} else {
|
|
|
|
die("conflict between reference and directory: %s",
|
|
|
|
e1->name);
|
|
|
|
}
|
2012-04-10 07:30:16 +02:00
|
|
|
} else {
|
2012-04-10 07:30:26 +02:00
|
|
|
struct ref_entry *e;
|
|
|
|
if (cmp < 0) {
|
|
|
|
e = e1;
|
2012-04-10 07:30:16 +02:00
|
|
|
i1++;
|
2012-04-10 07:30:26 +02:00
|
|
|
} else {
|
|
|
|
e = e2;
|
|
|
|
i2++;
|
|
|
|
}
|
|
|
|
if (e->flag & REF_DIR) {
|
2012-04-27 00:27:03 +02:00
|
|
|
struct ref_dir *subdir = get_ref_dir(e);
|
|
|
|
sort_ref_dir(subdir);
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
retval = do_for_each_entry_in_dir(
|
|
|
|
subdir, 0, fn, cb_data);
|
2012-04-10 07:30:26 +02:00
|
|
|
} else {
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
retval = fn(e, cb_data);
|
2012-04-10 07:30:16 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-10 07:30:17 +02:00
|
|
|
/*
|
|
|
|
* Return true iff refname1 and refname2 conflict with each other.
|
|
|
|
* Two reference names conflict if one of them exactly matches the
|
|
|
|
* leading components of the other; e.g., "foo/bar" conflicts with
|
|
|
|
* both "foo" and with "foo/bar/baz" but not with "foo/bar" or
|
|
|
|
* "foo/barbados".
|
|
|
|
*/
|
|
|
|
static int names_conflict(const char *refname1, const char *refname2)
|
|
|
|
{
|
2012-04-10 07:30:19 +02:00
|
|
|
for (; *refname1 && *refname1 == *refname2; refname1++, refname2++)
|
|
|
|
;
|
|
|
|
return (*refname1 == '\0' && *refname2 == '/')
|
|
|
|
|| (*refname1 == '/' && *refname2 == '\0');
|
|
|
|
}
|
|
|
|
|
|
|
|
struct name_conflict_cb {
|
|
|
|
const char *refname;
|
|
|
|
const char *oldrefname;
|
|
|
|
const char *conflicting_refname;
|
|
|
|
};
|
|
|
|
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
static int name_conflict_fn(struct ref_entry *entry, void *cb_data)
|
2012-04-10 07:30:19 +02:00
|
|
|
{
|
|
|
|
struct name_conflict_cb *data = (struct name_conflict_cb *)cb_data;
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
if (data->oldrefname && !strcmp(data->oldrefname, entry->name))
|
2012-04-10 07:30:19 +02:00
|
|
|
return 0;
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
if (names_conflict(data->refname, entry->name)) {
|
|
|
|
data->conflicting_refname = entry->name;
|
2012-04-10 07:30:19 +02:00
|
|
|
return 1;
|
2012-04-10 07:30:17 +02:00
|
|
|
}
|
2012-04-10 07:30:19 +02:00
|
|
|
return 0;
|
2012-04-10 07:30:17 +02:00
|
|
|
}
|
|
|
|
|
2012-04-10 07:30:13 +02:00
|
|
|
/*
|
|
|
|
* Return true iff a reference named refname could be created without
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
* conflicting with the name of an existing reference in dir. If
|
2012-04-10 07:30:19 +02:00
|
|
|
* oldrefname is non-NULL, ignore potential conflicts with oldrefname
|
|
|
|
* (e.g., because oldrefname is scheduled for deletion in the same
|
2012-04-10 07:30:13 +02:00
|
|
|
* operation).
|
|
|
|
*/
|
|
|
|
static int is_refname_available(const char *refname, const char *oldrefname,
|
2012-04-10 07:30:24 +02:00
|
|
|
struct ref_dir *dir)
|
2012-04-10 07:30:13 +02:00
|
|
|
{
|
2012-04-10 07:30:19 +02:00
|
|
|
struct name_conflict_cb data;
|
|
|
|
data.refname = refname;
|
|
|
|
data.oldrefname = oldrefname;
|
|
|
|
data.conflicting_refname = NULL;
|
|
|
|
|
2012-04-10 07:30:24 +02:00
|
|
|
sort_ref_dir(dir);
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
if (do_for_each_entry_in_dir(dir, 0, name_conflict_fn, &data)) {
|
2012-04-10 07:30:19 +02:00
|
|
|
error("'%s' exists; cannot create '%s'",
|
|
|
|
data.conflicting_refname, refname);
|
|
|
|
return 0;
|
2012-04-10 07:30:13 +02:00
|
|
|
}
|
|
|
|
return 1;
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
}
|
|
|
|
|
2006-09-30 21:37:37 +02:00
|
|
|
/*
|
|
|
|
* Future: need to be in "struct repository"
|
|
|
|
* when doing a full libification.
|
|
|
|
*/
|
2011-10-17 04:38:05 +02:00
|
|
|
static struct ref_cache {
|
|
|
|
struct ref_cache *next;
|
2012-04-27 00:27:01 +02:00
|
|
|
struct ref_entry *loose;
|
|
|
|
struct ref_entry *packed;
|
2011-08-13 00:36:28 +02:00
|
|
|
/* The submodule name, or "" for the main repo. */
|
|
|
|
char name[FLEX_ARRAY];
|
2011-10-17 04:38:05 +02:00
|
|
|
} *ref_cache;
|
2011-08-13 00:36:29 +02:00
|
|
|
|
2011-10-17 04:38:09 +02:00
|
|
|
static void clear_packed_ref_cache(struct ref_cache *refs)
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
{
|
2012-04-27 00:27:01 +02:00
|
|
|
if (refs->packed) {
|
|
|
|
free_ref_entry(refs->packed);
|
|
|
|
refs->packed = NULL;
|
|
|
|
}
|
2006-09-30 21:37:37 +02:00
|
|
|
}
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
|
2011-10-17 04:38:09 +02:00
|
|
|
static void clear_loose_ref_cache(struct ref_cache *refs)
|
|
|
|
{
|
2012-04-27 00:27:01 +02:00
|
|
|
if (refs->loose) {
|
|
|
|
free_ref_entry(refs->loose);
|
|
|
|
refs->loose = NULL;
|
|
|
|
}
|
2011-10-17 04:38:09 +02:00
|
|
|
}
|
|
|
|
|
2011-10-17 04:38:05 +02:00
|
|
|
static struct ref_cache *create_ref_cache(const char *submodule)
|
2011-08-13 00:36:27 +02:00
|
|
|
{
|
2011-08-13 00:36:28 +02:00
|
|
|
int len;
|
2011-10-17 04:38:05 +02:00
|
|
|
struct ref_cache *refs;
|
2011-08-13 00:36:28 +02:00
|
|
|
if (!submodule)
|
|
|
|
submodule = "";
|
|
|
|
len = strlen(submodule) + 1;
|
2011-10-17 04:38:05 +02:00
|
|
|
refs = xcalloc(1, sizeof(struct ref_cache) + len);
|
2011-08-13 00:36:28 +02:00
|
|
|
memcpy(refs->name, submodule, len);
|
2011-08-13 00:36:27 +02:00
|
|
|
return refs;
|
|
|
|
}
|
|
|
|
|
2011-08-13 00:36:25 +02:00
|
|
|
/*
|
2011-10-17 04:38:05 +02:00
|
|
|
* Return a pointer to a ref_cache for the specified submodule. For
|
2011-08-13 00:36:25 +02:00
|
|
|
* the main repository, use submodule==NULL. The returned structure
|
|
|
|
* will be allocated and initialized but not necessarily populated; it
|
|
|
|
* should not be freed.
|
|
|
|
*/
|
2011-10-17 04:38:05 +02:00
|
|
|
static struct ref_cache *get_ref_cache(const char *submodule)
|
2011-08-13 00:36:25 +02:00
|
|
|
{
|
2011-10-17 04:38:05 +02:00
|
|
|
struct ref_cache *refs = ref_cache;
|
2011-08-13 00:36:29 +02:00
|
|
|
if (!submodule)
|
|
|
|
submodule = "";
|
|
|
|
while (refs) {
|
|
|
|
if (!strcmp(submodule, refs->name))
|
|
|
|
return refs;
|
|
|
|
refs = refs->next;
|
2011-08-13 00:36:25 +02:00
|
|
|
}
|
2011-08-13 00:36:29 +02:00
|
|
|
|
2011-10-17 04:38:05 +02:00
|
|
|
refs = create_ref_cache(submodule);
|
|
|
|
refs->next = ref_cache;
|
|
|
|
ref_cache = refs;
|
2011-08-13 00:36:29 +02:00
|
|
|
return refs;
|
2011-08-13 00:36:25 +02:00
|
|
|
}
|
|
|
|
|
2011-10-17 04:38:07 +02:00
|
|
|
void invalidate_ref_cache(const char *submodule)
|
2011-08-13 00:36:24 +02:00
|
|
|
{
|
2011-10-17 04:38:11 +02:00
|
|
|
struct ref_cache *refs = get_ref_cache(submodule);
|
|
|
|
clear_packed_ref_cache(refs);
|
|
|
|
clear_loose_ref_cache(refs);
|
2006-09-30 21:37:37 +02:00
|
|
|
}
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
|
2013-04-22 21:52:13 +02:00
|
|
|
/* The length of a peeled reference line in packed-refs, including EOL: */
|
|
|
|
#define PEELED_LINE_LENGTH 42
|
|
|
|
|
repack_without_ref(): write peeled refs in the rewritten file
When a reference that existed in the packed-refs file is deleted, the
packed-refs file must be rewritten. Previously, the file was
rewritten without any peeled refs, even if the file contained peeled
refs when it was read. This was not a bug, because the packed-refs
file header didn't claim that the file contained peeled values. But
it had a performance cost, because the repository would lose the
benefit of having precomputed peeled references until pack-refs was
run again.
Teach repack_without_ref() to write peeled refs to the packed-refs
file (regardless of whether they were present in the old version of
the file).
This means that if the old version of the packed-refs file was not
fully peeled, then repack_without_ref() will have to peel references.
To avoid the expense of reading lots of loose references, we take two
shortcuts relative to pack-refs:
* If the peeled value of a reference is already known (i.e., because
it was read from the old version of the packed-refs file), then
output that peeled value again without any checks. This is the
usual code path and should avoid any noticeable overhead. (This is
different than pack-refs, which always re-peels references.)
* We don't verify that the packed ref is still current. It could be
that a packed references is overridden by a loose reference, in
which case the packed ref is no longer needed and might even refer
to an object that has been garbage collected. But we don't check;
instead, we just try to peel all references. If peeling is
successful, the peeled value is written out (even though it might
not be needed any more); if not, then the reference is silently
omitted from the output.
The extra overhead of peeling references in repack_without_ref()
should only be incurred the first time the packed-refs file is written
by a version of Git that knows about the "fully-peeled" attribute.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:29 +02:00
|
|
|
/*
|
|
|
|
* The packed-refs header line that we write out. Perhaps other
|
|
|
|
* traits will be added later. The trailing space is required.
|
|
|
|
*/
|
|
|
|
static const char PACKED_REFS_HEADER[] =
|
|
|
|
"# pack-refs with: peeled fully-peeled \n";
|
|
|
|
|
2012-04-10 07:30:13 +02:00
|
|
|
/*
|
|
|
|
* Parse one line from a packed-refs file. Write the SHA1 to sha1.
|
|
|
|
* Return a pointer to the refname within the line (null-terminated),
|
|
|
|
* or NULL if there was a problem.
|
|
|
|
*/
|
|
|
|
static const char *parse_ref_line(char *line, unsigned char *sha1)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* 42: the answer to everything.
|
|
|
|
*
|
|
|
|
* In this case, it happens to be the answer to
|
|
|
|
* 40 (length of sha1 hex representation)
|
|
|
|
* +1 (space in between hex and name)
|
|
|
|
* +1 (newline at the end of the line)
|
|
|
|
*/
|
|
|
|
int len = strlen(line) - 42;
|
|
|
|
|
|
|
|
if (len <= 0)
|
|
|
|
return NULL;
|
|
|
|
if (get_sha1_hex(line, sha1) < 0)
|
|
|
|
return NULL;
|
|
|
|
if (!isspace(line[40]))
|
|
|
|
return NULL;
|
|
|
|
line += 41;
|
|
|
|
if (isspace(*line))
|
|
|
|
return NULL;
|
|
|
|
if (line[len] != '\n')
|
|
|
|
return NULL;
|
|
|
|
line[len] = 0;
|
|
|
|
|
|
|
|
return line;
|
|
|
|
}
|
|
|
|
|
pack-refs: add fully-peeled trait
Older versions of pack-refs did not write peel lines for
refs outside of refs/tags. This meant that on reading the
pack-refs file, we might set the REF_KNOWS_PEELED flag for
such a ref, even though we do not know anything about its
peeled value.
The previous commit updated the writer to always peel, no
matter what the ref is. That means that packed-refs files
written by newer versions of git are fine to be read by both
old and new versions of git. However, we still have the
problem of reading packed-refs files written by older
versions of git, or by other implementations which have not
yet learned the same trick.
The simplest fix would be to always unset the
REF_KNOWS_PEELED flag for refs outside of refs/tags that do
not have a peel line (if it has a peel line, we know it is
valid, but we cannot assume a missing peel line means
anything). But that loses an important optimization, as
upload-pack should not need to load the object pointed to by
refs/heads/foo to determine that it is not a tag.
Instead, we add a "fully-peeled" trait to the packed-refs
file. If it is set, we know that we can trust a missing peel
line to mean that a ref cannot be peeled. Otherwise, we fall
back to assuming nothing.
[commit message and tests by Jeff King <peff@peff.net>]
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-18 12:37:32 +01:00
|
|
|
/*
|
|
|
|
* Read f, which is a packed-refs file, into dir.
|
|
|
|
*
|
|
|
|
* A comment line of the form "# pack-refs with: " may contain zero or
|
|
|
|
* more traits. We interpret the traits as follows:
|
|
|
|
*
|
|
|
|
* No traits:
|
|
|
|
*
|
|
|
|
* Probably no references are peeled. But if the file contains a
|
|
|
|
* peeled value for a reference, we will use it.
|
|
|
|
*
|
|
|
|
* peeled:
|
|
|
|
*
|
|
|
|
* References under "refs/tags/", if they *can* be peeled, *are*
|
|
|
|
* peeled in this file. References outside of "refs/tags/" are
|
|
|
|
* probably not peeled even if they could have been, but if we find
|
|
|
|
* a peeled value for such a reference we will use it.
|
|
|
|
*
|
|
|
|
* fully-peeled:
|
|
|
|
*
|
|
|
|
* All references in the file that can be peeled are peeled.
|
|
|
|
* Inversely (and this is more important), any references in the
|
|
|
|
* file for which no peeled value is recorded is not peelable. This
|
|
|
|
* trait should typically be written alongside "peeled" for
|
|
|
|
* compatibility with older clients, but we do not require it
|
|
|
|
* (i.e., "peeled" is a no-op if "fully-peeled" is set).
|
|
|
|
*/
|
2012-04-10 07:30:24 +02:00
|
|
|
static void read_packed_refs(FILE *f, struct ref_dir *dir)
|
2006-11-22 08:36:35 +01:00
|
|
|
{
|
2011-09-30 00:11:42 +02:00
|
|
|
struct ref_entry *last = NULL;
|
2006-11-22 08:36:35 +01:00
|
|
|
char refline[PATH_MAX];
|
pack-refs: add fully-peeled trait
Older versions of pack-refs did not write peel lines for
refs outside of refs/tags. This meant that on reading the
pack-refs file, we might set the REF_KNOWS_PEELED flag for
such a ref, even though we do not know anything about its
peeled value.
The previous commit updated the writer to always peel, no
matter what the ref is. That means that packed-refs files
written by newer versions of git are fine to be read by both
old and new versions of git. However, we still have the
problem of reading packed-refs files written by older
versions of git, or by other implementations which have not
yet learned the same trick.
The simplest fix would be to always unset the
REF_KNOWS_PEELED flag for refs outside of refs/tags that do
not have a peel line (if it has a peel line, we know it is
valid, but we cannot assume a missing peel line means
anything). But that loses an important optimization, as
upload-pack should not need to load the object pointed to by
refs/heads/foo to determine that it is not a tag.
Instead, we add a "fully-peeled" trait to the packed-refs
file. If it is set, we know that we can trust a missing peel
line to mean that a ref cannot be peeled. Otherwise, we fall
back to assuming nothing.
[commit message and tests by Jeff King <peff@peff.net>]
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-18 12:37:32 +01:00
|
|
|
enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled = PEELED_NONE;
|
2006-11-22 08:36:35 +01:00
|
|
|
|
|
|
|
while (fgets(refline, sizeof(refline), f)) {
|
|
|
|
unsigned char sha1[20];
|
2011-12-12 06:38:09 +01:00
|
|
|
const char *refname;
|
2006-11-22 08:36:35 +01:00
|
|
|
static const char header[] = "# pack-refs with:";
|
|
|
|
|
|
|
|
if (!strncmp(refline, header, sizeof(header)-1)) {
|
|
|
|
const char *traits = refline + sizeof(header) - 1;
|
pack-refs: add fully-peeled trait
Older versions of pack-refs did not write peel lines for
refs outside of refs/tags. This meant that on reading the
pack-refs file, we might set the REF_KNOWS_PEELED flag for
such a ref, even though we do not know anything about its
peeled value.
The previous commit updated the writer to always peel, no
matter what the ref is. That means that packed-refs files
written by newer versions of git are fine to be read by both
old and new versions of git. However, we still have the
problem of reading packed-refs files written by older
versions of git, or by other implementations which have not
yet learned the same trick.
The simplest fix would be to always unset the
REF_KNOWS_PEELED flag for refs outside of refs/tags that do
not have a peel line (if it has a peel line, we know it is
valid, but we cannot assume a missing peel line means
anything). But that loses an important optimization, as
upload-pack should not need to load the object pointed to by
refs/heads/foo to determine that it is not a tag.
Instead, we add a "fully-peeled" trait to the packed-refs
file. If it is set, we know that we can trust a missing peel
line to mean that a ref cannot be peeled. Otherwise, we fall
back to assuming nothing.
[commit message and tests by Jeff King <peff@peff.net>]
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-18 12:37:32 +01:00
|
|
|
if (strstr(traits, " fully-peeled "))
|
|
|
|
peeled = PEELED_FULLY;
|
|
|
|
else if (strstr(traits, " peeled "))
|
|
|
|
peeled = PEELED_TAGS;
|
2006-11-22 08:36:35 +01:00
|
|
|
/* perhaps other traits later as well */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
refname = parse_ref_line(refline, sha1);
|
|
|
|
if (refname) {
|
pack-refs: add fully-peeled trait
Older versions of pack-refs did not write peel lines for
refs outside of refs/tags. This meant that on reading the
pack-refs file, we might set the REF_KNOWS_PEELED flag for
such a ref, even though we do not know anything about its
peeled value.
The previous commit updated the writer to always peel, no
matter what the ref is. That means that packed-refs files
written by newer versions of git are fine to be read by both
old and new versions of git. However, we still have the
problem of reading packed-refs files written by older
versions of git, or by other implementations which have not
yet learned the same trick.
The simplest fix would be to always unset the
REF_KNOWS_PEELED flag for refs outside of refs/tags that do
not have a peel line (if it has a peel line, we know it is
valid, but we cannot assume a missing peel line means
anything). But that loses an important optimization, as
upload-pack should not need to load the object pointed to by
refs/heads/foo to determine that it is not a tag.
Instead, we add a "fully-peeled" trait to the packed-refs
file. If it is set, we know that we can trust a missing peel
line to mean that a ref cannot be peeled. Otherwise, we fall
back to assuming nothing.
[commit message and tests by Jeff King <peff@peff.net>]
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-18 12:37:32 +01:00
|
|
|
last = create_ref_entry(refname, sha1, REF_ISPACKED, 1);
|
|
|
|
if (peeled == PEELED_FULLY ||
|
|
|
|
(peeled == PEELED_TAGS && !prefixcmp(refname, "refs/tags/")))
|
|
|
|
last->flag |= REF_KNOWS_PEELED;
|
2012-04-10 07:30:24 +02:00
|
|
|
add_ref(dir, last);
|
2006-11-22 08:36:35 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (last &&
|
|
|
|
refline[0] == '^' &&
|
2013-04-22 21:52:13 +02:00
|
|
|
strlen(refline) == PEELED_LINE_LENGTH &&
|
|
|
|
refline[PEELED_LINE_LENGTH - 1] == '\n' &&
|
pack-refs: add fully-peeled trait
Older versions of pack-refs did not write peel lines for
refs outside of refs/tags. This meant that on reading the
pack-refs file, we might set the REF_KNOWS_PEELED flag for
such a ref, even though we do not know anything about its
peeled value.
The previous commit updated the writer to always peel, no
matter what the ref is. That means that packed-refs files
written by newer versions of git are fine to be read by both
old and new versions of git. However, we still have the
problem of reading packed-refs files written by older
versions of git, or by other implementations which have not
yet learned the same trick.
The simplest fix would be to always unset the
REF_KNOWS_PEELED flag for refs outside of refs/tags that do
not have a peel line (if it has a peel line, we know it is
valid, but we cannot assume a missing peel line means
anything). But that loses an important optimization, as
upload-pack should not need to load the object pointed to by
refs/heads/foo to determine that it is not a tag.
Instead, we add a "fully-peeled" trait to the packed-refs
file. If it is set, we know that we can trust a missing peel
line to mean that a ref cannot be peeled. Otherwise, we fall
back to assuming nothing.
[commit message and tests by Jeff King <peff@peff.net>]
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-18 12:37:32 +01:00
|
|
|
!get_sha1_hex(refline + 1, sha1)) {
|
2012-04-10 07:30:23 +02:00
|
|
|
hashcpy(last->u.value.peeled, sha1);
|
pack-refs: add fully-peeled trait
Older versions of pack-refs did not write peel lines for
refs outside of refs/tags. This meant that on reading the
pack-refs file, we might set the REF_KNOWS_PEELED flag for
such a ref, even though we do not know anything about its
peeled value.
The previous commit updated the writer to always peel, no
matter what the ref is. That means that packed-refs files
written by newer versions of git are fine to be read by both
old and new versions of git. However, we still have the
problem of reading packed-refs files written by older
versions of git, or by other implementations which have not
yet learned the same trick.
The simplest fix would be to always unset the
REF_KNOWS_PEELED flag for refs outside of refs/tags that do
not have a peel line (if it has a peel line, we know it is
valid, but we cannot assume a missing peel line means
anything). But that loses an important optimization, as
upload-pack should not need to load the object pointed to by
refs/heads/foo to determine that it is not a tag.
Instead, we add a "fully-peeled" trait to the packed-refs
file. If it is set, we know that we can trust a missing peel
line to mean that a ref cannot be peeled. Otherwise, we fall
back to assuming nothing.
[commit message and tests by Jeff King <peff@peff.net>]
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-18 12:37:32 +01:00
|
|
|
/*
|
|
|
|
* Regardless of what the file header said,
|
|
|
|
* we definitely know the value of *this*
|
|
|
|
* reference:
|
|
|
|
*/
|
|
|
|
last->flag |= REF_KNOWS_PEELED;
|
|
|
|
}
|
2006-11-22 08:36:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-10 07:30:24 +02:00
|
|
|
static struct ref_dir *get_packed_refs(struct ref_cache *refs)
|
2006-09-30 21:37:37 +02:00
|
|
|
{
|
2012-04-27 00:27:01 +02:00
|
|
|
if (!refs->packed) {
|
2011-08-13 00:36:25 +02:00
|
|
|
const char *packed_refs_file;
|
|
|
|
FILE *f;
|
2010-07-07 15:39:11 +02:00
|
|
|
|
2012-05-22 20:50:52 +02:00
|
|
|
refs->packed = create_dir_entry(refs, "", 0, 0);
|
2011-12-12 06:38:16 +01:00
|
|
|
if (*refs->name)
|
|
|
|
packed_refs_file = git_path_submodule(refs->name, "packed-refs");
|
2011-08-13 00:36:25 +02:00
|
|
|
else
|
|
|
|
packed_refs_file = git_path("packed-refs");
|
|
|
|
f = fopen(packed_refs_file, "r");
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
if (f) {
|
2012-04-27 00:27:03 +02:00
|
|
|
read_packed_refs(f, get_ref_dir(refs->packed));
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
fclose(f);
|
|
|
|
}
|
|
|
|
}
|
2012-04-27 00:27:03 +02:00
|
|
|
return get_ref_dir(refs->packed);
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
}
|
|
|
|
|
2012-01-17 06:50:33 +01:00
|
|
|
void add_packed_ref(const char *refname, const unsigned char *sha1)
|
|
|
|
{
|
|
|
|
add_ref(get_packed_refs(get_ref_cache(NULL)),
|
|
|
|
create_ref_entry(refname, sha1, REF_ISPACKED, 1));
|
|
|
|
}
|
|
|
|
|
2012-04-25 00:45:10 +02:00
|
|
|
/*
|
2012-04-27 00:27:07 +02:00
|
|
|
* Read the loose references from the namespace dirname into dir
|
|
|
|
* (without recursing). dirname must end with '/'. dir must be the
|
|
|
|
* directory entry corresponding to dirname.
|
2012-04-25 00:45:10 +02:00
|
|
|
*/
|
2012-04-27 00:27:06 +02:00
|
|
|
static void read_loose_refs(const char *dirname, struct ref_dir *dir)
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
{
|
2012-04-27 00:27:06 +02:00
|
|
|
struct ref_cache *refs = dir->ref_cache;
|
2012-04-10 07:30:24 +02:00
|
|
|
DIR *d;
|
2010-07-07 15:39:11 +02:00
|
|
|
const char *path;
|
2012-04-25 00:45:07 +02:00
|
|
|
struct dirent *de;
|
2012-04-25 00:45:10 +02:00
|
|
|
int dirnamelen = strlen(dirname);
|
2012-04-25 00:45:08 +02:00
|
|
|
struct strbuf refname;
|
2010-07-07 15:39:11 +02:00
|
|
|
|
2011-12-12 06:38:17 +01:00
|
|
|
if (*refs->name)
|
2012-04-25 00:45:09 +02:00
|
|
|
path = git_path_submodule(refs->name, "%s", dirname);
|
2010-07-07 15:39:11 +02:00
|
|
|
else
|
2012-04-25 00:45:09 +02:00
|
|
|
path = git_path("%s", dirname);
|
2010-07-07 15:39:11 +02:00
|
|
|
|
2012-04-10 07:30:24 +02:00
|
|
|
d = opendir(path);
|
2012-04-25 00:45:07 +02:00
|
|
|
if (!d)
|
|
|
|
return;
|
|
|
|
|
2012-04-25 00:45:09 +02:00
|
|
|
strbuf_init(&refname, dirnamelen + 257);
|
|
|
|
strbuf_add(&refname, dirname, dirnamelen);
|
2012-04-25 00:45:07 +02:00
|
|
|
|
|
|
|
while ((de = readdir(d)) != NULL) {
|
|
|
|
unsigned char sha1[20];
|
|
|
|
struct stat st;
|
|
|
|
int flag;
|
|
|
|
const char *refdir;
|
|
|
|
|
|
|
|
if (de->d_name[0] == '.')
|
|
|
|
continue;
|
|
|
|
if (has_extension(de->d_name, ".lock"))
|
|
|
|
continue;
|
2012-04-25 00:45:08 +02:00
|
|
|
strbuf_addstr(&refname, de->d_name);
|
2012-04-25 00:45:07 +02:00
|
|
|
refdir = *refs->name
|
2012-04-25 00:45:08 +02:00
|
|
|
? git_path_submodule(refs->name, "%s", refname.buf)
|
|
|
|
: git_path("%s", refname.buf);
|
|
|
|
if (stat(refdir, &st) < 0) {
|
|
|
|
; /* silently ignore */
|
|
|
|
} else if (S_ISDIR(st.st_mode)) {
|
2012-04-25 00:45:10 +02:00
|
|
|
strbuf_addch(&refname, '/');
|
2012-04-27 00:27:07 +02:00
|
|
|
add_entry_to_dir(dir,
|
2012-05-22 20:50:52 +02:00
|
|
|
create_dir_entry(refs, refname.buf,
|
|
|
|
refname.len, 1));
|
2012-04-25 00:45:08 +02:00
|
|
|
} else {
|
2011-12-12 06:38:17 +01:00
|
|
|
if (*refs->name) {
|
2009-02-09 08:27:10 +01:00
|
|
|
hashclr(sha1);
|
2010-07-07 15:39:11 +02:00
|
|
|
flag = 0;
|
2012-04-25 00:45:08 +02:00
|
|
|
if (resolve_gitlink_ref(refs->name, refname.buf, sha1) < 0) {
|
2010-07-07 15:39:11 +02:00
|
|
|
hashclr(sha1);
|
2011-10-19 22:45:50 +02:00
|
|
|
flag |= REF_ISBROKEN;
|
2010-07-07 15:39:11 +02:00
|
|
|
}
|
2012-04-25 00:45:08 +02:00
|
|
|
} else if (read_ref_full(refname.buf, sha1, 1, &flag)) {
|
2011-11-17 01:54:32 +01:00
|
|
|
hashclr(sha1);
|
|
|
|
flag |= REF_ISBROKEN;
|
|
|
|
}
|
2012-04-25 00:45:12 +02:00
|
|
|
add_entry_to_dir(dir,
|
|
|
|
create_ref_entry(refname.buf, sha1, flag, 1));
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
}
|
2012-04-25 00:45:09 +02:00
|
|
|
strbuf_setlen(&refname, dirnamelen);
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
}
|
2012-04-25 00:45:08 +02:00
|
|
|
strbuf_release(&refname);
|
2012-04-25 00:45:07 +02:00
|
|
|
closedir(d);
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
}
|
|
|
|
|
2012-04-10 07:30:24 +02:00
|
|
|
static struct ref_dir *get_loose_refs(struct ref_cache *refs)
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
{
|
2012-04-27 00:27:01 +02:00
|
|
|
if (!refs->loose) {
|
2012-04-27 00:27:07 +02:00
|
|
|
/*
|
|
|
|
* Mark the top-level directory complete because we
|
|
|
|
* are about to read the only subdirectory that can
|
|
|
|
* hold references:
|
|
|
|
*/
|
2012-05-22 20:50:52 +02:00
|
|
|
refs->loose = create_dir_entry(refs, "", 0, 0);
|
2012-04-27 00:27:07 +02:00
|
|
|
/*
|
|
|
|
* Create an incomplete entry for "refs/":
|
|
|
|
*/
|
|
|
|
add_entry_to_dir(get_ref_dir(refs->loose),
|
2012-05-22 20:50:52 +02:00
|
|
|
create_dir_entry(refs, "refs/", 5, 1));
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
}
|
2012-04-27 00:27:03 +02:00
|
|
|
return get_ref_dir(refs->loose);
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-12 01:37:32 +02:00
|
|
|
}
|
|
|
|
|
2005-09-25 18:59:37 +02:00
|
|
|
/* We allow "recursive" symbolic refs. Only within reason, though */
|
|
|
|
#define MAXDEPTH 5
|
2007-04-10 06:14:26 +02:00
|
|
|
#define MAXREFLEN (1024)
|
|
|
|
|
2011-10-17 20:43:30 +02:00
|
|
|
/*
|
|
|
|
* Called by resolve_gitlink_ref_recursive() after it failed to read
|
2011-12-12 06:38:19 +01:00
|
|
|
* from the loose refs in ref_cache refs. Find <refname> in the
|
|
|
|
* packed-refs file for the submodule.
|
2011-10-17 20:43:30 +02:00
|
|
|
*/
|
2011-12-12 06:38:19 +01:00
|
|
|
static int resolve_gitlink_packed_ref(struct ref_cache *refs,
|
2011-12-12 06:38:10 +01:00
|
|
|
const char *refname, unsigned char *sha1)
|
2007-04-10 06:14:26 +02:00
|
|
|
{
|
2011-10-11 00:56:19 +02:00
|
|
|
struct ref_entry *ref;
|
2012-04-10 07:30:24 +02:00
|
|
|
struct ref_dir *dir = get_packed_refs(refs);
|
2007-04-10 06:14:26 +02:00
|
|
|
|
2012-04-10 07:30:26 +02:00
|
|
|
ref = find_ref(dir, refname);
|
2011-12-12 06:38:19 +01:00
|
|
|
if (ref == NULL)
|
|
|
|
return -1;
|
|
|
|
|
2012-04-10 07:30:23 +02:00
|
|
|
memcpy(sha1, ref->u.value.sha1, 20);
|
2011-12-12 06:38:19 +01:00
|
|
|
return 0;
|
2007-04-10 06:14:26 +02:00
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:19 +01:00
|
|
|
static int resolve_gitlink_ref_recursive(struct ref_cache *refs,
|
2011-12-12 06:38:10 +01:00
|
|
|
const char *refname, unsigned char *sha1,
|
2011-12-12 06:38:09 +01:00
|
|
|
int recursion)
|
2007-04-10 06:14:26 +02:00
|
|
|
{
|
2011-12-12 06:38:20 +01:00
|
|
|
int fd, len;
|
2007-04-10 06:14:26 +02:00
|
|
|
char buffer[128], *p;
|
2011-12-12 06:38:20 +01:00
|
|
|
char *path;
|
2007-04-10 06:14:26 +02:00
|
|
|
|
2011-12-12 06:38:20 +01:00
|
|
|
if (recursion > MAXDEPTH || strlen(refname) > MAXREFLEN)
|
2007-04-10 06:14:26 +02:00
|
|
|
return -1;
|
2011-12-12 06:38:20 +01:00
|
|
|
path = *refs->name
|
|
|
|
? git_path_submodule(refs->name, "%s", refname)
|
|
|
|
: git_path("%s", refname);
|
|
|
|
fd = open(path, O_RDONLY);
|
2007-04-10 06:14:26 +02:00
|
|
|
if (fd < 0)
|
2011-12-12 06:38:19 +01:00
|
|
|
return resolve_gitlink_packed_ref(refs, refname, sha1);
|
2007-04-10 06:14:26 +02:00
|
|
|
|
|
|
|
len = read(fd, buffer, sizeof(buffer)-1);
|
|
|
|
close(fd);
|
|
|
|
if (len < 0)
|
|
|
|
return -1;
|
|
|
|
while (len && isspace(buffer[len-1]))
|
|
|
|
len--;
|
|
|
|
buffer[len] = 0;
|
|
|
|
|
|
|
|
/* Was it a detached head or an old-fashioned symlink? */
|
2011-12-12 06:38:10 +01:00
|
|
|
if (!get_sha1_hex(buffer, sha1))
|
2007-04-10 06:14:26 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Symref? */
|
|
|
|
if (strncmp(buffer, "ref:", 4))
|
|
|
|
return -1;
|
|
|
|
p = buffer + 4;
|
|
|
|
while (isspace(*p))
|
|
|
|
p++;
|
|
|
|
|
2011-12-12 06:38:20 +01:00
|
|
|
return resolve_gitlink_ref_recursive(refs, p, sha1, recursion+1);
|
2007-04-10 06:14:26 +02:00
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:10 +01:00
|
|
|
int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1)
|
2007-04-10 06:14:26 +02:00
|
|
|
{
|
|
|
|
int len = strlen(path), retval;
|
2011-12-12 06:38:20 +01:00
|
|
|
char *submodule;
|
2011-12-12 06:38:19 +01:00
|
|
|
struct ref_cache *refs;
|
2007-04-10 06:14:26 +02:00
|
|
|
|
|
|
|
while (len && path[len-1] == '/')
|
|
|
|
len--;
|
|
|
|
if (!len)
|
|
|
|
return -1;
|
2011-12-12 06:38:19 +01:00
|
|
|
submodule = xstrndup(path, len);
|
|
|
|
refs = get_ref_cache(submodule);
|
|
|
|
free(submodule);
|
|
|
|
|
2011-12-12 06:38:20 +01:00
|
|
|
retval = resolve_gitlink_ref_recursive(refs, refname, sha1, 0);
|
2007-04-10 06:14:26 +02:00
|
|
|
return retval;
|
|
|
|
}
|
2005-09-25 18:59:37 +02:00
|
|
|
|
2008-09-09 07:10:56 +02:00
|
|
|
/*
|
2013-04-22 21:52:15 +02:00
|
|
|
* Return the ref_entry for the given refname from the packed
|
|
|
|
* references. If it does not exist, return NULL.
|
2008-09-09 07:10:56 +02:00
|
|
|
*/
|
2013-04-22 21:52:15 +02:00
|
|
|
static struct ref_entry *get_packed_ref(const char *refname)
|
2011-09-15 23:10:35 +02:00
|
|
|
{
|
2013-04-22 21:52:15 +02:00
|
|
|
return find_ref(get_packed_refs(get_ref_cache(NULL)), refname);
|
2011-09-15 23:10:35 +02:00
|
|
|
}
|
|
|
|
|
2011-12-20 22:25:53 +01:00
|
|
|
const char *resolve_ref_unsafe(const char *refname, unsigned char *sha1, int reading, int *flag)
|
2005-07-03 05:23:36 +02:00
|
|
|
{
|
2008-04-27 20:21:58 +02:00
|
|
|
int depth = MAXDEPTH;
|
|
|
|
ssize_t len;
|
2005-09-30 23:08:25 +02:00
|
|
|
char buffer[256];
|
2011-12-12 06:38:09 +01:00
|
|
|
static char refname_buffer[256];
|
2005-09-25 18:59:37 +02:00
|
|
|
|
2006-09-21 07:02:01 +02:00
|
|
|
if (flag)
|
|
|
|
*flag = 0;
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))
|
2011-09-15 23:10:39 +02:00
|
|
|
return NULL;
|
|
|
|
|
2005-09-30 23:08:25 +02:00
|
|
|
for (;;) {
|
2011-10-19 22:55:49 +02:00
|
|
|
char path[PATH_MAX];
|
2005-09-30 23:08:25 +02:00
|
|
|
struct stat st;
|
|
|
|
char *buf;
|
|
|
|
int fd;
|
2005-07-03 05:23:36 +02:00
|
|
|
|
2005-09-30 23:08:25 +02:00
|
|
|
if (--depth < 0)
|
|
|
|
return NULL;
|
2005-09-25 18:59:37 +02:00
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
git_snpath(path, sizeof(path), "%s", refname);
|
2011-09-15 23:10:35 +02:00
|
|
|
|
2005-09-30 23:08:25 +02:00
|
|
|
if (lstat(path, &st) < 0) {
|
2013-04-22 21:52:15 +02:00
|
|
|
struct ref_entry *entry;
|
|
|
|
|
2011-09-15 23:10:35 +02:00
|
|
|
if (errno != ENOENT)
|
|
|
|
return NULL;
|
|
|
|
/*
|
|
|
|
* The loose reference file does not exist;
|
|
|
|
* check for a packed reference.
|
|
|
|
*/
|
2013-04-22 21:52:15 +02:00
|
|
|
entry = get_packed_ref(refname);
|
|
|
|
if (entry) {
|
|
|
|
hashcpy(sha1, entry->u.value.sha1);
|
2011-09-15 23:10:35 +02:00
|
|
|
if (flag)
|
|
|
|
*flag |= REF_ISPACKED;
|
2011-12-12 06:38:09 +01:00
|
|
|
return refname;
|
Enable the packed refs file format
This actually "turns on" the packed ref file format, now that the
infrastructure to do so sanely exists (ie notably the change to make the
reference reading logic take refnames rather than pathnames to the loose
objects that no longer necessarily even exist).
In particular, when the ref lookup hits a refname that has no loose file
associated with it, it falls back on the packed-ref information. Also, the
ref-locking code, while still using a loose file for the locking itself
(and _creating_ a loose file for the new ref) no longer requires that the
old ref be in such an unpacked state.
Finally, this does a minimal hack to git-checkout.sh to rather than check
the ref-file directly, do a "git-rev-parse" on the "heads/$refname".
That's not really wonderful - we should rather really have a special
routine to verify the names as proper branch head names, but it is a
workable solution for now.
With this, I can literally do something like
git pack-refs
find .git/refs -type f -print0 | xargs -0 rm -f --
and the end result is a largely working repository (ie I've done two
commits - which creates _one_ unpacked ref file - done things like run
"gitk" and "git log" etc, and it all looks ok).
There are probably things missing, but I'm hoping that the missing things
are now of the "small and obvious" kind, and that somebody else might want
to start looking at this too. Hint hint ;)
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-14 19:14:47 +02:00
|
|
|
}
|
2011-09-15 23:10:35 +02:00
|
|
|
/* The reference is not a packed reference, either. */
|
|
|
|
if (reading) {
|
2005-09-30 23:08:25 +02:00
|
|
|
return NULL;
|
2011-09-15 23:10:35 +02:00
|
|
|
} else {
|
|
|
|
hashclr(sha1);
|
2011-12-12 06:38:09 +01:00
|
|
|
return refname;
|
2011-09-15 23:10:35 +02:00
|
|
|
}
|
2005-09-30 23:08:25 +02:00
|
|
|
}
|
2005-09-25 18:59:37 +02:00
|
|
|
|
2005-09-30 23:08:25 +02:00
|
|
|
/* Follow "normalized" - ie "refs/.." symlinks by hand */
|
|
|
|
if (S_ISLNK(st.st_mode)) {
|
|
|
|
len = readlink(path, buffer, sizeof(buffer)-1);
|
2011-09-15 23:10:31 +02:00
|
|
|
if (len < 0)
|
|
|
|
return NULL;
|
2011-09-15 23:10:32 +02:00
|
|
|
buffer[len] = 0;
|
2011-09-15 23:10:33 +02:00
|
|
|
if (!prefixcmp(buffer, "refs/") &&
|
|
|
|
!check_refname_format(buffer, 0)) {
|
2011-12-12 06:38:09 +01:00
|
|
|
strcpy(refname_buffer, buffer);
|
|
|
|
refname = refname_buffer;
|
2006-09-21 07:02:01 +02:00
|
|
|
if (flag)
|
|
|
|
*flag |= REF_ISSYMREF;
|
2005-09-30 23:08:25 +02:00
|
|
|
continue;
|
|
|
|
}
|
2005-09-25 18:59:37 +02:00
|
|
|
}
|
2005-09-30 23:08:25 +02:00
|
|
|
|
2006-10-02 19:23:53 +02:00
|
|
|
/* Is it a directory? */
|
|
|
|
if (S_ISDIR(st.st_mode)) {
|
|
|
|
errno = EISDIR;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-09-30 23:08:25 +02:00
|
|
|
/*
|
|
|
|
* Anything else, just open it and try to use it as
|
|
|
|
* a ref
|
|
|
|
*/
|
|
|
|
fd = open(path, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
return NULL;
|
2007-01-08 16:58:08 +01:00
|
|
|
len = read_in_full(fd, buffer, sizeof(buffer)-1);
|
2005-09-30 23:08:25 +02:00
|
|
|
close(fd);
|
2011-09-15 23:10:34 +02:00
|
|
|
if (len < 0)
|
|
|
|
return NULL;
|
|
|
|
while (len && isspace(buffer[len-1]))
|
|
|
|
len--;
|
|
|
|
buffer[len] = '\0';
|
2005-09-30 23:08:25 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Is it a symbolic ref?
|
|
|
|
*/
|
2011-09-15 23:10:34 +02:00
|
|
|
if (prefixcmp(buffer, "ref:"))
|
2005-09-30 23:08:25 +02:00
|
|
|
break;
|
2011-10-19 22:55:49 +02:00
|
|
|
if (flag)
|
|
|
|
*flag |= REF_ISSYMREF;
|
2005-09-30 23:08:25 +02:00
|
|
|
buf = buffer + 4;
|
2011-09-15 23:10:34 +02:00
|
|
|
while (isspace(*buf))
|
|
|
|
buf++;
|
2011-09-15 23:10:36 +02:00
|
|
|
if (check_refname_format(buf, REFNAME_ALLOW_ONELEVEL)) {
|
2011-10-19 22:55:49 +02:00
|
|
|
if (flag)
|
|
|
|
*flag |= REF_ISBROKEN;
|
2011-09-15 23:10:36 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
2011-12-12 06:38:09 +01:00
|
|
|
refname = strcpy(refname_buffer, buf);
|
2005-07-03 05:23:36 +02:00
|
|
|
}
|
2011-09-15 23:10:41 +02:00
|
|
|
/* Please note that FETCH_HEAD has a second line containing other data. */
|
|
|
|
if (get_sha1_hex(buffer, sha1) || (buffer[40] != '\0' && !isspace(buffer[40]))) {
|
2011-10-19 22:55:49 +02:00
|
|
|
if (flag)
|
|
|
|
*flag |= REF_ISBROKEN;
|
2005-09-30 23:08:25 +02:00
|
|
|
return NULL;
|
2011-09-15 23:10:40 +02:00
|
|
|
}
|
2011-12-12 06:38:09 +01:00
|
|
|
return refname;
|
2005-09-30 23:08:25 +02:00
|
|
|
}
|
|
|
|
|
2011-12-13 15:17:48 +01:00
|
|
|
char *resolve_refdup(const char *ref, unsigned char *sha1, int reading, int *flag)
|
|
|
|
{
|
2011-12-12 12:20:32 +01:00
|
|
|
const char *ret = resolve_ref_unsafe(ref, sha1, reading, flag);
|
2011-12-13 15:17:48 +01:00
|
|
|
return ret ? xstrdup(ret) : NULL;
|
|
|
|
}
|
|
|
|
|
2010-01-20 10:48:25 +01:00
|
|
|
/* The argument to filter_refs */
|
|
|
|
struct ref_filter {
|
|
|
|
const char *pattern;
|
|
|
|
each_ref_fn *fn;
|
|
|
|
void *cb_data;
|
|
|
|
};
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
int read_ref_full(const char *refname, unsigned char *sha1, int reading, int *flags)
|
2005-09-30 23:08:25 +02:00
|
|
|
{
|
2011-12-20 22:25:53 +01:00
|
|
|
if (resolve_ref_unsafe(refname, sha1, reading, flags))
|
2005-09-30 23:08:25 +02:00
|
|
|
return 0;
|
|
|
|
return -1;
|
2005-07-03 05:23:36 +02:00
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
int read_ref(const char *refname, unsigned char *sha1)
|
2011-11-13 11:22:14 +01:00
|
|
|
{
|
2011-12-12 06:38:09 +01:00
|
|
|
return read_ref_full(refname, sha1, 1, NULL);
|
2011-11-13 11:22:14 +01:00
|
|
|
}
|
|
|
|
|
2012-04-10 07:30:13 +02:00
|
|
|
int ref_exists(const char *refname)
|
2006-11-19 07:13:33 +01:00
|
|
|
{
|
2012-04-10 07:30:13 +02:00
|
|
|
unsigned char sha1[20];
|
|
|
|
return !!resolve_ref_unsafe(refname, sha1, 1, NULL);
|
2006-11-19 07:13:33 +01:00
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:10 +01:00
|
|
|
static int filter_refs(const char *refname, const unsigned char *sha1, int flags,
|
2011-12-12 06:38:09 +01:00
|
|
|
void *data)
|
2010-01-20 10:48:25 +01:00
|
|
|
{
|
|
|
|
struct ref_filter *filter = (struct ref_filter *)data;
|
2011-12-12 06:38:09 +01:00
|
|
|
if (fnmatch(filter->pattern, refname, 0))
|
2010-01-20 10:48:25 +01:00
|
|
|
return 0;
|
2011-12-12 06:38:10 +01:00
|
|
|
return filter->fn(refname, sha1, flags, filter->cb_data);
|
2010-01-20 10:48:25 +01:00
|
|
|
}
|
|
|
|
|
2013-04-22 21:52:20 +02:00
|
|
|
enum peel_status {
|
|
|
|
/* object was peeled successfully: */
|
|
|
|
PEEL_PEELED = 0,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* object cannot be peeled because the named object (or an
|
|
|
|
* object referred to by a tag in the peel chain), does not
|
|
|
|
* exist.
|
|
|
|
*/
|
|
|
|
PEEL_INVALID = -1,
|
|
|
|
|
|
|
|
/* object cannot be peeled because it is not a tag: */
|
2013-04-22 21:52:22 +02:00
|
|
|
PEEL_NON_TAG = -2,
|
|
|
|
|
|
|
|
/* ref_entry contains no peeled value because it is a symref: */
|
|
|
|
PEEL_IS_SYMREF = -3,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ref_entry cannot be peeled because it is broken (i.e., the
|
|
|
|
* symbolic reference cannot even be resolved to an object
|
|
|
|
* name):
|
|
|
|
*/
|
|
|
|
PEEL_BROKEN = -4
|
2013-04-22 21:52:20 +02:00
|
|
|
};
|
|
|
|
|
2013-04-22 21:52:19 +02:00
|
|
|
/*
|
|
|
|
* Peel the named object; i.e., if the object is a tag, resolve the
|
2013-04-22 21:52:20 +02:00
|
|
|
* tag recursively until a non-tag is found. If successful, store the
|
|
|
|
* result to sha1 and return PEEL_PEELED. If the object is not a tag
|
|
|
|
* or is not valid, return PEEL_NON_TAG or PEEL_INVALID, respectively,
|
|
|
|
* and leave sha1 unchanged.
|
2013-04-22 21:52:19 +02:00
|
|
|
*/
|
2013-04-22 21:52:20 +02:00
|
|
|
static enum peel_status peel_object(const unsigned char *name, unsigned char *sha1)
|
2013-04-22 21:52:19 +02:00
|
|
|
{
|
|
|
|
struct object *o = lookup_unknown_object(name);
|
|
|
|
|
|
|
|
if (o->type == OBJ_NONE) {
|
|
|
|
int type = sha1_object_info(name, NULL);
|
|
|
|
if (type < 0)
|
2013-04-22 21:52:20 +02:00
|
|
|
return PEEL_INVALID;
|
2013-04-22 21:52:19 +02:00
|
|
|
o->type = type;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (o->type != OBJ_TAG)
|
2013-04-22 21:52:20 +02:00
|
|
|
return PEEL_NON_TAG;
|
2013-04-22 21:52:19 +02:00
|
|
|
|
|
|
|
o = deref_tag_noverify(o);
|
|
|
|
if (!o)
|
2013-04-22 21:52:20 +02:00
|
|
|
return PEEL_INVALID;
|
2013-04-22 21:52:19 +02:00
|
|
|
|
|
|
|
hashcpy(sha1, o->sha1);
|
2013-04-22 21:52:20 +02:00
|
|
|
return PEEL_PEELED;
|
2013-04-22 21:52:19 +02:00
|
|
|
}
|
|
|
|
|
2013-04-22 21:52:22 +02:00
|
|
|
/*
|
|
|
|
* Peel the entry (if possible) and return its new peel_status.
|
repack_without_ref(): write peeled refs in the rewritten file
When a reference that existed in the packed-refs file is deleted, the
packed-refs file must be rewritten. Previously, the file was
rewritten without any peeled refs, even if the file contained peeled
refs when it was read. This was not a bug, because the packed-refs
file header didn't claim that the file contained peeled values. But
it had a performance cost, because the repository would lose the
benefit of having precomputed peeled references until pack-refs was
run again.
Teach repack_without_ref() to write peeled refs to the packed-refs
file (regardless of whether they were present in the old version of
the file).
This means that if the old version of the packed-refs file was not
fully peeled, then repack_without_ref() will have to peel references.
To avoid the expense of reading lots of loose references, we take two
shortcuts relative to pack-refs:
* If the peeled value of a reference is already known (i.e., because
it was read from the old version of the packed-refs file), then
output that peeled value again without any checks. This is the
usual code path and should avoid any noticeable overhead. (This is
different than pack-refs, which always re-peels references.)
* We don't verify that the packed ref is still current. It could be
that a packed references is overridden by a loose reference, in
which case the packed ref is no longer needed and might even refer
to an object that has been garbage collected. But we don't check;
instead, we just try to peel all references. If peeling is
successful, the peeled value is written out (even though it might
not be needed any more); if not, then the reference is silently
omitted from the output.
The extra overhead of peeling references in repack_without_ref()
should only be incurred the first time the packed-refs file is written
by a version of Git that knows about the "fully-peeled" attribute.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:29 +02:00
|
|
|
*
|
|
|
|
* It is OK to call this function with a packed reference entry that
|
|
|
|
* might be stale and might even refer to an object that has since
|
|
|
|
* been garbage-collected. In such a case, if the entry has
|
|
|
|
* REF_KNOWS_PEELED then leave the status unchanged and return
|
|
|
|
* PEEL_PEELED or PEEL_NON_TAG; otherwise, return PEEL_INVALID.
|
2013-04-22 21:52:22 +02:00
|
|
|
*/
|
|
|
|
static enum peel_status peel_entry(struct ref_entry *entry)
|
|
|
|
{
|
|
|
|
enum peel_status status;
|
|
|
|
|
|
|
|
if (entry->flag & REF_KNOWS_PEELED)
|
|
|
|
return is_null_sha1(entry->u.value.peeled) ?
|
|
|
|
PEEL_NON_TAG : PEEL_PEELED;
|
|
|
|
if (entry->flag & REF_ISBROKEN)
|
|
|
|
return PEEL_BROKEN;
|
|
|
|
if (entry->flag & REF_ISSYMREF)
|
|
|
|
return PEEL_IS_SYMREF;
|
|
|
|
|
|
|
|
status = peel_object(entry->u.value.sha1, entry->u.value.peeled);
|
|
|
|
if (status == PEEL_PEELED || status == PEEL_NON_TAG)
|
|
|
|
entry->flag |= REF_KNOWS_PEELED;
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
int peel_ref(const char *refname, unsigned char *sha1)
|
2006-11-19 22:22:44 +01:00
|
|
|
{
|
|
|
|
int flag;
|
|
|
|
unsigned char base[20];
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
if (current_ref && (current_ref->name == refname
|
2013-04-22 21:52:22 +02:00
|
|
|
|| !strcmp(current_ref->name, refname))) {
|
|
|
|
if (peel_entry(current_ref))
|
|
|
|
return -1;
|
|
|
|
hashcpy(sha1, current_ref->u.value.peeled);
|
|
|
|
return 0;
|
2008-02-24 09:07:22 +01:00
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
if (read_ref_full(refname, base, 1, &flag))
|
2006-11-19 22:22:44 +01:00
|
|
|
return -1;
|
|
|
|
|
2013-04-22 21:52:22 +02:00
|
|
|
/*
|
|
|
|
* If the reference is packed, read its ref_entry from the
|
|
|
|
* cache in the hope that we already know its peeled value.
|
|
|
|
* We only try this optimization on packed references because
|
|
|
|
* (a) forcing the filling of the loose reference cache could
|
|
|
|
* be expensive and (b) loose references anyway usually do not
|
|
|
|
* have REF_KNOWS_PEELED.
|
|
|
|
*/
|
|
|
|
if (flag & REF_ISPACKED) {
|
2013-04-22 21:52:16 +02:00
|
|
|
struct ref_entry *r = get_packed_ref(refname);
|
2013-04-22 21:52:22 +02:00
|
|
|
if (r) {
|
|
|
|
if (peel_entry(r))
|
|
|
|
return -1;
|
2012-04-10 07:30:23 +02:00
|
|
|
hashcpy(sha1, r->u.value.peeled);
|
2011-09-30 00:11:42 +02:00
|
|
|
return 0;
|
2006-11-19 22:22:44 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-22 21:52:19 +02:00
|
|
|
return peel_object(base, sha1);
|
2006-11-19 22:22:44 +01:00
|
|
|
}
|
|
|
|
|
2012-04-10 07:30:13 +02:00
|
|
|
struct warn_if_dangling_data {
|
|
|
|
FILE *fp;
|
|
|
|
const char *refname;
|
|
|
|
const char *msg_fmt;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int warn_if_dangling_symref(const char *refname, const unsigned char *sha1,
|
|
|
|
int flags, void *cb_data)
|
|
|
|
{
|
|
|
|
struct warn_if_dangling_data *d = cb_data;
|
|
|
|
const char *resolves_to;
|
|
|
|
unsigned char junk[20];
|
|
|
|
|
|
|
|
if (!(flags & REF_ISSYMREF))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
resolves_to = resolve_ref_unsafe(refname, junk, 0, NULL);
|
|
|
|
if (!resolves_to || strcmp(resolves_to, d->refname))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fprintf(d->fp, d->msg_fmt, refname);
|
2012-05-02 22:51:35 +02:00
|
|
|
fputc('\n', d->fp);
|
2012-04-10 07:30:13 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
|
|
|
|
{
|
|
|
|
struct warn_if_dangling_data data;
|
|
|
|
|
|
|
|
data.fp = fp;
|
|
|
|
data.refname = refname;
|
|
|
|
data.msg_fmt = msg_fmt;
|
|
|
|
for_each_rawref(warn_if_dangling_symref, &data);
|
|
|
|
}
|
|
|
|
|
2013-04-22 21:52:11 +02:00
|
|
|
/*
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
* Call fn for each reference in the specified submodule, omitting
|
|
|
|
* references not in the containing_dir of base. fn is called for all
|
|
|
|
* references, including broken ones. If fn ever returns a non-zero
|
2013-04-22 21:52:11 +02:00
|
|
|
* value, stop the iteration and return that value; otherwise, return
|
|
|
|
* 0.
|
|
|
|
*/
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
static int do_for_each_entry(const char *submodule, const char *base,
|
|
|
|
each_ref_entry_fn fn, void *cb_data)
|
2005-07-03 05:23:36 +02:00
|
|
|
{
|
2011-12-12 06:38:16 +01:00
|
|
|
struct ref_cache *refs = get_ref_cache(submodule);
|
2012-04-10 07:30:27 +02:00
|
|
|
struct ref_dir *packed_dir = get_packed_refs(refs);
|
|
|
|
struct ref_dir *loose_dir = get_loose_refs(refs);
|
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
if (base && *base) {
|
|
|
|
packed_dir = find_containing_dir(packed_dir, base, 0);
|
|
|
|
loose_dir = find_containing_dir(loose_dir, base, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (packed_dir && loose_dir) {
|
|
|
|
sort_ref_dir(packed_dir);
|
|
|
|
sort_ref_dir(loose_dir);
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
retval = do_for_each_entry_in_dirs(
|
|
|
|
packed_dir, loose_dir, fn, cb_data);
|
2012-04-10 07:30:27 +02:00
|
|
|
} else if (packed_dir) {
|
|
|
|
sort_ref_dir(packed_dir);
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
retval = do_for_each_entry_in_dir(
|
|
|
|
packed_dir, 0, fn, cb_data);
|
2012-04-10 07:30:27 +02:00
|
|
|
} else if (loose_dir) {
|
|
|
|
sort_ref_dir(loose_dir);
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
retval = do_for_each_entry_in_dir(
|
|
|
|
loose_dir, 0, fn, cb_data);
|
2012-04-10 07:30:27 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return retval;
|
2005-07-03 05:23:36 +02:00
|
|
|
}
|
|
|
|
|
refs: change the internal reference-iteration API
Establish an internal API for iterating over references, which gives
the callback functions direct access to the ref_entry structure
describing the reference. (Do not change the iteration API that is
exposed outside of the module.)
Define a new internal callback signature
int each_ref_entry_fn(struct ref_entry *entry, void *cb_data)
Change do_for_each_ref_in_dir() and do_for_each_ref_in_dirs() to
accept each_ref_entry_fn callbacks, and rename them to
do_for_each_entry_in_dir() and do_for_each_entry_in_dirs(),
respectively. Adapt their callers accordingly.
Add a new function do_for_each_entry() analogous to do_for_each_ref()
but using the new callback style.
Change do_one_ref() into an each_ref_entry_fn that does some
bookkeeping and then calls a wrapped each_ref_fn.
Reimplement do_for_each_ref() in terms of do_for_each_entry(), using
do_one_ref() as an adapter.
Please note that the responsibility for setting current_ref remains in
do_one_ref(), which means that current_ref is *not* set when iterating
over references via the new internal API. This is not a disadvantage,
because current_ref is not needed by callers of the internal API (they
receive a pointer to the current ref_entry anyway). But more
importantly, this change prevents peel_ref() from returning invalid
results in the following scenario:
When iterating via the external API, the iteration always includes
both packed and loose references, and in particular never presents a
packed ref if there is a loose ref with the same name. The internal
API, on the other hand, gives the option to iterate over only the
packed references. During such an iteration, there is no check
whether the packed ref might be hidden by a loose ref of the same
name. But until now the packed ref was recorded in current_ref during
the iteration. So if peel_ref() were called with the reference name
corresponding to current ref, it would return the peeled version of
the packed ref even though there might be a loose ref that peels to a
different value. This scenario doesn't currently occur in the code,
but fix it to prevent things from breaking in a very confusing way in
the future.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:23 +02:00
|
|
|
/*
|
|
|
|
* Call fn for each reference in the specified submodule for which the
|
|
|
|
* refname begins with base. If trim is non-zero, then trim that many
|
|
|
|
* characters off the beginning of each refname before passing the
|
|
|
|
* refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to include
|
|
|
|
* broken references in the iteration. If fn ever returns a non-zero
|
|
|
|
* value, stop the iteration and return that value; otherwise, return
|
|
|
|
* 0.
|
|
|
|
*/
|
|
|
|
static int do_for_each_ref(const char *submodule, const char *base, each_ref_fn fn,
|
|
|
|
int trim, int flags, void *cb_data)
|
|
|
|
{
|
|
|
|
struct ref_entry_cb data;
|
|
|
|
data.base = base;
|
|
|
|
data.trim = trim;
|
|
|
|
data.flags = flags;
|
|
|
|
data.fn = fn;
|
|
|
|
data.cb_data = cb_data;
|
|
|
|
|
|
|
|
return do_for_each_entry(submodule, base, do_one_ref, &data);
|
|
|
|
}
|
|
|
|
|
2010-07-07 15:39:11 +02:00
|
|
|
static int do_head_ref(const char *submodule, each_ref_fn fn, void *cb_data)
|
2005-07-05 20:31:32 +02:00
|
|
|
{
|
|
|
|
unsigned char sha1[20];
|
2006-09-21 07:02:01 +02:00
|
|
|
int flag;
|
|
|
|
|
2010-07-07 15:39:11 +02:00
|
|
|
if (submodule) {
|
|
|
|
if (resolve_gitlink_ref(submodule, "HEAD", sha1) == 0)
|
|
|
|
return fn("HEAD", sha1, 0, cb_data);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-11-13 11:22:14 +01:00
|
|
|
if (!read_ref_full("HEAD", sha1, 1, &flag))
|
2006-09-21 07:02:01 +02:00
|
|
|
return fn("HEAD", sha1, flag, cb_data);
|
2010-07-07 15:39:11 +02:00
|
|
|
|
2005-07-06 00:45:00 +02:00
|
|
|
return 0;
|
2005-07-05 20:31:32 +02:00
|
|
|
}
|
|
|
|
|
2010-07-07 15:39:11 +02:00
|
|
|
int head_ref(each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
return do_head_ref(NULL, fn, cb_data);
|
|
|
|
}
|
|
|
|
|
2010-07-07 15:39:12 +02:00
|
|
|
int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
return do_head_ref(submodule, fn, cb_data);
|
|
|
|
}
|
|
|
|
|
2006-09-21 06:47:42 +02:00
|
|
|
int for_each_ref(each_ref_fn fn, void *cb_data)
|
2005-07-03 05:23:36 +02:00
|
|
|
{
|
Fix prefix handling in ref iteration functions
The do_for_each_ref iteration function accepts a prefix and a trim, and
checks for the prefix on each ref before passing in that ref; it also
supports trimming off part of the ref before passing it. However,
do_for_each_ref used trim as the length of the prefix to check, ignoring
the actual length of the prefix. Switch to using prefixcmp, checking
the entire length of the prefix string, to properly support a trim value
different than the length of the prefix.
Several callers passed a prefix of "refs/" to filter out everything
outside of refs/, but a trim of 0 to avoid trimming off the "refs/"; the
trim of 0 meant that the filter of "refs/" no longer applied. Change
these callers to pass an empty prefix instead, to avoid changing the
existing behavior. Various callers count on this lack of filtering,
such as receive-pack which uses add_extra_ref to add alternates as refs
named ".have"; adding filtering would break that, causing
t5501-fetch-push-alternates.sh to fail. That lack of filtering doesn't
currently have any other effect, since the loose ref functions can never
supply refs outside of "refs/", and packed-refs will not normally
include such refs unless manually edited.
Signed-off-by: Josh Triplett <josh@joshtriplett.org>
Signed-off-by: Jamey Sharp <jamey@minilop.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-07-05 19:54:21 +02:00
|
|
|
return do_for_each_ref(NULL, "", fn, 0, 0, cb_data);
|
2006-05-14 03:43:00 +02:00
|
|
|
}
|
|
|
|
|
2010-07-07 15:39:12 +02:00
|
|
|
int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
Fix prefix handling in ref iteration functions
The do_for_each_ref iteration function accepts a prefix and a trim, and
checks for the prefix on each ref before passing in that ref; it also
supports trimming off part of the ref before passing it. However,
do_for_each_ref used trim as the length of the prefix to check, ignoring
the actual length of the prefix. Switch to using prefixcmp, checking
the entire length of the prefix string, to properly support a trim value
different than the length of the prefix.
Several callers passed a prefix of "refs/" to filter out everything
outside of refs/, but a trim of 0 to avoid trimming off the "refs/"; the
trim of 0 meant that the filter of "refs/" no longer applied. Change
these callers to pass an empty prefix instead, to avoid changing the
existing behavior. Various callers count on this lack of filtering,
such as receive-pack which uses add_extra_ref to add alternates as refs
named ".have"; adding filtering would break that, causing
t5501-fetch-push-alternates.sh to fail. That lack of filtering doesn't
currently have any other effect, since the loose ref functions can never
supply refs outside of "refs/", and packed-refs will not normally
include such refs unless manually edited.
Signed-off-by: Josh Triplett <josh@joshtriplett.org>
Signed-off-by: Jamey Sharp <jamey@minilop.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-07-05 19:54:21 +02:00
|
|
|
return do_for_each_ref(submodule, "", fn, 0, 0, cb_data);
|
2006-05-14 03:43:00 +02:00
|
|
|
}
|
|
|
|
|
2009-03-30 05:07:15 +02:00
|
|
|
int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
2010-07-07 15:39:11 +02:00
|
|
|
return do_for_each_ref(NULL, prefix, fn, strlen(prefix), 0, cb_data);
|
2009-03-30 05:07:15 +02:00
|
|
|
}
|
|
|
|
|
2010-07-07 15:39:12 +02:00
|
|
|
int for_each_ref_in_submodule(const char *submodule, const char *prefix,
|
|
|
|
each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
return do_for_each_ref(submodule, prefix, fn, strlen(prefix), 0, cb_data);
|
2009-03-30 05:07:15 +02:00
|
|
|
}
|
|
|
|
|
2006-09-21 06:47:42 +02:00
|
|
|
int for_each_tag_ref(each_ref_fn fn, void *cb_data)
|
2006-05-14 03:43:00 +02:00
|
|
|
{
|
2009-03-30 05:07:15 +02:00
|
|
|
return for_each_ref_in("refs/tags/", fn, cb_data);
|
2006-05-14 03:43:00 +02:00
|
|
|
}
|
|
|
|
|
2010-07-07 15:39:12 +02:00
|
|
|
int for_each_tag_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
return for_each_ref_in_submodule(submodule, "refs/tags/", fn, cb_data);
|
|
|
|
}
|
|
|
|
|
2006-09-21 06:47:42 +02:00
|
|
|
int for_each_branch_ref(each_ref_fn fn, void *cb_data)
|
2006-05-14 03:43:00 +02:00
|
|
|
{
|
2009-03-30 05:07:15 +02:00
|
|
|
return for_each_ref_in("refs/heads/", fn, cb_data);
|
2006-05-14 03:43:00 +02:00
|
|
|
}
|
|
|
|
|
2010-07-07 15:39:12 +02:00
|
|
|
int for_each_branch_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
return for_each_ref_in_submodule(submodule, "refs/heads/", fn, cb_data);
|
|
|
|
}
|
|
|
|
|
2006-09-21 06:47:42 +02:00
|
|
|
int for_each_remote_ref(each_ref_fn fn, void *cb_data)
|
2006-05-14 03:43:00 +02:00
|
|
|
{
|
2009-03-30 05:07:15 +02:00
|
|
|
return for_each_ref_in("refs/remotes/", fn, cb_data);
|
2009-02-09 08:27:10 +01:00
|
|
|
}
|
|
|
|
|
2010-07-07 15:39:12 +02:00
|
|
|
int for_each_remote_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
return for_each_ref_in_submodule(submodule, "refs/remotes/", fn, cb_data);
|
|
|
|
}
|
|
|
|
|
2009-01-23 10:06:38 +01:00
|
|
|
int for_each_replace_ref(each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
2010-07-07 15:39:11 +02:00
|
|
|
return do_for_each_ref(NULL, "refs/replace/", fn, 13, 0, cb_data);
|
2009-01-23 10:06:38 +01:00
|
|
|
}
|
|
|
|
|
ref namespaces: infrastructure
Add support for dividing the refs of a single repository into multiple
namespaces, each of which can have its own branches, tags, and HEAD.
Git can expose each namespace as an independent repository to pull from
and push to, while sharing the object store, and exposing all the refs
to operations such as git-gc.
Storing multiple repositories as namespaces of a single repository
avoids storing duplicate copies of the same objects, such as when
storing multiple branches of the same source. The alternates mechanism
provides similar support for avoiding duplicates, but alternates do not
prevent duplication between new objects added to the repositories
without ongoing maintenance, while namespaces do.
To specify a namespace, set the GIT_NAMESPACE environment variable to
the namespace. For each ref namespace, git stores the corresponding
refs in a directory under refs/namespaces/. For example,
GIT_NAMESPACE=foo will store refs under refs/namespaces/foo/. You can
also specify namespaces via the --namespace option to git.
Note that namespaces which include a / will expand to a hierarchy of
namespaces; for example, GIT_NAMESPACE=foo/bar will store refs under
refs/namespaces/foo/refs/namespaces/bar/. This makes paths in
GIT_NAMESPACE behave hierarchically, so that cloning with
GIT_NAMESPACE=foo/bar produces the same result as cloning with
GIT_NAMESPACE=foo and cloning from that repo with GIT_NAMESPACE=bar. It
also avoids ambiguity with strange namespace paths such as
foo/refs/heads/, which could otherwise generate directory/file conflicts
within the refs directory.
Add the infrastructure for ref namespaces: handle the GIT_NAMESPACE
environment variable and --namespace option, and support iterating over
refs in a namespace.
Signed-off-by: Josh Triplett <josh@joshtriplett.org>
Signed-off-by: Jamey Sharp <jamey@minilop.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-07-05 19:54:44 +02:00
|
|
|
int head_ref_namespaced(each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int ret = 0;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
int flag;
|
|
|
|
|
|
|
|
strbuf_addf(&buf, "%sHEAD", get_git_namespace());
|
2011-11-13 11:22:14 +01:00
|
|
|
if (!read_ref_full(buf.buf, sha1, 1, &flag))
|
ref namespaces: infrastructure
Add support for dividing the refs of a single repository into multiple
namespaces, each of which can have its own branches, tags, and HEAD.
Git can expose each namespace as an independent repository to pull from
and push to, while sharing the object store, and exposing all the refs
to operations such as git-gc.
Storing multiple repositories as namespaces of a single repository
avoids storing duplicate copies of the same objects, such as when
storing multiple branches of the same source. The alternates mechanism
provides similar support for avoiding duplicates, but alternates do not
prevent duplication between new objects added to the repositories
without ongoing maintenance, while namespaces do.
To specify a namespace, set the GIT_NAMESPACE environment variable to
the namespace. For each ref namespace, git stores the corresponding
refs in a directory under refs/namespaces/. For example,
GIT_NAMESPACE=foo will store refs under refs/namespaces/foo/. You can
also specify namespaces via the --namespace option to git.
Note that namespaces which include a / will expand to a hierarchy of
namespaces; for example, GIT_NAMESPACE=foo/bar will store refs under
refs/namespaces/foo/refs/namespaces/bar/. This makes paths in
GIT_NAMESPACE behave hierarchically, so that cloning with
GIT_NAMESPACE=foo/bar produces the same result as cloning with
GIT_NAMESPACE=foo and cloning from that repo with GIT_NAMESPACE=bar. It
also avoids ambiguity with strange namespace paths such as
foo/refs/heads/, which could otherwise generate directory/file conflicts
within the refs directory.
Add the infrastructure for ref namespaces: handle the GIT_NAMESPACE
environment variable and --namespace option, and support iterating over
refs in a namespace.
Signed-off-by: Josh Triplett <josh@joshtriplett.org>
Signed-off-by: Jamey Sharp <jamey@minilop.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-07-05 19:54:44 +02:00
|
|
|
ret = fn(buf.buf, sha1, flag, cb_data);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int ret;
|
|
|
|
strbuf_addf(&buf, "%srefs/", get_git_namespace());
|
|
|
|
ret = do_for_each_ref(NULL, buf.buf, fn, 0, 0, cb_data);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-01-20 10:48:26 +01:00
|
|
|
int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
|
|
|
|
const char *prefix, void *cb_data)
|
2010-01-20 10:48:25 +01:00
|
|
|
{
|
|
|
|
struct strbuf real_pattern = STRBUF_INIT;
|
|
|
|
struct ref_filter filter;
|
|
|
|
int ret;
|
|
|
|
|
2010-01-20 10:48:26 +01:00
|
|
|
if (!prefix && prefixcmp(pattern, "refs/"))
|
2010-01-20 10:48:25 +01:00
|
|
|
strbuf_addstr(&real_pattern, "refs/");
|
2010-01-20 10:48:26 +01:00
|
|
|
else if (prefix)
|
|
|
|
strbuf_addstr(&real_pattern, prefix);
|
2010-01-20 10:48:25 +01:00
|
|
|
strbuf_addstr(&real_pattern, pattern);
|
|
|
|
|
2010-03-12 18:04:26 +01:00
|
|
|
if (!has_glob_specials(pattern)) {
|
2010-02-04 06:23:18 +01:00
|
|
|
/* Append implied '/' '*' if not present. */
|
2010-01-20 10:48:25 +01:00
|
|
|
if (real_pattern.buf[real_pattern.len - 1] != '/')
|
|
|
|
strbuf_addch(&real_pattern, '/');
|
|
|
|
/* No need to check for '*', there is none. */
|
|
|
|
strbuf_addch(&real_pattern, '*');
|
|
|
|
}
|
|
|
|
|
|
|
|
filter.pattern = real_pattern.buf;
|
|
|
|
filter.fn = fn;
|
|
|
|
filter.cb_data = cb_data;
|
|
|
|
ret = for_each_ref(filter_refs, &filter);
|
|
|
|
|
|
|
|
strbuf_release(&real_pattern);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-01-20 10:48:26 +01:00
|
|
|
int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
|
|
|
|
{
|
|
|
|
return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
|
|
|
|
}
|
|
|
|
|
2009-02-09 08:27:10 +01:00
|
|
|
int for_each_rawref(each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
Fix prefix handling in ref iteration functions
The do_for_each_ref iteration function accepts a prefix and a trim, and
checks for the prefix on each ref before passing in that ref; it also
supports trimming off part of the ref before passing it. However,
do_for_each_ref used trim as the length of the prefix to check, ignoring
the actual length of the prefix. Switch to using prefixcmp, checking
the entire length of the prefix string, to properly support a trim value
different than the length of the prefix.
Several callers passed a prefix of "refs/" to filter out everything
outside of refs/, but a trim of 0 to avoid trimming off the "refs/"; the
trim of 0 meant that the filter of "refs/" no longer applied. Change
these callers to pass an empty prefix instead, to avoid changing the
existing behavior. Various callers count on this lack of filtering,
such as receive-pack which uses add_extra_ref to add alternates as refs
named ".have"; adding filtering would break that, causing
t5501-fetch-push-alternates.sh to fail. That lack of filtering doesn't
currently have any other effect, since the loose ref functions can never
supply refs outside of "refs/", and packed-refs will not normally
include such refs unless manually edited.
Signed-off-by: Josh Triplett <josh@joshtriplett.org>
Signed-off-by: Jamey Sharp <jamey@minilop.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-07-05 19:54:21 +02:00
|
|
|
return do_for_each_ref(NULL, "", fn, 0,
|
2009-02-09 08:27:10 +01:00
|
|
|
DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
|
2005-07-03 05:23:36 +02:00
|
|
|
}
|
|
|
|
|
2009-05-13 23:22:04 +02:00
|
|
|
const char *prettify_refname(const char *name)
|
2009-03-09 02:06:05 +01:00
|
|
|
{
|
|
|
|
return name + (
|
|
|
|
!prefixcmp(name, "refs/heads/") ? 11 :
|
|
|
|
!prefixcmp(name, "refs/tags/") ? 10 :
|
|
|
|
!prefixcmp(name, "refs/remotes/") ? 13 :
|
|
|
|
0);
|
|
|
|
}
|
|
|
|
|
add refname_match()
We use at least two rulesets for matching abbreviated refnames with
full refnames (starting with 'refs/'). git-rev-parse and git-fetch
use slightly different rules.
This commit introduces a new function refname_match
(const char *abbrev_name, const char *full_name, const char **rules).
abbrev_name is expanded using the rules and matched against full_name.
If a match is found the function returns true. rules is a NULL-terminate
list of format patterns with "%.*s", for example:
const char *ref_rev_parse_rules[] = {
"%.*s",
"refs/%.*s",
"refs/tags/%.*s",
"refs/heads/%.*s",
"refs/remotes/%.*s",
"refs/remotes/%.*s/HEAD",
NULL
};
Asterisks are included in the format strings because this is the form
required in sha1_name.c. Sharing the list with the functions there is
a good idea to avoid duplicating the rules. Hopefully this
facilitates unified matching rules in the future.
This commit makes the rules used by rev-parse for resolving refs to
sha1s available for string comparison. Before this change, the rules
were buried in get_sha1*() and dwim_ref().
A follow-up commit will refactor the rules used by fetch.
refname_match() will be used for matching refspecs in git-send-pack.
Thanks to Daniel Barkalow <barkalow@iabervon.org> for pointing
out that ref_matches_abbrev in remote.c solves a similar problem
and care should be taken to avoid confusion.
Signed-off-by: Steffen Prohaska <prohaska@zib.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-11 15:01:46 +01:00
|
|
|
const char *ref_rev_parse_rules[] = {
|
|
|
|
"%.*s",
|
|
|
|
"refs/%.*s",
|
|
|
|
"refs/tags/%.*s",
|
|
|
|
"refs/heads/%.*s",
|
|
|
|
"refs/remotes/%.*s",
|
|
|
|
"refs/remotes/%.*s/HEAD",
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
int refname_match(const char *abbrev_name, const char *full_name, const char **rules)
|
|
|
|
{
|
|
|
|
const char **p;
|
|
|
|
const int abbrev_name_len = strlen(abbrev_name);
|
|
|
|
|
|
|
|
for (p = rules; *p; p++) {
|
|
|
|
if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name))) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-06-06 23:04:17 +02:00
|
|
|
static struct ref_lock *verify_lock(struct ref_lock *lock,
|
2006-05-17 11:55:02 +02:00
|
|
|
const unsigned char *old_sha1, int mustexist)
|
|
|
|
{
|
2011-11-13 11:22:14 +01:00
|
|
|
if (read_ref_full(lock->ref_name, lock->old_sha1, mustexist, NULL)) {
|
Enable the packed refs file format
This actually "turns on" the packed ref file format, now that the
infrastructure to do so sanely exists (ie notably the change to make the
reference reading logic take refnames rather than pathnames to the loose
objects that no longer necessarily even exist).
In particular, when the ref lookup hits a refname that has no loose file
associated with it, it falls back on the packed-ref information. Also, the
ref-locking code, while still using a loose file for the locking itself
(and _creating_ a loose file for the new ref) no longer requires that the
old ref be in such an unpacked state.
Finally, this does a minimal hack to git-checkout.sh to rather than check
the ref-file directly, do a "git-rev-parse" on the "heads/$refname".
That's not really wonderful - we should rather really have a special
routine to verify the names as proper branch head names, but it is a
workable solution for now.
With this, I can literally do something like
git pack-refs
find .git/refs -type f -print0 | xargs -0 rm -f --
and the end result is a largely working repository (ie I've done two
commits - which creates _one_ unpacked ref file - done things like run
"gitk" and "git log" etc, and it all looks ok).
There are probably things missing, but I'm hoping that the missing things
are now of the "small and obvious" kind, and that somebody else might want
to start looking at this too. Hint hint ;)
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-14 19:14:47 +02:00
|
|
|
error("Can't verify ref %s", lock->ref_name);
|
2006-05-17 11:55:02 +02:00
|
|
|
unlock_ref(lock);
|
|
|
|
return NULL;
|
|
|
|
}
|
2006-08-17 20:54:57 +02:00
|
|
|
if (hashcmp(lock->old_sha1, old_sha1)) {
|
Enable the packed refs file format
This actually "turns on" the packed ref file format, now that the
infrastructure to do so sanely exists (ie notably the change to make the
reference reading logic take refnames rather than pathnames to the loose
objects that no longer necessarily even exist).
In particular, when the ref lookup hits a refname that has no loose file
associated with it, it falls back on the packed-ref information. Also, the
ref-locking code, while still using a loose file for the locking itself
(and _creating_ a loose file for the new ref) no longer requires that the
old ref be in such an unpacked state.
Finally, this does a minimal hack to git-checkout.sh to rather than check
the ref-file directly, do a "git-rev-parse" on the "heads/$refname".
That's not really wonderful - we should rather really have a special
routine to verify the names as proper branch head names, but it is a
workable solution for now.
With this, I can literally do something like
git pack-refs
find .git/refs -type f -print0 | xargs -0 rm -f --
and the end result is a largely working repository (ie I've done two
commits - which creates _one_ unpacked ref file - done things like run
"gitk" and "git log" etc, and it all looks ok).
There are probably things missing, but I'm hoping that the missing things
are now of the "small and obvious" kind, and that somebody else might want
to start looking at this too. Hint hint ;)
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-14 19:14:47 +02:00
|
|
|
error("Ref %s is at %s but expected %s", lock->ref_name,
|
2006-05-17 11:55:02 +02:00
|
|
|
sha1_to_hex(lock->old_sha1), sha1_to_hex(old_sha1));
|
|
|
|
unlock_ref(lock);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return lock;
|
|
|
|
}
|
|
|
|
|
2007-09-28 17:28:54 +02:00
|
|
|
static int remove_empty_directories(const char *file)
|
2006-09-30 11:25:30 +02:00
|
|
|
{
|
|
|
|
/* we want to create a file but there is a directory there;
|
|
|
|
* if that is an empty directory (or a directory that contains
|
|
|
|
* only empty directories), remove them.
|
|
|
|
*/
|
2007-09-28 17:28:54 +02:00
|
|
|
struct strbuf path;
|
|
|
|
int result;
|
2006-09-30 11:25:30 +02:00
|
|
|
|
2007-09-28 17:28:54 +02:00
|
|
|
strbuf_init(&path, 20);
|
|
|
|
strbuf_addstr(&path, file);
|
|
|
|
|
2009-07-01 00:33:45 +02:00
|
|
|
result = remove_dir_recursively(&path, REMOVE_DIR_EMPTY_ONLY);
|
2007-09-28 17:28:54 +02:00
|
|
|
|
|
|
|
strbuf_release(&path);
|
|
|
|
|
|
|
|
return result;
|
2006-09-30 11:25:30 +02:00
|
|
|
}
|
|
|
|
|
2011-10-12 19:35:38 +02:00
|
|
|
/*
|
|
|
|
* *string and *len will only be substituted, and *string returned (for
|
|
|
|
* later free()ing) if the string passed in is a magic short-hand form
|
|
|
|
* to name a branch.
|
|
|
|
*/
|
|
|
|
static char *substitute_branch_name(const char **string, int *len)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int ret = interpret_branch_name(*string, &buf);
|
|
|
|
|
|
|
|
if (ret == *len) {
|
|
|
|
size_t size;
|
|
|
|
*string = strbuf_detach(&buf, &size);
|
|
|
|
*len = size;
|
|
|
|
return (char *)*string;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref)
|
|
|
|
{
|
|
|
|
char *last_branch = substitute_branch_name(&str, &len);
|
|
|
|
const char **p, *r;
|
|
|
|
int refs_found = 0;
|
|
|
|
|
|
|
|
*ref = NULL;
|
|
|
|
for (p = ref_rev_parse_rules; *p; p++) {
|
|
|
|
char fullref[PATH_MAX];
|
|
|
|
unsigned char sha1_from_ref[20];
|
|
|
|
unsigned char *this_result;
|
|
|
|
int flag;
|
|
|
|
|
|
|
|
this_result = refs_found ? sha1_from_ref : sha1;
|
|
|
|
mksnpath(fullref, sizeof(fullref), *p, len, str);
|
2011-12-12 12:20:32 +01:00
|
|
|
r = resolve_ref_unsafe(fullref, this_result, 1, &flag);
|
2011-10-12 19:35:38 +02:00
|
|
|
if (r) {
|
|
|
|
if (!refs_found++)
|
|
|
|
*ref = xstrdup(r);
|
|
|
|
if (!warn_ambiguous_refs)
|
|
|
|
break;
|
2011-10-19 22:55:49 +02:00
|
|
|
} else if ((flag & REF_ISSYMREF) && strcmp(fullref, "HEAD")) {
|
2011-10-12 19:35:38 +02:00
|
|
|
warning("ignoring dangling symref %s.", fullref);
|
2011-10-19 22:55:49 +02:00
|
|
|
} else if ((flag & REF_ISBROKEN) && strchr(fullref, '/')) {
|
|
|
|
warning("ignoring broken ref %s.", fullref);
|
|
|
|
}
|
2011-10-12 19:35:38 +02:00
|
|
|
}
|
|
|
|
free(last_branch);
|
|
|
|
return refs_found;
|
|
|
|
}
|
|
|
|
|
|
|
|
int dwim_log(const char *str, int len, unsigned char *sha1, char **log)
|
|
|
|
{
|
|
|
|
char *last_branch = substitute_branch_name(&str, &len);
|
|
|
|
const char **p;
|
|
|
|
int logs_found = 0;
|
|
|
|
|
|
|
|
*log = NULL;
|
|
|
|
for (p = ref_rev_parse_rules; *p; p++) {
|
|
|
|
struct stat st;
|
|
|
|
unsigned char hash[20];
|
|
|
|
char path[PATH_MAX];
|
|
|
|
const char *ref, *it;
|
|
|
|
|
|
|
|
mksnpath(path, sizeof(path), *p, len, str);
|
2011-12-12 12:20:32 +01:00
|
|
|
ref = resolve_ref_unsafe(path, hash, 1, NULL);
|
2011-10-12 19:35:38 +02:00
|
|
|
if (!ref)
|
|
|
|
continue;
|
|
|
|
if (!stat(git_path("logs/%s", path), &st) &&
|
|
|
|
S_ISREG(st.st_mode))
|
|
|
|
it = path;
|
|
|
|
else if (strcmp(ref, path) &&
|
|
|
|
!stat(git_path("logs/%s", ref), &st) &&
|
|
|
|
S_ISREG(st.st_mode))
|
|
|
|
it = ref;
|
|
|
|
else
|
|
|
|
continue;
|
|
|
|
if (!logs_found++) {
|
|
|
|
*log = xstrdup(it);
|
|
|
|
hashcpy(sha1, hash);
|
|
|
|
}
|
|
|
|
if (!warn_ambiguous_refs)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
free(last_branch);
|
|
|
|
return logs_found;
|
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
static struct ref_lock *lock_ref_sha1_basic(const char *refname,
|
|
|
|
const unsigned char *old_sha1,
|
|
|
|
int flags, int *type_p)
|
2006-05-17 11:55:02 +02:00
|
|
|
{
|
Enable the packed refs file format
This actually "turns on" the packed ref file format, now that the
infrastructure to do so sanely exists (ie notably the change to make the
reference reading logic take refnames rather than pathnames to the loose
objects that no longer necessarily even exist).
In particular, when the ref lookup hits a refname that has no loose file
associated with it, it falls back on the packed-ref information. Also, the
ref-locking code, while still using a loose file for the locking itself
(and _creating_ a loose file for the new ref) no longer requires that the
old ref be in such an unpacked state.
Finally, this does a minimal hack to git-checkout.sh to rather than check
the ref-file directly, do a "git-rev-parse" on the "heads/$refname".
That's not really wonderful - we should rather really have a special
routine to verify the names as proper branch head names, but it is a
workable solution for now.
With this, I can literally do something like
git pack-refs
find .git/refs -type f -print0 | xargs -0 rm -f --
and the end result is a largely working repository (ie I've done two
commits - which creates _one_ unpacked ref file - done things like run
"gitk" and "git log" etc, and it all looks ok).
There are probably things missing, but I'm hoping that the missing things
are now of the "small and obvious" kind, and that somebody else might want
to start looking at this too. Hint hint ;)
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-14 19:14:47 +02:00
|
|
|
char *ref_file;
|
2011-12-12 06:38:09 +01:00
|
|
|
const char *orig_refname = refname;
|
2006-05-17 11:55:02 +02:00
|
|
|
struct ref_lock *lock;
|
2006-09-30 23:14:31 +02:00
|
|
|
int last_errno = 0;
|
2008-10-18 00:44:39 +02:00
|
|
|
int type, lflags;
|
2006-09-27 10:09:18 +02:00
|
|
|
int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
|
2008-11-05 21:55:53 +01:00
|
|
|
int missing = 0;
|
2006-05-17 11:55:02 +02:00
|
|
|
|
|
|
|
lock = xcalloc(1, sizeof(struct ref_lock));
|
|
|
|
lock->lock_fd = -1;
|
|
|
|
|
2011-12-20 22:25:53 +01:00
|
|
|
refname = resolve_ref_unsafe(refname, lock->old_sha1, mustexist, &type);
|
2011-12-12 06:38:09 +01:00
|
|
|
if (!refname && errno == EISDIR) {
|
2006-09-30 11:25:30 +02:00
|
|
|
/* we are trying to lock foo but we used to
|
|
|
|
* have foo/bar which now does not exist;
|
|
|
|
* it is normal for the empty directory 'foo'
|
|
|
|
* to remain.
|
|
|
|
*/
|
2011-12-12 06:38:09 +01:00
|
|
|
ref_file = git_path("%s", orig_refname);
|
2006-09-30 23:14:31 +02:00
|
|
|
if (remove_empty_directories(ref_file)) {
|
|
|
|
last_errno = errno;
|
2011-12-12 06:38:09 +01:00
|
|
|
error("there are still refs under '%s'", orig_refname);
|
2006-09-30 23:14:31 +02:00
|
|
|
goto error_return;
|
|
|
|
}
|
2011-12-20 22:25:53 +01:00
|
|
|
refname = resolve_ref_unsafe(orig_refname, lock->old_sha1, mustexist, &type);
|
2006-09-30 11:25:30 +02:00
|
|
|
}
|
2007-05-09 12:33:20 +02:00
|
|
|
if (type_p)
|
|
|
|
*type_p = type;
|
2011-12-12 06:38:09 +01:00
|
|
|
if (!refname) {
|
2006-09-30 23:14:31 +02:00
|
|
|
last_errno = errno;
|
2006-07-29 05:44:51 +02:00
|
|
|
error("unable to resolve reference %s: %s",
|
2011-12-12 06:38:09 +01:00
|
|
|
orig_refname, strerror(errno));
|
2006-09-30 23:14:31 +02:00
|
|
|
goto error_return;
|
2006-05-17 11:55:02 +02:00
|
|
|
}
|
2008-11-05 21:55:53 +01:00
|
|
|
missing = is_null_sha1(lock->old_sha1);
|
2006-11-28 15:47:40 +01:00
|
|
|
/* When the ref did not exist and we are creating it,
|
|
|
|
* make sure there is no existing ref that is packed
|
|
|
|
* whose name begins with our refname, nor a ref whose
|
|
|
|
* name is a proper prefix of our refname.
|
|
|
|
*/
|
2008-11-05 21:55:53 +01:00
|
|
|
if (missing &&
|
2011-12-12 06:38:16 +01:00
|
|
|
!is_refname_available(refname, NULL, get_packed_refs(get_ref_cache(NULL)))) {
|
2009-05-25 12:37:15 +02:00
|
|
|
last_errno = ENOTDIR;
|
2006-11-28 15:47:40 +01:00
|
|
|
goto error_return;
|
2009-05-25 12:37:15 +02:00
|
|
|
}
|
2006-09-30 23:19:25 +02:00
|
|
|
|
2006-06-06 22:54:14 +02:00
|
|
|
lock->lk = xcalloc(1, sizeof(struct lock_file));
|
2006-05-17 11:55:02 +02:00
|
|
|
|
2008-10-18 00:44:39 +02:00
|
|
|
lflags = LOCK_DIE_ON_ERROR;
|
|
|
|
if (flags & REF_NODEREF) {
|
2011-12-12 06:38:09 +01:00
|
|
|
refname = orig_refname;
|
2008-10-18 00:44:39 +02:00
|
|
|
lflags |= LOCK_NODEREF;
|
|
|
|
}
|
2011-12-12 06:38:09 +01:00
|
|
|
lock->ref_name = xstrdup(refname);
|
|
|
|
lock->orig_ref_name = xstrdup(orig_refname);
|
|
|
|
ref_file = git_path("%s", refname);
|
2008-11-05 21:55:53 +01:00
|
|
|
if (missing)
|
2007-05-09 12:33:20 +02:00
|
|
|
lock->force_write = 1;
|
|
|
|
if ((flags & REF_NODEREF) && (type & REF_ISSYMREF))
|
|
|
|
lock->force_write = 1;
|
2006-05-17 11:55:02 +02:00
|
|
|
|
2006-09-30 23:14:31 +02:00
|
|
|
if (safe_create_leading_directories(ref_file)) {
|
|
|
|
last_errno = errno;
|
|
|
|
error("unable to create directory for %s", ref_file);
|
|
|
|
goto error_return;
|
|
|
|
}
|
2006-05-17 11:55:02 +02:00
|
|
|
|
2008-10-18 00:44:39 +02:00
|
|
|
lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, lflags);
|
2006-05-17 11:55:02 +02:00
|
|
|
return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;
|
2006-09-30 23:14:31 +02:00
|
|
|
|
|
|
|
error_return:
|
|
|
|
unlock_ref(lock);
|
|
|
|
errno = last_errno;
|
|
|
|
return NULL;
|
2006-05-17 11:55:02 +02:00
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
struct ref_lock *lock_ref_sha1(const char *refname, const unsigned char *old_sha1)
|
2005-06-06 22:31:29 +02:00
|
|
|
{
|
2006-09-19 22:58:23 +02:00
|
|
|
char refpath[PATH_MAX];
|
2011-12-12 06:38:09 +01:00
|
|
|
if (check_refname_format(refname, 0))
|
2006-05-17 11:55:02 +02:00
|
|
|
return NULL;
|
2011-12-12 06:38:09 +01:00
|
|
|
strcpy(refpath, mkpath("refs/%s", refname));
|
2007-05-09 12:33:20 +02:00
|
|
|
return lock_ref_sha1_basic(refpath, old_sha1, 0, NULL);
|
2006-05-17 11:55:02 +02:00
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
struct ref_lock *lock_any_ref_for_update(const char *refname,
|
|
|
|
const unsigned char *old_sha1, int flags)
|
2006-05-17 11:55:02 +02:00
|
|
|
{
|
2011-12-12 06:38:09 +01:00
|
|
|
if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))
|
2008-01-02 20:14:40 +01:00
|
|
|
return NULL;
|
2011-12-12 06:38:09 +01:00
|
|
|
return lock_ref_sha1_basic(refname, old_sha1, flags, NULL);
|
2006-10-01 00:02:00 +02:00
|
|
|
}
|
|
|
|
|
2013-04-22 21:52:30 +02:00
|
|
|
/*
|
|
|
|
* Write an entry to the packed-refs file for the specified refname.
|
|
|
|
* If peeled is non-NULL, write it as the entry's peeled value.
|
|
|
|
*/
|
|
|
|
static void write_packed_entry(int fd, char *refname, unsigned char *sha1,
|
|
|
|
unsigned char *peeled)
|
2012-04-10 07:30:17 +02:00
|
|
|
{
|
|
|
|
char line[PATH_MAX + 100];
|
|
|
|
int len;
|
|
|
|
|
2013-04-22 21:52:30 +02:00
|
|
|
len = snprintf(line, sizeof(line), "%s %s\n",
|
|
|
|
sha1_to_hex(sha1), refname);
|
|
|
|
/* this should not happen but just being defensive */
|
|
|
|
if (len > sizeof(line))
|
|
|
|
die("too long a refname '%s'", refname);
|
|
|
|
write_or_die(fd, line, len);
|
|
|
|
|
|
|
|
if (peeled) {
|
|
|
|
if (snprintf(line, sizeof(line), "^%s\n",
|
|
|
|
sha1_to_hex(peeled)) != PEELED_LINE_LENGTH)
|
|
|
|
die("internal error");
|
|
|
|
write_or_die(fd, line, PEELED_LINE_LENGTH);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-22 21:52:32 +02:00
|
|
|
struct ref_to_prune {
|
|
|
|
struct ref_to_prune *next;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
char name[FLEX_ARRAY];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct pack_refs_cb_data {
|
|
|
|
unsigned int flags;
|
|
|
|
struct ref_to_prune *ref_to_prune;
|
|
|
|
FILE *refs_file;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int do_not_prune(int flags)
|
|
|
|
{
|
|
|
|
/* If it is already packed or if it is a symref,
|
|
|
|
* do not prune it.
|
|
|
|
*/
|
|
|
|
return (flags & (REF_ISSYMREF|REF_ISPACKED));
|
|
|
|
}
|
|
|
|
|
2013-04-22 21:52:33 +02:00
|
|
|
static int pack_one_ref(const char *refname, const unsigned char *sha1,
|
2013-04-22 21:52:32 +02:00
|
|
|
int flags, void *cb_data)
|
|
|
|
{
|
|
|
|
struct pack_refs_cb_data *cb = cb_data;
|
|
|
|
struct object *o;
|
|
|
|
int is_tag_ref;
|
|
|
|
|
|
|
|
/* Do not pack the symbolic refs */
|
|
|
|
if ((flags & REF_ISSYMREF))
|
|
|
|
return 0;
|
2013-04-22 21:52:33 +02:00
|
|
|
is_tag_ref = !prefixcmp(refname, "refs/tags/");
|
2013-04-22 21:52:32 +02:00
|
|
|
|
|
|
|
/* ALWAYS pack refs that were already packed or are tags */
|
|
|
|
if (!(cb->flags & PACK_REFS_ALL) && !is_tag_ref && !(flags & REF_ISPACKED))
|
|
|
|
return 0;
|
|
|
|
|
2013-04-22 21:52:33 +02:00
|
|
|
fprintf(cb->refs_file, "%s %s\n", sha1_to_hex(sha1), refname);
|
2013-04-22 21:52:32 +02:00
|
|
|
|
2013-04-22 21:52:33 +02:00
|
|
|
o = parse_object_or_die(sha1, refname);
|
2013-04-22 21:52:32 +02:00
|
|
|
if (o->type == OBJ_TAG) {
|
2013-04-22 21:52:33 +02:00
|
|
|
o = deref_tag(o, refname, 0);
|
2013-04-22 21:52:32 +02:00
|
|
|
if (o)
|
|
|
|
fprintf(cb->refs_file, "^%s\n",
|
|
|
|
sha1_to_hex(o->sha1));
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((cb->flags & PACK_REFS_PRUNE) && !do_not_prune(flags)) {
|
2013-04-22 21:52:33 +02:00
|
|
|
int namelen = strlen(refname) + 1;
|
2013-04-22 21:52:32 +02:00
|
|
|
struct ref_to_prune *n = xcalloc(1, sizeof(*n) + namelen);
|
|
|
|
hashcpy(n->sha1, sha1);
|
2013-04-22 21:52:33 +02:00
|
|
|
strcpy(n->name, refname);
|
2013-04-22 21:52:32 +02:00
|
|
|
n->next = cb->ref_to_prune;
|
|
|
|
cb->ref_to_prune = n;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove empty parents, but spare refs/ and immediate subdirs.
|
|
|
|
* Note: munges *name.
|
|
|
|
*/
|
|
|
|
static void try_remove_empty_parents(char *name)
|
|
|
|
{
|
|
|
|
char *p, *q;
|
|
|
|
int i;
|
|
|
|
p = name;
|
|
|
|
for (i = 0; i < 2; i++) { /* refs/{heads,tags,...}/ */
|
|
|
|
while (*p && *p != '/')
|
|
|
|
p++;
|
|
|
|
/* tolerate duplicate slashes; see check_refname_format() */
|
|
|
|
while (*p == '/')
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
for (q = p; *q; q++)
|
|
|
|
;
|
|
|
|
while (1) {
|
|
|
|
while (q > p && *q != '/')
|
|
|
|
q--;
|
|
|
|
while (q > p && *(q-1) == '/')
|
|
|
|
q--;
|
|
|
|
if (q == p)
|
|
|
|
break;
|
|
|
|
*q = '\0';
|
|
|
|
if (rmdir(git_path("%s", name)))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* make sure nobody touched the ref, and unlink */
|
|
|
|
static void prune_ref(struct ref_to_prune *r)
|
|
|
|
{
|
|
|
|
struct ref_lock *lock = lock_ref_sha1(r->name + 5, r->sha1);
|
|
|
|
|
|
|
|
if (lock) {
|
|
|
|
unlink_or_warn(git_path("%s", r->name));
|
|
|
|
unlock_ref(lock);
|
|
|
|
try_remove_empty_parents(r->name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void prune_refs(struct ref_to_prune *r)
|
|
|
|
{
|
|
|
|
while (r) {
|
|
|
|
prune_ref(r);
|
|
|
|
r = r->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct lock_file packed;
|
|
|
|
|
|
|
|
int pack_refs(unsigned int flags)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
struct pack_refs_cb_data cbdata;
|
|
|
|
|
|
|
|
memset(&cbdata, 0, sizeof(cbdata));
|
|
|
|
cbdata.flags = flags;
|
|
|
|
|
|
|
|
fd = hold_lock_file_for_update(&packed, git_path("packed-refs"),
|
|
|
|
LOCK_DIE_ON_ERROR);
|
|
|
|
cbdata.refs_file = fdopen(fd, "w");
|
|
|
|
if (!cbdata.refs_file)
|
|
|
|
die_errno("unable to create ref-pack file structure");
|
|
|
|
|
|
|
|
/* perhaps other traits later as well */
|
|
|
|
fprintf(cbdata.refs_file, "# pack-refs with: peeled fully-peeled \n");
|
|
|
|
|
|
|
|
for_each_ref(pack_one_ref, &cbdata);
|
|
|
|
if (ferror(cbdata.refs_file))
|
|
|
|
die("failed to write ref-pack file");
|
|
|
|
if (fflush(cbdata.refs_file) || fsync(fd) || fclose(cbdata.refs_file))
|
|
|
|
die_errno("failed to write ref-pack file");
|
|
|
|
/*
|
|
|
|
* Since the lock file was fdopen()'ed and then fclose()'ed above,
|
|
|
|
* assign -1 to the lock file descriptor so that commit_lock_file()
|
|
|
|
* won't try to close() it.
|
|
|
|
*/
|
|
|
|
packed.fd = -1;
|
|
|
|
if (commit_lock_file(&packed) < 0)
|
|
|
|
die_errno("unable to overwrite old ref-pack file");
|
|
|
|
prune_refs(cbdata.ref_to_prune);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-04-22 21:52:30 +02:00
|
|
|
static int repack_ref_fn(struct ref_entry *entry, void *cb_data)
|
|
|
|
{
|
|
|
|
int *fd = cb_data;
|
|
|
|
enum peel_status peel_status;
|
|
|
|
|
2013-04-22 21:52:25 +02:00
|
|
|
if (entry->flag & REF_ISBROKEN) {
|
|
|
|
/* This shouldn't happen to packed refs. */
|
|
|
|
error("%s is broken!", entry->name);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (!has_sha1_file(entry->u.value.sha1)) {
|
|
|
|
unsigned char sha1[20];
|
|
|
|
int flags;
|
|
|
|
|
|
|
|
if (read_ref_full(entry->name, sha1, 0, &flags))
|
|
|
|
/* We should at least have found the packed ref. */
|
|
|
|
die("Internal error");
|
|
|
|
if ((flags & REF_ISSYMREF) || !(flags & REF_ISPACKED))
|
|
|
|
/*
|
|
|
|
* This packed reference is overridden by a
|
|
|
|
* loose reference, so it is OK that its value
|
|
|
|
* is no longer valid; for example, it might
|
|
|
|
* refer to an object that has been garbage
|
|
|
|
* collected. For this purpose we don't even
|
|
|
|
* care whether the loose reference itself is
|
|
|
|
* invalid, broken, symbolic, etc. Silently
|
|
|
|
* omit the packed reference from the output.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
/*
|
|
|
|
* There is no overriding loose reference, so the fact
|
|
|
|
* that this reference doesn't refer to a valid object
|
|
|
|
* indicates some kind of repository corruption.
|
|
|
|
* Report the problem, then omit the reference from
|
|
|
|
* the output.
|
|
|
|
*/
|
|
|
|
error("%s does not point to a valid object!", entry->name);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-04-22 21:52:30 +02:00
|
|
|
peel_status = peel_entry(entry);
|
|
|
|
write_packed_entry(*fd, entry->name, entry->u.value.sha1,
|
|
|
|
peel_status == PEEL_PEELED ?
|
|
|
|
entry->u.value.peeled : NULL);
|
repack_without_ref(): write peeled refs in the rewritten file
When a reference that existed in the packed-refs file is deleted, the
packed-refs file must be rewritten. Previously, the file was
rewritten without any peeled refs, even if the file contained peeled
refs when it was read. This was not a bug, because the packed-refs
file header didn't claim that the file contained peeled values. But
it had a performance cost, because the repository would lose the
benefit of having precomputed peeled references until pack-refs was
run again.
Teach repack_without_ref() to write peeled refs to the packed-refs
file (regardless of whether they were present in the old version of
the file).
This means that if the old version of the packed-refs file was not
fully peeled, then repack_without_ref() will have to peel references.
To avoid the expense of reading lots of loose references, we take two
shortcuts relative to pack-refs:
* If the peeled value of a reference is already known (i.e., because
it was read from the old version of the packed-refs file), then
output that peeled value again without any checks. This is the
usual code path and should avoid any noticeable overhead. (This is
different than pack-refs, which always re-peels references.)
* We don't verify that the packed ref is still current. It could be
that a packed references is overridden by a loose reference, in
which case the packed ref is no longer needed and might even refer
to an object that has been garbage collected. But we don't check;
instead, we just try to peel all references. If peeling is
successful, the peeled value is written out (even though it might
not be needed any more); if not, then the reference is silently
omitted from the output.
The extra overhead of peeling references in repack_without_ref()
should only be incurred the first time the packed-refs file is written
by a version of Git that knows about the "fully-peeled" attribute.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:29 +02:00
|
|
|
|
2012-04-10 07:30:17 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-01 20:41:00 +02:00
|
|
|
static struct lock_file packlock;
|
|
|
|
|
2006-10-01 00:02:00 +02:00
|
|
|
static int repack_without_ref(const char *refname)
|
|
|
|
{
|
2013-04-22 21:52:27 +02:00
|
|
|
int fd;
|
refs: do not use cached refs in repack_without_ref
When we delete a ref that is packed, we rewrite the whole
packed-refs file and simply omit the ref that no longer
exists. However, we base the rewrite on whatever happens to
be in our refs cache, not what is necessarily on disk. That
opens us up to a race condition if another process is
simultaneously packing the refs, as we will overwrite their
newly-made pack-refs file with our potentially stale data,
losing commits.
You can demonstrate the race like this:
# setup some repositories
git init --bare parent &&
(cd parent && git config core.logallrefupdates true) &&
git clone parent child &&
(cd child && git commit --allow-empty -m base)
# in one terminal, repack the refs repeatedly
cd parent &&
while true; do
git pack-refs --all
done
# in another terminal, simultaneously push updates to
# master, and create and delete an unrelated ref
cd child &&
while true; do
git push origin HEAD:newbranch &&
git commit --allow-empty -m foo
us=`git rev-parse master` &&
git push origin master &&
git push origin :newbranch &&
them=`git --git-dir=../parent rev-parse master` &&
if test "$them" != "$us"; then
echo >&2 "$them" != "$us"
exit 1
fi
done
In many cases the two processes will conflict over locking
the packed-refs file, and the deletion of newbranch will
simply fail. But eventually you will hit the race, which
happens like this:
1. We push a new commit to master. It is already packed
(from the looping pack-refs call). We write the new
value (let us call it B) to $GIT_DIR/refs/heads/master,
but the old value (call it A) remains in the
packed-refs file.
2. We push the deletion of newbranch, spawning a
receive-pack process. Receive-pack advertises all refs
to the client, causing it to iterate over each ref; it
caches the packed refs in memory, which points at the
stale value A.
3. Meanwhile, a separate pack-refs process is running. It
runs to completion, updating the packed-refs file to
point master at B, and deleting $GIT_DIR/refs/heads/master
which also pointed at B.
4. Back in the receive-pack process, we get the
instruction to delete :newbranch. We take a lock on
packed-refs (which works, as the other pack-refs
process has already finished). We then rewrite the
contents using the cached refs, which contain the stale
value A.
The resulting packed-refs file points master once again at
A. The loose ref which would override it to point at B was
deleted (rightfully) in step 3. As a result, master now
points at A. The only trace that B ever existed in the
parent is in the reflog: the final entry will show master
moving from A to B, even though the ref still points at A
(so you can detect this race after the fact, because the
next reflog entry will move from A to C).
We can fix this by invalidating the packed-refs cache after
we have taken the lock. This means that we will re-read the
packed-refs file, and since we have the lock, we will be
sure that what we read will be atomically up-to-date when we
write (it may be out of date with respect to loose refs, but
that is OK, as loose refs take precedence).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-12-21 09:04:49 +01:00
|
|
|
struct ref_cache *refs = get_ref_cache(NULL);
|
2013-04-22 21:52:17 +02:00
|
|
|
struct ref_dir *packed;
|
|
|
|
|
|
|
|
if (!get_packed_ref(refname))
|
|
|
|
return 0; /* refname does not exist in packed refs */
|
|
|
|
|
2013-04-22 21:52:27 +02:00
|
|
|
fd = hold_lock_file_for_update(&packlock, git_path("packed-refs"), 0);
|
|
|
|
if (fd < 0) {
|
2009-09-27 01:15:09 +02:00
|
|
|
unable_to_lock_error(git_path("packed-refs"), errno);
|
2006-10-01 00:02:00 +02:00
|
|
|
return error("cannot delete '%s' from packed refs", refname);
|
2009-09-27 01:15:09 +02:00
|
|
|
}
|
refs: do not use cached refs in repack_without_ref
When we delete a ref that is packed, we rewrite the whole
packed-refs file and simply omit the ref that no longer
exists. However, we base the rewrite on whatever happens to
be in our refs cache, not what is necessarily on disk. That
opens us up to a race condition if another process is
simultaneously packing the refs, as we will overwrite their
newly-made pack-refs file with our potentially stale data,
losing commits.
You can demonstrate the race like this:
# setup some repositories
git init --bare parent &&
(cd parent && git config core.logallrefupdates true) &&
git clone parent child &&
(cd child && git commit --allow-empty -m base)
# in one terminal, repack the refs repeatedly
cd parent &&
while true; do
git pack-refs --all
done
# in another terminal, simultaneously push updates to
# master, and create and delete an unrelated ref
cd child &&
while true; do
git push origin HEAD:newbranch &&
git commit --allow-empty -m foo
us=`git rev-parse master` &&
git push origin master &&
git push origin :newbranch &&
them=`git --git-dir=../parent rev-parse master` &&
if test "$them" != "$us"; then
echo >&2 "$them" != "$us"
exit 1
fi
done
In many cases the two processes will conflict over locking
the packed-refs file, and the deletion of newbranch will
simply fail. But eventually you will hit the race, which
happens like this:
1. We push a new commit to master. It is already packed
(from the looping pack-refs call). We write the new
value (let us call it B) to $GIT_DIR/refs/heads/master,
but the old value (call it A) remains in the
packed-refs file.
2. We push the deletion of newbranch, spawning a
receive-pack process. Receive-pack advertises all refs
to the client, causing it to iterate over each ref; it
caches the packed refs in memory, which points at the
stale value A.
3. Meanwhile, a separate pack-refs process is running. It
runs to completion, updating the packed-refs file to
point master at B, and deleting $GIT_DIR/refs/heads/master
which also pointed at B.
4. Back in the receive-pack process, we get the
instruction to delete :newbranch. We take a lock on
packed-refs (which works, as the other pack-refs
process has already finished). We then rewrite the
contents using the cached refs, which contain the stale
value A.
The resulting packed-refs file points master once again at
A. The loose ref which would override it to point at B was
deleted (rightfully) in step 3. As a result, master now
points at A. The only trace that B ever existed in the
parent is in the reflog: the final entry will show master
moving from A to B, even though the ref still points at A
(so you can detect this race after the fact, because the
next reflog entry will move from A to C).
We can fix this by invalidating the packed-refs cache after
we have taken the lock. This means that we will re-read the
packed-refs file, and since we have the lock, we will be
sure that what we read will be atomically up-to-date when we
write (it may be out of date with respect to loose refs, but
that is OK, as loose refs take precedence).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-12-21 09:04:49 +01:00
|
|
|
clear_packed_ref_cache(refs);
|
|
|
|
packed = get_packed_refs(refs);
|
2013-04-22 21:52:27 +02:00
|
|
|
/* Remove refname from the cache. */
|
|
|
|
if (remove_entry(packed, refname) == -1) {
|
|
|
|
/*
|
|
|
|
* The packed entry disappeared while we were
|
|
|
|
* acquiring the lock.
|
|
|
|
*/
|
|
|
|
rollback_lock_file(&packlock);
|
|
|
|
return 0;
|
|
|
|
}
|
repack_without_ref(): write peeled refs in the rewritten file
When a reference that existed in the packed-refs file is deleted, the
packed-refs file must be rewritten. Previously, the file was
rewritten without any peeled refs, even if the file contained peeled
refs when it was read. This was not a bug, because the packed-refs
file header didn't claim that the file contained peeled values. But
it had a performance cost, because the repository would lose the
benefit of having precomputed peeled references until pack-refs was
run again.
Teach repack_without_ref() to write peeled refs to the packed-refs
file (regardless of whether they were present in the old version of
the file).
This means that if the old version of the packed-refs file was not
fully peeled, then repack_without_ref() will have to peel references.
To avoid the expense of reading lots of loose references, we take two
shortcuts relative to pack-refs:
* If the peeled value of a reference is already known (i.e., because
it was read from the old version of the packed-refs file), then
output that peeled value again without any checks. This is the
usual code path and should avoid any noticeable overhead. (This is
different than pack-refs, which always re-peels references.)
* We don't verify that the packed ref is still current. It could be
that a packed references is overridden by a loose reference, in
which case the packed ref is no longer needed and might even refer
to an object that has been garbage collected. But we don't check;
instead, we just try to peel all references. If peeling is
successful, the peeled value is written out (even though it might
not be needed any more); if not, then the reference is silently
omitted from the output.
The extra overhead of peeling references in repack_without_ref()
should only be incurred the first time the packed-refs file is written
by a version of Git that knows about the "fully-peeled" attribute.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-22 21:52:29 +02:00
|
|
|
write_or_die(fd, PACKED_REFS_HEADER, strlen(PACKED_REFS_HEADER));
|
2013-04-22 21:52:27 +02:00
|
|
|
do_for_each_entry_in_dir(packed, 0, repack_ref_fn, &fd);
|
2006-10-01 00:02:00 +02:00
|
|
|
return commit_lock_file(&packlock);
|
|
|
|
}
|
|
|
|
|
2008-10-26 03:33:56 +01:00
|
|
|
int delete_ref(const char *refname, const unsigned char *sha1, int delopt)
|
2006-10-01 00:02:00 +02:00
|
|
|
{
|
|
|
|
struct ref_lock *lock;
|
2008-10-26 03:33:56 +01:00
|
|
|
int err, i = 0, ret = 0, flag = 0;
|
2006-10-01 00:02:00 +02:00
|
|
|
|
2012-10-16 12:22:15 +02:00
|
|
|
lock = lock_ref_sha1_basic(refname, sha1, delopt, &flag);
|
2006-10-01 00:02:00 +02:00
|
|
|
if (!lock)
|
|
|
|
return 1;
|
2008-11-01 00:25:44 +01:00
|
|
|
if (!(flag & REF_ISPACKED) || flag & REF_ISSYMREF) {
|
2006-10-01 00:02:00 +02:00
|
|
|
/* loose */
|
2012-10-16 12:22:15 +02:00
|
|
|
i = strlen(lock->lk->filename) - 5; /* .lock */
|
|
|
|
lock->lk->filename[i] = 0;
|
|
|
|
err = unlink_or_warn(lock->lk->filename);
|
2009-04-29 23:22:56 +02:00
|
|
|
if (err && errno != ENOENT)
|
2006-10-01 00:02:00 +02:00
|
|
|
ret = 1;
|
2009-04-29 23:22:56 +02:00
|
|
|
|
2012-10-16 12:22:15 +02:00
|
|
|
lock->lk->filename[i] = '.';
|
2006-10-01 00:02:00 +02:00
|
|
|
}
|
|
|
|
/* removing the loose one could have resurrected an earlier
|
|
|
|
* packed one. Also, if it was not loose we need to repack
|
|
|
|
* without it.
|
|
|
|
*/
|
2012-10-21 12:40:32 +02:00
|
|
|
ret |= repack_without_ref(lock->ref_name);
|
2006-10-01 00:02:00 +02:00
|
|
|
|
2009-04-29 23:22:56 +02:00
|
|
|
unlink_or_warn(git_path("logs/%s", lock->ref_name));
|
2013-04-22 21:52:27 +02:00
|
|
|
clear_loose_ref_cache(get_ref_cache(NULL));
|
2006-10-01 00:02:00 +02:00
|
|
|
unlock_ref(lock);
|
|
|
|
return ret;
|
2006-05-17 11:55:02 +02:00
|
|
|
}
|
|
|
|
|
2010-07-07 09:47:20 +02:00
|
|
|
/*
|
|
|
|
* People using contrib's git-new-workdir have .git/logs/refs ->
|
|
|
|
* /some/other/path/.git/logs/refs, and that may live on another device.
|
|
|
|
*
|
|
|
|
* IOW, to avoid cross device rename errors, the temporary renamed log must
|
|
|
|
* live into logs/refs.
|
|
|
|
*/
|
|
|
|
#define TMP_RENAMED_LOG "logs/refs/.tmp-renamed-log"
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
int rename_ref(const char *oldrefname, const char *newrefname, const char *logmsg)
|
2006-11-28 15:47:40 +01:00
|
|
|
{
|
|
|
|
unsigned char sha1[20], orig_sha1[20];
|
|
|
|
int flag = 0, logmoved = 0;
|
|
|
|
struct ref_lock *lock;
|
|
|
|
struct stat loginfo;
|
2011-12-12 06:38:09 +01:00
|
|
|
int log = !lstat(git_path("logs/%s", oldrefname), &loginfo);
|
2008-10-26 03:33:56 +01:00
|
|
|
const char *symref = NULL;
|
2011-12-12 06:38:16 +01:00
|
|
|
struct ref_cache *refs = get_ref_cache(NULL);
|
2006-11-28 15:47:40 +01:00
|
|
|
|
2008-10-26 03:33:57 +01:00
|
|
|
if (log && S_ISLNK(loginfo.st_mode))
|
2011-12-12 06:38:09 +01:00
|
|
|
return error("reflog for %s is a symlink", oldrefname);
|
2006-11-28 15:47:40 +01:00
|
|
|
|
2011-12-20 22:25:53 +01:00
|
|
|
symref = resolve_ref_unsafe(oldrefname, orig_sha1, 1, &flag);
|
2008-10-26 03:33:56 +01:00
|
|
|
if (flag & REF_ISSYMREF)
|
2008-10-29 01:05:27 +01:00
|
|
|
return error("refname %s is a symbolic ref, renaming it is not supported",
|
2011-12-12 06:38:09 +01:00
|
|
|
oldrefname);
|
2008-10-26 03:33:56 +01:00
|
|
|
if (!symref)
|
2011-12-12 06:38:09 +01:00
|
|
|
return error("refname %s not found", oldrefname);
|
2006-11-28 15:47:40 +01:00
|
|
|
|
2011-12-12 06:38:16 +01:00
|
|
|
if (!is_refname_available(newrefname, oldrefname, get_packed_refs(refs)))
|
2006-11-28 15:47:40 +01:00
|
|
|
return 1;
|
|
|
|
|
2011-12-12 06:38:16 +01:00
|
|
|
if (!is_refname_available(newrefname, oldrefname, get_loose_refs(refs)))
|
2006-11-28 15:47:40 +01:00
|
|
|
return 1;
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
if (log && rename(git_path("logs/%s", oldrefname), git_path(TMP_RENAMED_LOG)))
|
2010-07-07 09:47:20 +02:00
|
|
|
return error("unable to move logfile logs/%s to "TMP_RENAMED_LOG": %s",
|
2011-12-12 06:38:09 +01:00
|
|
|
oldrefname, strerror(errno));
|
2006-11-28 15:47:40 +01:00
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
if (delete_ref(oldrefname, orig_sha1, REF_NODEREF)) {
|
|
|
|
error("unable to delete old %s", oldrefname);
|
2006-11-28 15:47:40 +01:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
if (!read_ref_full(newrefname, sha1, 1, &flag) &&
|
|
|
|
delete_ref(newrefname, sha1, REF_NODEREF)) {
|
2006-11-28 15:47:40 +01:00
|
|
|
if (errno==EISDIR) {
|
2011-12-12 06:38:09 +01:00
|
|
|
if (remove_empty_directories(git_path("%s", newrefname))) {
|
|
|
|
error("Directory not empty: %s", newrefname);
|
2006-11-28 15:47:40 +01:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
} else {
|
2011-12-12 06:38:09 +01:00
|
|
|
error("unable to delete existing %s", newrefname);
|
2006-11-28 15:47:40 +01:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
if (log && safe_create_leading_directories(git_path("logs/%s", newrefname))) {
|
|
|
|
error("unable to create directory for %s", newrefname);
|
2006-11-28 15:47:40 +01:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
|
|
|
|
retry:
|
2011-12-12 06:38:09 +01:00
|
|
|
if (log && rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", newrefname))) {
|
2007-01-16 02:30:59 +01:00
|
|
|
if (errno==EISDIR || errno==ENOTDIR) {
|
|
|
|
/*
|
|
|
|
* rename(a, b) when b is an existing
|
|
|
|
* directory ought to result in ISDIR, but
|
|
|
|
* Solaris 5.8 gives ENOTDIR. Sheesh.
|
|
|
|
*/
|
2011-12-12 06:38:09 +01:00
|
|
|
if (remove_empty_directories(git_path("logs/%s", newrefname))) {
|
|
|
|
error("Directory not empty: logs/%s", newrefname);
|
2006-11-28 15:47:40 +01:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
goto retry;
|
|
|
|
} else {
|
2010-07-07 09:47:20 +02:00
|
|
|
error("unable to move logfile "TMP_RENAMED_LOG" to logs/%s: %s",
|
2011-12-12 06:38:09 +01:00
|
|
|
newrefname, strerror(errno));
|
2006-11-28 15:47:40 +01:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
logmoved = log;
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
lock = lock_ref_sha1_basic(newrefname, NULL, 0, NULL);
|
2006-11-28 15:47:40 +01:00
|
|
|
if (!lock) {
|
2011-12-12 06:38:09 +01:00
|
|
|
error("unable to lock %s for update", newrefname);
|
2006-11-28 15:47:40 +01:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
lock->force_write = 1;
|
|
|
|
hashcpy(lock->old_sha1, orig_sha1);
|
2006-11-30 03:16:56 +01:00
|
|
|
if (write_ref_sha1(lock, orig_sha1, logmsg)) {
|
2011-12-12 06:38:09 +01:00
|
|
|
error("unable to write current sha1 into %s", newrefname);
|
2006-11-28 15:47:40 +01:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
rollback:
|
2011-12-12 06:38:09 +01:00
|
|
|
lock = lock_ref_sha1_basic(oldrefname, NULL, 0, NULL);
|
2006-11-28 15:47:40 +01:00
|
|
|
if (!lock) {
|
2011-12-12 06:38:09 +01:00
|
|
|
error("unable to lock %s for rollback", oldrefname);
|
2006-11-28 15:47:40 +01:00
|
|
|
goto rollbacklog;
|
|
|
|
}
|
|
|
|
|
|
|
|
lock->force_write = 1;
|
|
|
|
flag = log_all_ref_updates;
|
|
|
|
log_all_ref_updates = 0;
|
|
|
|
if (write_ref_sha1(lock, orig_sha1, NULL))
|
2011-12-12 06:38:09 +01:00
|
|
|
error("unable to write current sha1 into %s", oldrefname);
|
2006-11-28 15:47:40 +01:00
|
|
|
log_all_ref_updates = flag;
|
|
|
|
|
|
|
|
rollbacklog:
|
2011-12-12 06:38:09 +01:00
|
|
|
if (logmoved && rename(git_path("logs/%s", newrefname), git_path("logs/%s", oldrefname)))
|
2006-11-28 15:47:40 +01:00
|
|
|
error("unable to restore logfile %s from %s: %s",
|
2011-12-12 06:38:09 +01:00
|
|
|
oldrefname, newrefname, strerror(errno));
|
2006-11-28 15:47:40 +01:00
|
|
|
if (!logmoved && log &&
|
2011-12-12 06:38:09 +01:00
|
|
|
rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", oldrefname)))
|
2010-07-07 09:47:20 +02:00
|
|
|
error("unable to restore logfile %s from "TMP_RENAMED_LOG": %s",
|
2011-12-12 06:38:09 +01:00
|
|
|
oldrefname, strerror(errno));
|
2006-11-28 15:47:40 +01:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-02-22 19:57:30 +01:00
|
|
|
int close_ref(struct ref_lock *lock)
|
2008-01-16 20:14:30 +01:00
|
|
|
{
|
|
|
|
if (close_lock_file(lock->lk))
|
|
|
|
return -1;
|
|
|
|
lock->lock_fd = -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-22 19:57:30 +01:00
|
|
|
int commit_ref(struct ref_lock *lock)
|
2008-01-16 20:14:30 +01:00
|
|
|
{
|
|
|
|
if (commit_lock_file(lock->lk))
|
|
|
|
return -1;
|
|
|
|
lock->lock_fd = -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-06-06 23:04:17 +02:00
|
|
|
void unlock_ref(struct ref_lock *lock)
|
2006-05-17 11:55:02 +02:00
|
|
|
{
|
2008-01-16 20:12:46 +01:00
|
|
|
/* Do not free lock->lk -- atexit() still looks at them */
|
|
|
|
if (lock->lk)
|
|
|
|
rollback_lock_file(lock->lk);
|
Enable the packed refs file format
This actually "turns on" the packed ref file format, now that the
infrastructure to do so sanely exists (ie notably the change to make the
reference reading logic take refnames rather than pathnames to the loose
objects that no longer necessarily even exist).
In particular, when the ref lookup hits a refname that has no loose file
associated with it, it falls back on the packed-ref information. Also, the
ref-locking code, while still using a loose file for the locking itself
(and _creating_ a loose file for the new ref) no longer requires that the
old ref be in such an unpacked state.
Finally, this does a minimal hack to git-checkout.sh to rather than check
the ref-file directly, do a "git-rev-parse" on the "heads/$refname".
That's not really wonderful - we should rather really have a special
routine to verify the names as proper branch head names, but it is a
workable solution for now.
With this, I can literally do something like
git pack-refs
find .git/refs -type f -print0 | xargs -0 rm -f --
and the end result is a largely working repository (ie I've done two
commits - which creates _one_ unpacked ref file - done things like run
"gitk" and "git log" etc, and it all looks ok).
There are probably things missing, but I'm hoping that the missing things
are now of the "small and obvious" kind, and that somebody else might want
to start looking at this too. Hint hint ;)
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-14 19:14:47 +02:00
|
|
|
free(lock->ref_name);
|
2007-01-26 23:26:06 +01:00
|
|
|
free(lock->orig_ref_name);
|
2006-05-17 11:55:02 +02:00
|
|
|
free(lock);
|
|
|
|
}
|
|
|
|
|
2007-07-29 02:17:17 +02:00
|
|
|
/*
|
|
|
|
* copy the reflog message msg to buf, which has been allocated sufficiently
|
|
|
|
* large, while cleaning up the whitespaces. Especially, convert LF to space,
|
|
|
|
* because reflog file is one line per entry.
|
|
|
|
*/
|
|
|
|
static int copy_msg(char *buf, const char *msg)
|
|
|
|
{
|
|
|
|
char *cp = buf;
|
|
|
|
char c;
|
|
|
|
int wasspace = 1;
|
|
|
|
|
|
|
|
*cp++ = '\t';
|
|
|
|
while ((c = *msg++)) {
|
|
|
|
if (wasspace && isspace(c))
|
|
|
|
continue;
|
|
|
|
wasspace = isspace(c);
|
|
|
|
if (wasspace)
|
|
|
|
c = ' ';
|
|
|
|
*cp++ = c;
|
|
|
|
}
|
|
|
|
while (buf < cp && isspace(cp[-1]))
|
|
|
|
cp--;
|
|
|
|
*cp++ = '\n';
|
|
|
|
return cp - buf;
|
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
int log_ref_setup(const char *refname, char *logfile, int bufsize)
|
2006-05-17 11:55:40 +02:00
|
|
|
{
|
2010-05-22 02:28:36 +02:00
|
|
|
int logfd, oflags = O_APPEND | O_WRONLY;
|
2007-01-26 23:26:05 +01:00
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
git_snpath(logfile, bufsize, "logs/%s", refname);
|
2006-10-08 10:35:18 +02:00
|
|
|
if (log_all_ref_updates &&
|
2011-12-12 06:38:09 +01:00
|
|
|
(!prefixcmp(refname, "refs/heads/") ||
|
|
|
|
!prefixcmp(refname, "refs/remotes/") ||
|
|
|
|
!prefixcmp(refname, "refs/notes/") ||
|
|
|
|
!strcmp(refname, "HEAD"))) {
|
2010-06-10 14:54:03 +02:00
|
|
|
if (safe_create_leading_directories(logfile) < 0)
|
2006-05-17 11:55:40 +02:00
|
|
|
return error("unable to create directory for %s",
|
2010-06-10 14:54:03 +02:00
|
|
|
logfile);
|
2006-05-17 11:55:40 +02:00
|
|
|
oflags |= O_CREAT;
|
|
|
|
}
|
|
|
|
|
2010-06-10 14:54:03 +02:00
|
|
|
logfd = open(logfile, oflags, 0666);
|
2006-05-17 11:55:40 +02:00
|
|
|
if (logfd < 0) {
|
2006-10-10 06:15:59 +02:00
|
|
|
if (!(oflags & O_CREAT) && errno == ENOENT)
|
2006-05-17 11:55:40 +02:00
|
|
|
return 0;
|
2006-10-19 10:28:47 +02:00
|
|
|
|
|
|
|
if ((oflags & O_CREAT) && errno == EISDIR) {
|
2010-06-10 14:54:03 +02:00
|
|
|
if (remove_empty_directories(logfile)) {
|
2006-10-19 10:28:47 +02:00
|
|
|
return error("There are still logs under '%s'",
|
2010-06-10 14:54:03 +02:00
|
|
|
logfile);
|
2006-10-19 10:28:47 +02:00
|
|
|
}
|
2010-06-10 14:54:03 +02:00
|
|
|
logfd = open(logfile, oflags, 0666);
|
2006-10-19 10:28:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (logfd < 0)
|
|
|
|
return error("Unable to append to %s: %s",
|
2010-06-10 14:54:03 +02:00
|
|
|
logfile, strerror(errno));
|
2006-05-17 11:55:40 +02:00
|
|
|
}
|
|
|
|
|
2010-06-10 14:54:03 +02:00
|
|
|
adjust_shared_perm(logfile);
|
2010-05-22 02:28:36 +02:00
|
|
|
close(logfd);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-03-09 23:38:57 +01:00
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
static int log_ref_write(const char *refname, const unsigned char *old_sha1,
|
2010-05-22 02:28:36 +02:00
|
|
|
const unsigned char *new_sha1, const char *msg)
|
|
|
|
{
|
|
|
|
int logfd, result, written, oflags = O_APPEND | O_WRONLY;
|
|
|
|
unsigned maxlen, len;
|
|
|
|
int msglen;
|
2010-06-10 14:54:03 +02:00
|
|
|
char log_file[PATH_MAX];
|
2010-05-22 02:28:36 +02:00
|
|
|
char *logrec;
|
|
|
|
const char *committer;
|
|
|
|
|
|
|
|
if (log_all_ref_updates < 0)
|
|
|
|
log_all_ref_updates = !is_bare_repository();
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
result = log_ref_setup(refname, log_file, sizeof(log_file));
|
2010-05-22 02:28:36 +02:00
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
logfd = open(log_file, oflags);
|
|
|
|
if (logfd < 0)
|
|
|
|
return 0;
|
2007-07-29 02:17:17 +02:00
|
|
|
msglen = msg ? strlen(msg) : 0;
|
2007-12-09 02:32:08 +01:00
|
|
|
committer = git_committer_info(0);
|
2007-01-26 11:26:04 +01:00
|
|
|
maxlen = strlen(committer) + msglen + 100;
|
|
|
|
logrec = xmalloc(maxlen);
|
|
|
|
len = sprintf(logrec, "%s %s %s\n",
|
2007-01-26 23:26:05 +01:00
|
|
|
sha1_to_hex(old_sha1),
|
|
|
|
sha1_to_hex(new_sha1),
|
2007-01-26 11:26:04 +01:00
|
|
|
committer);
|
|
|
|
if (msglen)
|
2007-07-29 02:17:17 +02:00
|
|
|
len += copy_msg(logrec + len - 1, msg) - 1;
|
2007-01-08 16:58:23 +01:00
|
|
|
written = len <= maxlen ? write_in_full(logfd, logrec, len) : -1;
|
2006-05-17 11:55:40 +02:00
|
|
|
free(logrec);
|
2007-06-24 21:20:41 +02:00
|
|
|
if (close(logfd) != 0 || written != len)
|
2007-01-26 23:26:05 +01:00
|
|
|
return error("Unable to append to %s", log_file);
|
2006-05-17 11:55:40 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-16 00:50:17 +01:00
|
|
|
static int is_branch(const char *refname)
|
|
|
|
{
|
|
|
|
return !strcmp(refname, "HEAD") || !prefixcmp(refname, "refs/heads/");
|
|
|
|
}
|
|
|
|
|
2006-05-17 11:55:02 +02:00
|
|
|
int write_ref_sha1(struct ref_lock *lock,
|
|
|
|
const unsigned char *sha1, const char *logmsg)
|
|
|
|
{
|
|
|
|
static char term = '\n';
|
2008-01-16 00:50:17 +01:00
|
|
|
struct object *o;
|
2006-05-17 11:55:02 +02:00
|
|
|
|
|
|
|
if (!lock)
|
2005-06-06 22:31:29 +02:00
|
|
|
return -1;
|
2006-08-17 20:54:57 +02:00
|
|
|
if (!lock->force_write && !hashcmp(lock->old_sha1, sha1)) {
|
2006-05-17 11:55:02 +02:00
|
|
|
unlock_ref(lock);
|
|
|
|
return 0;
|
2005-06-06 22:31:29 +02:00
|
|
|
}
|
2008-01-16 00:50:17 +01:00
|
|
|
o = parse_object(sha1);
|
|
|
|
if (!o) {
|
2011-06-16 15:42:48 +02:00
|
|
|
error("Trying to write ref %s with nonexistent object %s",
|
2008-01-16 00:50:17 +01:00
|
|
|
lock->ref_name, sha1_to_hex(sha1));
|
|
|
|
unlock_ref(lock);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {
|
|
|
|
error("Trying to write non-commit object %s to branch %s",
|
|
|
|
sha1_to_hex(sha1), lock->ref_name);
|
|
|
|
unlock_ref(lock);
|
|
|
|
return -1;
|
|
|
|
}
|
2007-01-08 16:58:23 +01:00
|
|
|
if (write_in_full(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 ||
|
|
|
|
write_in_full(lock->lock_fd, &term, 1) != 1
|
2008-01-16 20:14:30 +01:00
|
|
|
|| close_ref(lock) < 0) {
|
2006-06-06 22:54:14 +02:00
|
|
|
error("Couldn't write %s", lock->lk->filename);
|
2006-05-17 11:55:02 +02:00
|
|
|
unlock_ref(lock);
|
|
|
|
return -1;
|
|
|
|
}
|
2011-10-17 04:38:10 +02:00
|
|
|
clear_loose_ref_cache(get_ref_cache(NULL));
|
2007-01-26 23:26:07 +01:00
|
|
|
if (log_ref_write(lock->ref_name, lock->old_sha1, sha1, logmsg) < 0 ||
|
|
|
|
(strcmp(lock->ref_name, lock->orig_ref_name) &&
|
|
|
|
log_ref_write(lock->orig_ref_name, lock->old_sha1, sha1, logmsg) < 0)) {
|
2006-05-17 11:55:40 +02:00
|
|
|
unlock_ref(lock);
|
|
|
|
return -1;
|
|
|
|
}
|
2007-03-21 22:11:44 +01:00
|
|
|
if (strcmp(lock->orig_ref_name, "HEAD") != 0) {
|
|
|
|
/*
|
|
|
|
* Special hack: If a branch is updated directly and HEAD
|
|
|
|
* points to it (may happen on the remote side of a push
|
|
|
|
* for example) then logically the HEAD reflog should be
|
|
|
|
* updated too.
|
|
|
|
* A generic solution implies reverse symref information,
|
|
|
|
* but finding all symrefs pointing to the given branch
|
|
|
|
* would be rather costly for this rare event (the direct
|
|
|
|
* update of a branch) to be worth it. So let's cheat and
|
|
|
|
* check with HEAD only which should cover 99% of all usage
|
|
|
|
* scenarios (even 100% of the default ones).
|
|
|
|
*/
|
|
|
|
unsigned char head_sha1[20];
|
|
|
|
int head_flag;
|
|
|
|
const char *head_ref;
|
2011-12-12 12:20:32 +01:00
|
|
|
head_ref = resolve_ref_unsafe("HEAD", head_sha1, 1, &head_flag);
|
2007-03-21 22:11:44 +01:00
|
|
|
if (head_ref && (head_flag & REF_ISSYMREF) &&
|
|
|
|
!strcmp(head_ref, lock->ref_name))
|
|
|
|
log_ref_write("HEAD", lock->old_sha1, sha1, logmsg);
|
|
|
|
}
|
2008-01-16 20:14:30 +01:00
|
|
|
if (commit_ref(lock)) {
|
Enable the packed refs file format
This actually "turns on" the packed ref file format, now that the
infrastructure to do so sanely exists (ie notably the change to make the
reference reading logic take refnames rather than pathnames to the loose
objects that no longer necessarily even exist).
In particular, when the ref lookup hits a refname that has no loose file
associated with it, it falls back on the packed-ref information. Also, the
ref-locking code, while still using a loose file for the locking itself
(and _creating_ a loose file for the new ref) no longer requires that the
old ref be in such an unpacked state.
Finally, this does a minimal hack to git-checkout.sh to rather than check
the ref-file directly, do a "git-rev-parse" on the "heads/$refname".
That's not really wonderful - we should rather really have a special
routine to verify the names as proper branch head names, but it is a
workable solution for now.
With this, I can literally do something like
git pack-refs
find .git/refs -type f -print0 | xargs -0 rm -f --
and the end result is a largely working repository (ie I've done two
commits - which creates _one_ unpacked ref file - done things like run
"gitk" and "git log" etc, and it all looks ok).
There are probably things missing, but I'm hoping that the missing things
are now of the "small and obvious" kind, and that somebody else might want
to start looking at this too. Hint hint ;)
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-14 19:14:47 +02:00
|
|
|
error("Couldn't set %s", lock->ref_name);
|
2006-05-17 11:55:02 +02:00
|
|
|
unlock_ref(lock);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
unlock_ref(lock);
|
|
|
|
return 0;
|
2005-06-06 22:31:29 +02:00
|
|
|
}
|
2006-05-17 11:56:09 +02:00
|
|
|
|
2007-01-26 23:26:10 +01:00
|
|
|
int create_symref(const char *ref_target, const char *refs_heads_master,
|
|
|
|
const char *logmsg)
|
2007-01-26 23:26:09 +01:00
|
|
|
{
|
|
|
|
const char *lockpath;
|
|
|
|
char ref[1000];
|
|
|
|
int fd, len, written;
|
2008-10-27 11:22:09 +01:00
|
|
|
char *git_HEAD = git_pathdup("%s", ref_target);
|
2007-01-26 23:26:10 +01:00
|
|
|
unsigned char old_sha1[20], new_sha1[20];
|
|
|
|
|
|
|
|
if (logmsg && read_ref(ref_target, old_sha1))
|
|
|
|
hashclr(old_sha1);
|
2007-01-26 23:26:09 +01:00
|
|
|
|
2007-02-08 08:41:43 +01:00
|
|
|
if (safe_create_leading_directories(git_HEAD) < 0)
|
|
|
|
return error("unable to create directory for %s", git_HEAD);
|
|
|
|
|
2007-01-26 23:26:09 +01:00
|
|
|
#ifndef NO_SYMLINK_HEAD
|
|
|
|
if (prefer_symlink_refs) {
|
|
|
|
unlink(git_HEAD);
|
|
|
|
if (!symlink(refs_heads_master, git_HEAD))
|
2007-01-26 23:26:10 +01:00
|
|
|
goto done;
|
2007-01-26 23:26:09 +01:00
|
|
|
fprintf(stderr, "no symlink - falling back to symbolic ref\n");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
len = snprintf(ref, sizeof(ref), "ref: %s\n", refs_heads_master);
|
|
|
|
if (sizeof(ref) <= len) {
|
|
|
|
error("refname too long: %s", refs_heads_master);
|
2007-01-27 02:49:00 +01:00
|
|
|
goto error_free_return;
|
2007-01-26 23:26:09 +01:00
|
|
|
}
|
|
|
|
lockpath = mkpath("%s.lock", git_HEAD);
|
|
|
|
fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666);
|
|
|
|
if (fd < 0) {
|
|
|
|
error("Unable to open %s for writing", lockpath);
|
2007-01-27 02:49:00 +01:00
|
|
|
goto error_free_return;
|
2007-01-26 23:26:09 +01:00
|
|
|
}
|
|
|
|
written = write_in_full(fd, ref, len);
|
2007-06-24 21:20:41 +02:00
|
|
|
if (close(fd) != 0 || written != len) {
|
2007-01-26 23:26:09 +01:00
|
|
|
error("Unable to write to %s", lockpath);
|
2007-01-27 02:49:00 +01:00
|
|
|
goto error_unlink_return;
|
2007-01-26 23:26:09 +01:00
|
|
|
}
|
|
|
|
if (rename(lockpath, git_HEAD) < 0) {
|
|
|
|
error("Unable to create %s", git_HEAD);
|
2007-01-27 02:49:00 +01:00
|
|
|
goto error_unlink_return;
|
2007-01-26 23:26:09 +01:00
|
|
|
}
|
|
|
|
if (adjust_shared_perm(git_HEAD)) {
|
|
|
|
error("Unable to fix permissions on %s", lockpath);
|
2007-01-27 02:49:00 +01:00
|
|
|
error_unlink_return:
|
2009-04-29 23:22:56 +02:00
|
|
|
unlink_or_warn(lockpath);
|
2007-01-27 02:49:00 +01:00
|
|
|
error_free_return:
|
|
|
|
free(git_HEAD);
|
|
|
|
return -1;
|
2007-01-26 23:26:09 +01:00
|
|
|
}
|
2007-01-26 23:26:10 +01:00
|
|
|
|
2007-03-03 19:28:46 +01:00
|
|
|
#ifndef NO_SYMLINK_HEAD
|
2007-01-26 23:26:10 +01:00
|
|
|
done:
|
2007-03-03 19:28:46 +01:00
|
|
|
#endif
|
2007-01-26 23:26:10 +01:00
|
|
|
if (logmsg && !read_ref(refs_heads_master, new_sha1))
|
|
|
|
log_ref_write(ref_target, old_sha1, new_sha1, logmsg);
|
|
|
|
|
2007-01-27 02:49:00 +01:00
|
|
|
free(git_HEAD);
|
2007-01-26 23:26:09 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-01-19 10:19:05 +01:00
|
|
|
static char *ref_msg(const char *line, const char *endp)
|
|
|
|
{
|
|
|
|
const char *ep;
|
|
|
|
line += 82;
|
2007-09-16 00:32:36 +02:00
|
|
|
ep = memchr(line, '\n', endp - line);
|
|
|
|
if (!ep)
|
|
|
|
ep = endp;
|
|
|
|
return xmemdupz(line, ep - line);
|
2007-01-19 10:19:05 +01:00
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
int read_ref_at(const char *refname, unsigned long at_time, int cnt,
|
|
|
|
unsigned char *sha1, char **msg,
|
|
|
|
unsigned long *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
|
2006-05-17 11:56:09 +02:00
|
|
|
{
|
2006-05-19 09:28:19 +02:00
|
|
|
const char *logfile, *logdata, *logend, *rec, *lastgt, *lastrec;
|
2006-05-17 11:56:09 +02:00
|
|
|
char *tz_c;
|
2006-12-19 07:07:45 +01:00
|
|
|
int logfd, tz, reccnt = 0;
|
2006-05-17 11:56:09 +02:00
|
|
|
struct stat st;
|
|
|
|
unsigned long date;
|
2006-05-19 09:28:19 +02:00
|
|
|
unsigned char logged_sha1[20];
|
2007-01-19 09:39:32 +01:00
|
|
|
void *log_mapped;
|
2007-03-07 02:44:37 +01:00
|
|
|
size_t mapsz;
|
2006-05-17 11:56:09 +02:00
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
logfile = git_path("logs/%s", refname);
|
2006-05-17 11:56:09 +02:00
|
|
|
logfd = open(logfile, O_RDONLY, 0);
|
|
|
|
if (logfd < 0)
|
2009-06-27 17:58:46 +02:00
|
|
|
die_errno("Unable to read log '%s'", logfile);
|
2006-05-17 11:56:09 +02:00
|
|
|
fstat(logfd, &st);
|
|
|
|
if (!st.st_size)
|
|
|
|
die("Log %s is empty.", logfile);
|
2007-03-07 02:44:37 +01:00
|
|
|
mapsz = xsize_t(st.st_size);
|
|
|
|
log_mapped = xmmap(NULL, mapsz, PROT_READ, MAP_PRIVATE, logfd, 0);
|
2007-01-19 09:39:32 +01:00
|
|
|
logdata = log_mapped;
|
2006-05-17 11:56:09 +02:00
|
|
|
close(logfd);
|
|
|
|
|
2006-05-19 09:28:19 +02:00
|
|
|
lastrec = NULL;
|
2006-05-17 11:56:09 +02:00
|
|
|
rec = logend = logdata + st.st_size;
|
|
|
|
while (logdata < rec) {
|
2006-12-19 07:07:45 +01:00
|
|
|
reccnt++;
|
2006-05-17 11:56:09 +02:00
|
|
|
if (logdata < rec && *(rec-1) == '\n')
|
|
|
|
rec--;
|
2006-05-19 09:28:19 +02:00
|
|
|
lastgt = NULL;
|
|
|
|
while (logdata < rec && *(rec-1) != '\n') {
|
2006-05-17 11:56:09 +02:00
|
|
|
rec--;
|
2006-05-19 09:28:19 +02:00
|
|
|
if (*rec == '>')
|
|
|
|
lastgt = rec;
|
|
|
|
}
|
|
|
|
if (!lastgt)
|
2006-05-17 11:56:09 +02:00
|
|
|
die("Log %s is corrupt.", logfile);
|
2006-05-19 09:28:19 +02:00
|
|
|
date = strtoul(lastgt + 1, &tz_c, 10);
|
2006-10-06 08:16:15 +02:00
|
|
|
if (date <= at_time || cnt == 0) {
|
show-branch --reflog: show the reflog message at the top.
This changes the output so the list at the top shows the reflog
message, along with their relative timestamps.
You can use --reflog=<n> to show <n> most recent log entries, or
use --reflog=<n>,<b> to show <n> entries going back from the
entry <b>. <b> can be either a number (so --reflog=4,20 shows 4
records starting from @{20}) or a timestamp (e.g. --reflog='4,1 day').
Here is a sample output (with --list option):
$ git show-branch --reflog=10 --list jc/show-reflog
[jc/show-reflog@{0}] (3 minutes ago) commit (amend): show-branch --ref
[jc/show-reflog@{1}] (5 minutes ago) reset HEAD^
[jc/show-reflog@{2}] (14 minutes ago) commit: show-branch --reflog: sho
[jc/show-reflog@{3}] (14 minutes ago) commit: show-branch --reflog: sho
[jc/show-reflog@{4}] (18 minutes ago) commit (amend): Extend read_ref_a
[jc/show-reflog@{5}] (18 minutes ago) commit (amend): Extend read_ref_a
[jc/show-reflog@{6}] (18 minutes ago) commit (amend): Extend read_ref_a
[jc/show-reflog@{7}] (18 minutes ago) am: read_ref_at(): allow retrievi
[jc/show-reflog@{8}] (18 minutes ago) reset --hard HEAD~4
[jc/show-reflog@{9}] (61 minutes ago) commit: show-branch --reflog: use
This shows what I did more cleanly:
$ git show-branch --reflog=10 jc/show-reflog
! [jc/show-reflog@{0}] (3 minutes ago) commit (amend): show-branch --ref
! [jc/show-reflog@{1}] (5 minutes ago) reset HEAD^
! [jc/show-reflog@{2}] (14 minutes ago) commit: show-branch --reflog:
! [jc/show-reflog@{3}] (14 minutes ago) commit: show-branch --reflog:
! [jc/show-reflog@{4}] (18 minutes ago) commit (amend): Extend read_
! [jc/show-reflog@{5}] (18 minutes ago) commit (amend): Extend read
! [jc/show-reflog@{6}] (18 minutes ago) commit (amend): Extend rea
! [jc/show-reflog@{7}] (18 minutes ago) am: read_ref_at(): allow
! [jc/show-reflog@{8}] (18 minutes ago) reset --hard HEAD~4
! [jc/show-reflog@{9}] (61 minutes ago) commit: show-branch --r
----------
+ [jc/show-reflog@{0}] show-branch --reflog: show the reflog
+ [jc/show-reflog@{2}] show-branch --reflog: show the reflog
+++ [jc/show-reflog@{1}] show-branch --reflog: show the reflog
+++++ [jc/show-reflog@{4}] Extend read_ref_at() to be usable fro
+ [jc/show-reflog@{5}] Extend read_ref_at() to be usable fro
+ [jc/show-reflog@{6}] Extend read_ref_at() to be usable fro
+ [jc/show-reflog@{7}] read_ref_at(): allow retrieving the r
+ [jc/show-reflog@{9}] show-branch --reflog: use updated rea
+ [jc/show-reflog@{9}^] read_ref_at(): allow reporting the c
+ [jc/show-reflog@{9}~2] show-branch --reflog: show the refl
+ [jc/show-reflog@{9}~3] read_ref_at(): allow retrieving the
++++++++++ [jc/show-reflog@{8}] dwim_ref(): Separate name-to-ref DWIM
At @{9}, I had a commit to complete 5 patch series, but I wanted
to consolidate two commits that enhances read_ref_at() into one
(they were @{9}^ and @{9}~3), and another two that touch show-branch
into one (@{9} and @{9}~2).
I first saved them with "format-patch -4", and then did a reset
at @{8}. At @{7}, I applied one of them with "am", and then
used "git-apply" on the other one, and amended the commit at
@{6} (so @{6} and @{7} has the same parent). I did not like the
log message, so I amended again at @{5}.
Then I cherry-picked @{9}~2 to create @{3} (the log message
shows that it needs to learn to set GIT_REFLOG_ACTION -- it uses
"git-commit" and the log entry is attributed for it). Another
cherry-pick built @{2} out of @{9}, but what I wanted to do was
to squash these two into one, so I did a "reset HEAD^" at @{1}
and then made the final commit by amending what was at the top.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-19 10:20:23 +01:00
|
|
|
tz = strtoul(tz_c, NULL, 10);
|
2007-01-19 10:19:05 +01:00
|
|
|
if (msg)
|
|
|
|
*msg = ref_msg(rec, logend);
|
|
|
|
if (cutoff_time)
|
|
|
|
*cutoff_time = date;
|
|
|
|
if (cutoff_tz)
|
|
|
|
*cutoff_tz = tz;
|
|
|
|
if (cutoff_cnt)
|
show-branch --reflog: show the reflog message at the top.
This changes the output so the list at the top shows the reflog
message, along with their relative timestamps.
You can use --reflog=<n> to show <n> most recent log entries, or
use --reflog=<n>,<b> to show <n> entries going back from the
entry <b>. <b> can be either a number (so --reflog=4,20 shows 4
records starting from @{20}) or a timestamp (e.g. --reflog='4,1 day').
Here is a sample output (with --list option):
$ git show-branch --reflog=10 --list jc/show-reflog
[jc/show-reflog@{0}] (3 minutes ago) commit (amend): show-branch --ref
[jc/show-reflog@{1}] (5 minutes ago) reset HEAD^
[jc/show-reflog@{2}] (14 minutes ago) commit: show-branch --reflog: sho
[jc/show-reflog@{3}] (14 minutes ago) commit: show-branch --reflog: sho
[jc/show-reflog@{4}] (18 minutes ago) commit (amend): Extend read_ref_a
[jc/show-reflog@{5}] (18 minutes ago) commit (amend): Extend read_ref_a
[jc/show-reflog@{6}] (18 minutes ago) commit (amend): Extend read_ref_a
[jc/show-reflog@{7}] (18 minutes ago) am: read_ref_at(): allow retrievi
[jc/show-reflog@{8}] (18 minutes ago) reset --hard HEAD~4
[jc/show-reflog@{9}] (61 minutes ago) commit: show-branch --reflog: use
This shows what I did more cleanly:
$ git show-branch --reflog=10 jc/show-reflog
! [jc/show-reflog@{0}] (3 minutes ago) commit (amend): show-branch --ref
! [jc/show-reflog@{1}] (5 minutes ago) reset HEAD^
! [jc/show-reflog@{2}] (14 minutes ago) commit: show-branch --reflog:
! [jc/show-reflog@{3}] (14 minutes ago) commit: show-branch --reflog:
! [jc/show-reflog@{4}] (18 minutes ago) commit (amend): Extend read_
! [jc/show-reflog@{5}] (18 minutes ago) commit (amend): Extend read
! [jc/show-reflog@{6}] (18 minutes ago) commit (amend): Extend rea
! [jc/show-reflog@{7}] (18 minutes ago) am: read_ref_at(): allow
! [jc/show-reflog@{8}] (18 minutes ago) reset --hard HEAD~4
! [jc/show-reflog@{9}] (61 minutes ago) commit: show-branch --r
----------
+ [jc/show-reflog@{0}] show-branch --reflog: show the reflog
+ [jc/show-reflog@{2}] show-branch --reflog: show the reflog
+++ [jc/show-reflog@{1}] show-branch --reflog: show the reflog
+++++ [jc/show-reflog@{4}] Extend read_ref_at() to be usable fro
+ [jc/show-reflog@{5}] Extend read_ref_at() to be usable fro
+ [jc/show-reflog@{6}] Extend read_ref_at() to be usable fro
+ [jc/show-reflog@{7}] read_ref_at(): allow retrieving the r
+ [jc/show-reflog@{9}] show-branch --reflog: use updated rea
+ [jc/show-reflog@{9}^] read_ref_at(): allow reporting the c
+ [jc/show-reflog@{9}~2] show-branch --reflog: show the refl
+ [jc/show-reflog@{9}~3] read_ref_at(): allow retrieving the
++++++++++ [jc/show-reflog@{8}] dwim_ref(): Separate name-to-ref DWIM
At @{9}, I had a commit to complete 5 patch series, but I wanted
to consolidate two commits that enhances read_ref_at() into one
(they were @{9}^ and @{9}~3), and another two that touch show-branch
into one (@{9} and @{9}~2).
I first saved them with "format-patch -4", and then did a reset
at @{8}. At @{7}, I applied one of them with "am", and then
used "git-apply" on the other one, and amended the commit at
@{6} (so @{6} and @{7} has the same parent). I did not like the
log message, so I amended again at @{5}.
Then I cherry-picked @{9}~2 to create @{3} (the log message
shows that it needs to learn to set GIT_REFLOG_ACTION -- it uses
"git-commit" and the log entry is attributed for it). Another
cherry-pick built @{2} out of @{9}, but what I wanted to do was
to squash these two into one, so I did a "reset HEAD^" at @{1}
and then made the final commit by amending what was at the top.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-19 10:20:23 +01:00
|
|
|
*cutoff_cnt = reccnt - 1;
|
2006-05-19 09:28:19 +02:00
|
|
|
if (lastrec) {
|
|
|
|
if (get_sha1_hex(lastrec, logged_sha1))
|
|
|
|
die("Log %s is corrupt.", logfile);
|
|
|
|
if (get_sha1_hex(rec + 41, sha1))
|
|
|
|
die("Log %s is corrupt.", logfile);
|
2006-08-17 20:54:57 +02:00
|
|
|
if (hashcmp(logged_sha1, sha1)) {
|
2009-03-24 02:09:17 +01:00
|
|
|
warning("Log %s has gap after %s.",
|
2007-07-14 08:14:52 +02:00
|
|
|
logfile, show_date(date, tz, DATE_RFC2822));
|
2006-05-19 09:28:19 +02:00
|
|
|
}
|
2006-06-06 23:04:17 +02:00
|
|
|
}
|
|
|
|
else if (date == at_time) {
|
2006-05-19 09:28:19 +02:00
|
|
|
if (get_sha1_hex(rec + 41, sha1))
|
|
|
|
die("Log %s is corrupt.", logfile);
|
2006-06-06 23:04:17 +02:00
|
|
|
}
|
|
|
|
else {
|
2006-05-19 09:28:19 +02:00
|
|
|
if (get_sha1_hex(rec + 41, logged_sha1))
|
|
|
|
die("Log %s is corrupt.", logfile);
|
2006-08-17 20:54:57 +02:00
|
|
|
if (hashcmp(logged_sha1, sha1)) {
|
2009-03-24 02:09:17 +01:00
|
|
|
warning("Log %s unexpectedly ended on %s.",
|
2007-07-14 08:14:52 +02:00
|
|
|
logfile, show_date(date, tz, DATE_RFC2822));
|
2006-05-19 09:28:19 +02:00
|
|
|
}
|
|
|
|
}
|
2007-03-07 02:44:37 +01:00
|
|
|
munmap(log_mapped, mapsz);
|
2006-05-17 11:56:09 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2006-05-19 09:28:19 +02:00
|
|
|
lastrec = rec;
|
2006-10-06 08:16:15 +02:00
|
|
|
if (cnt > 0)
|
|
|
|
cnt--;
|
2006-05-17 11:56:09 +02:00
|
|
|
}
|
|
|
|
|
2006-05-19 09:28:19 +02:00
|
|
|
rec = logdata;
|
|
|
|
while (rec < logend && *rec != '>' && *rec != '\n')
|
|
|
|
rec++;
|
|
|
|
if (rec == logend || *rec == '\n')
|
2006-05-17 11:56:09 +02:00
|
|
|
die("Log %s is corrupt.", logfile);
|
2006-05-19 09:28:19 +02:00
|
|
|
date = strtoul(rec + 1, &tz_c, 10);
|
2006-05-17 11:56:09 +02:00
|
|
|
tz = strtoul(tz_c, NULL, 10);
|
|
|
|
if (get_sha1_hex(logdata, sha1))
|
|
|
|
die("Log %s is corrupt.", logfile);
|
2008-07-08 06:38:54 +02:00
|
|
|
if (is_null_sha1(sha1)) {
|
|
|
|
if (get_sha1_hex(logdata + 41, sha1))
|
|
|
|
die("Log %s is corrupt.", logfile);
|
|
|
|
}
|
2007-01-19 10:19:05 +01:00
|
|
|
if (msg)
|
|
|
|
*msg = ref_msg(logdata, logend);
|
2007-03-07 02:44:37 +01:00
|
|
|
munmap(log_mapped, mapsz);
|
2007-01-19 10:19:05 +01:00
|
|
|
|
|
|
|
if (cutoff_time)
|
|
|
|
*cutoff_time = date;
|
|
|
|
if (cutoff_tz)
|
|
|
|
*cutoff_tz = tz;
|
|
|
|
if (cutoff_cnt)
|
|
|
|
*cutoff_cnt = reccnt;
|
|
|
|
return 1;
|
2006-05-17 11:56:09 +02:00
|
|
|
}
|
2006-12-18 10:18:16 +01:00
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
int for_each_recent_reflog_ent(const char *refname, each_reflog_ent_fn fn, long ofs, void *cb_data)
|
2006-12-18 10:18:16 +01:00
|
|
|
{
|
|
|
|
const char *logfile;
|
|
|
|
FILE *logfp;
|
2010-03-13 18:37:50 +01:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2007-01-19 08:25:54 +01:00
|
|
|
int ret = 0;
|
2006-12-18 10:18:16 +01:00
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
logfile = git_path("logs/%s", refname);
|
2006-12-18 10:18:16 +01:00
|
|
|
logfp = fopen(logfile, "r");
|
|
|
|
if (!logfp)
|
2007-01-08 01:59:54 +01:00
|
|
|
return -1;
|
2009-01-20 07:18:29 +01:00
|
|
|
|
|
|
|
if (ofs) {
|
|
|
|
struct stat statbuf;
|
|
|
|
if (fstat(fileno(logfp), &statbuf) ||
|
|
|
|
statbuf.st_size < ofs ||
|
|
|
|
fseek(logfp, -ofs, SEEK_END) ||
|
2010-03-13 18:37:50 +01:00
|
|
|
strbuf_getwholeline(&sb, logfp, '\n')) {
|
2009-07-16 23:25:18 +02:00
|
|
|
fclose(logfp);
|
2010-03-13 18:37:50 +01:00
|
|
|
strbuf_release(&sb);
|
2009-01-20 07:18:29 +01:00
|
|
|
return -1;
|
2009-07-16 23:25:18 +02:00
|
|
|
}
|
2009-01-20 07:18:29 +01:00
|
|
|
}
|
|
|
|
|
2010-03-13 18:37:50 +01:00
|
|
|
while (!strbuf_getwholeline(&sb, logfp, '\n')) {
|
2006-12-18 10:18:16 +01:00
|
|
|
unsigned char osha1[20], nsha1[20];
|
2007-01-08 01:59:54 +01:00
|
|
|
char *email_end, *message;
|
|
|
|
unsigned long timestamp;
|
2010-03-13 18:37:50 +01:00
|
|
|
int tz;
|
2006-12-18 10:18:16 +01:00
|
|
|
|
|
|
|
/* old SP new SP name <email> SP time TAB msg LF */
|
2010-03-13 18:37:50 +01:00
|
|
|
if (sb.len < 83 || sb.buf[sb.len - 1] != '\n' ||
|
|
|
|
get_sha1_hex(sb.buf, osha1) || sb.buf[40] != ' ' ||
|
|
|
|
get_sha1_hex(sb.buf + 41, nsha1) || sb.buf[81] != ' ' ||
|
|
|
|
!(email_end = strchr(sb.buf + 82, '>')) ||
|
2007-01-08 01:59:54 +01:00
|
|
|
email_end[1] != ' ' ||
|
|
|
|
!(timestamp = strtoul(email_end + 2, &message, 10)) ||
|
|
|
|
!message || message[0] != ' ' ||
|
|
|
|
(message[1] != '+' && message[1] != '-') ||
|
|
|
|
!isdigit(message[2]) || !isdigit(message[3]) ||
|
2007-02-09 00:59:47 +01:00
|
|
|
!isdigit(message[4]) || !isdigit(message[5]))
|
2006-12-18 10:18:16 +01:00
|
|
|
continue; /* corrupt? */
|
2007-01-08 01:59:54 +01:00
|
|
|
email_end[1] = '\0';
|
|
|
|
tz = strtol(message + 1, NULL, 10);
|
2007-02-09 00:59:47 +01:00
|
|
|
if (message[6] != '\t')
|
|
|
|
message += 6;
|
|
|
|
else
|
|
|
|
message += 7;
|
2010-03-13 18:37:50 +01:00
|
|
|
ret = fn(osha1, nsha1, sb.buf + 82, timestamp, tz, message,
|
|
|
|
cb_data);
|
2007-01-08 01:59:54 +01:00
|
|
|
if (ret)
|
2007-01-19 08:25:54 +01:00
|
|
|
break;
|
2006-12-18 10:18:16 +01:00
|
|
|
}
|
|
|
|
fclose(logfp);
|
2010-03-13 18:37:50 +01:00
|
|
|
strbuf_release(&sb);
|
2007-01-19 08:25:54 +01:00
|
|
|
return ret;
|
2006-12-18 10:18:16 +01:00
|
|
|
}
|
2006-12-19 07:07:45 +01:00
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, void *cb_data)
|
2009-01-20 07:18:29 +01:00
|
|
|
{
|
2011-12-12 06:38:09 +01:00
|
|
|
return for_each_recent_reflog_ent(refname, fn, 0, cb_data);
|
2009-01-20 07:18:29 +01:00
|
|
|
}
|
|
|
|
|
2012-04-25 00:45:14 +02:00
|
|
|
/*
|
|
|
|
* Call fn for each reflog in the namespace indicated by name. name
|
|
|
|
* must be empty or end with '/'. Name will be used as a scratch
|
|
|
|
* space, but its contents will be restored before return.
|
|
|
|
*/
|
|
|
|
static int do_for_each_reflog(struct strbuf *name, each_ref_fn fn, void *cb_data)
|
2007-02-03 19:25:43 +01:00
|
|
|
{
|
2012-04-25 00:45:14 +02:00
|
|
|
DIR *d = opendir(git_path("logs/%s", name->buf));
|
2007-02-07 18:18:57 +01:00
|
|
|
int retval = 0;
|
2012-04-25 00:45:13 +02:00
|
|
|
struct dirent *de;
|
2012-04-25 00:45:14 +02:00
|
|
|
int oldlen = name->len;
|
2007-02-03 19:25:43 +01:00
|
|
|
|
2012-04-25 00:45:13 +02:00
|
|
|
if (!d)
|
2012-04-25 00:45:14 +02:00
|
|
|
return name->len ? errno : 0;
|
2007-02-03 19:25:43 +01:00
|
|
|
|
2012-04-25 00:45:13 +02:00
|
|
|
while ((de = readdir(d)) != NULL) {
|
|
|
|
struct stat st;
|
2007-02-03 19:25:43 +01:00
|
|
|
|
2012-04-25 00:45:13 +02:00
|
|
|
if (de->d_name[0] == '.')
|
|
|
|
continue;
|
|
|
|
if (has_extension(de->d_name, ".lock"))
|
|
|
|
continue;
|
2012-04-25 00:45:14 +02:00
|
|
|
strbuf_addstr(name, de->d_name);
|
|
|
|
if (stat(git_path("logs/%s", name->buf), &st) < 0) {
|
|
|
|
; /* silently ignore */
|
2012-04-25 00:45:13 +02:00
|
|
|
} else {
|
2007-02-03 19:25:43 +01:00
|
|
|
if (S_ISDIR(st.st_mode)) {
|
2012-04-25 00:45:14 +02:00
|
|
|
strbuf_addch(name, '/');
|
|
|
|
retval = do_for_each_reflog(name, fn, cb_data);
|
2007-02-03 19:25:43 +01:00
|
|
|
} else {
|
|
|
|
unsigned char sha1[20];
|
2012-04-25 00:45:14 +02:00
|
|
|
if (read_ref_full(name->buf, sha1, 0, NULL))
|
|
|
|
retval = error("bad ref for %s", name->buf);
|
2007-02-03 19:25:43 +01:00
|
|
|
else
|
2012-04-25 00:45:14 +02:00
|
|
|
retval = fn(name->buf, sha1, 0, cb_data);
|
2007-02-03 19:25:43 +01:00
|
|
|
}
|
|
|
|
if (retval)
|
|
|
|
break;
|
|
|
|
}
|
2012-04-25 00:45:14 +02:00
|
|
|
strbuf_setlen(name, oldlen);
|
2007-02-03 19:25:43 +01:00
|
|
|
}
|
2012-04-25 00:45:13 +02:00
|
|
|
closedir(d);
|
2007-02-03 19:25:43 +01:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int for_each_reflog(each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
2012-04-25 00:45:14 +02:00
|
|
|
int retval;
|
|
|
|
struct strbuf name;
|
|
|
|
strbuf_init(&name, PATH_MAX);
|
|
|
|
retval = do_for_each_reflog(&name, fn, cb_data);
|
|
|
|
strbuf_release(&name);
|
|
|
|
return retval;
|
2007-02-03 19:25:43 +01:00
|
|
|
}
|
2007-09-05 03:38:24 +02:00
|
|
|
|
|
|
|
int update_ref(const char *action, const char *refname,
|
|
|
|
const unsigned char *sha1, const unsigned char *oldval,
|
|
|
|
int flags, enum action_on_err onerr)
|
|
|
|
{
|
|
|
|
static struct ref_lock *lock;
|
|
|
|
lock = lock_any_ref_for_update(refname, oldval, flags);
|
|
|
|
if (!lock) {
|
|
|
|
const char *str = "Cannot lock the ref '%s'.";
|
|
|
|
switch (onerr) {
|
|
|
|
case MSG_ON_ERR: error(str, refname); break;
|
|
|
|
case DIE_ON_ERR: die(str, refname); break;
|
|
|
|
case QUIET_ON_ERR: break;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (write_ref_sha1(lock, sha1, action) < 0) {
|
|
|
|
const char *str = "Cannot update the ref '%s'.";
|
|
|
|
switch (onerr) {
|
|
|
|
case MSG_ON_ERR: error(str, refname); break;
|
|
|
|
case DIE_ON_ERR: die(str, refname); break;
|
|
|
|
case QUIET_ON_ERR: break;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2007-11-18 08:13:10 +01:00
|
|
|
|
2009-02-25 09:32:10 +01:00
|
|
|
struct ref *find_ref_by_name(const struct ref *list, const char *name)
|
2007-11-18 08:13:10 +01:00
|
|
|
{
|
|
|
|
for ( ; list; list = list->next)
|
|
|
|
if (!strcmp(list->name, name))
|
2009-02-25 09:32:10 +01:00
|
|
|
return (struct ref *)list;
|
2007-11-18 08:13:10 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
2009-04-07 09:14:20 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* generate a format suitable for scanf from a ref_rev_parse_rules
|
|
|
|
* rule, that is replace the "%.*s" spec with a "%s" spec
|
|
|
|
*/
|
|
|
|
static void gen_scanf_fmt(char *scanf_fmt, const char *rule)
|
|
|
|
{
|
|
|
|
char *spec;
|
|
|
|
|
|
|
|
spec = strstr(rule, "%.*s");
|
|
|
|
if (!spec || strstr(spec + 4, "%.*s"))
|
|
|
|
die("invalid rule in ref_rev_parse_rules: %s", rule);
|
|
|
|
|
|
|
|
/* copy all until spec */
|
|
|
|
strncpy(scanf_fmt, rule, spec - rule);
|
|
|
|
scanf_fmt[spec - rule] = '\0';
|
|
|
|
/* copy new spec */
|
|
|
|
strcat(scanf_fmt, "%s");
|
|
|
|
/* copy remaining rule */
|
|
|
|
strcat(scanf_fmt, spec + 4);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
char *shorten_unambiguous_ref(const char *refname, int strict)
|
2009-04-07 09:14:20 +02:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
static char **scanf_fmts;
|
|
|
|
static int nr_rules;
|
|
|
|
char *short_name;
|
|
|
|
|
|
|
|
/* pre generate scanf formats from ref_rev_parse_rules[] */
|
|
|
|
if (!nr_rules) {
|
|
|
|
size_t total_len = 0;
|
|
|
|
|
|
|
|
/* the rule list is NULL terminated, count them first */
|
|
|
|
for (; ref_rev_parse_rules[nr_rules]; nr_rules++)
|
|
|
|
/* no +1 because strlen("%s") < strlen("%.*s") */
|
|
|
|
total_len += strlen(ref_rev_parse_rules[nr_rules]);
|
|
|
|
|
|
|
|
scanf_fmts = xmalloc(nr_rules * sizeof(char *) + total_len);
|
|
|
|
|
|
|
|
total_len = 0;
|
|
|
|
for (i = 0; i < nr_rules; i++) {
|
|
|
|
scanf_fmts[i] = (char *)&scanf_fmts[nr_rules]
|
|
|
|
+ total_len;
|
|
|
|
gen_scanf_fmt(scanf_fmts[i], ref_rev_parse_rules[i]);
|
|
|
|
total_len += strlen(ref_rev_parse_rules[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* bail out if there are no rules */
|
|
|
|
if (!nr_rules)
|
2011-12-12 06:38:09 +01:00
|
|
|
return xstrdup(refname);
|
2009-04-07 09:14:20 +02:00
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
/* buffer for scanf result, at most refname must fit */
|
|
|
|
short_name = xstrdup(refname);
|
2009-04-07 09:14:20 +02:00
|
|
|
|
|
|
|
/* skip first rule, it will always match */
|
|
|
|
for (i = nr_rules - 1; i > 0 ; --i) {
|
|
|
|
int j;
|
2009-04-13 12:25:46 +02:00
|
|
|
int rules_to_fail = i;
|
2009-04-07 09:14:20 +02:00
|
|
|
int short_name_len;
|
|
|
|
|
2011-12-12 06:38:09 +01:00
|
|
|
if (1 != sscanf(refname, scanf_fmts[i], short_name))
|
2009-04-07 09:14:20 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
short_name_len = strlen(short_name);
|
|
|
|
|
2009-04-13 12:25:46 +02:00
|
|
|
/*
|
|
|
|
* in strict mode, all (except the matched one) rules
|
|
|
|
* must fail to resolve to a valid non-ambiguous ref
|
|
|
|
*/
|
|
|
|
if (strict)
|
|
|
|
rules_to_fail = nr_rules;
|
|
|
|
|
2009-04-07 09:14:20 +02:00
|
|
|
/*
|
|
|
|
* check if the short name resolves to a valid ref,
|
|
|
|
* but use only rules prior to the matched one
|
|
|
|
*/
|
2009-04-13 12:25:46 +02:00
|
|
|
for (j = 0; j < rules_to_fail; j++) {
|
2009-04-07 09:14:20 +02:00
|
|
|
const char *rule = ref_rev_parse_rules[j];
|
|
|
|
char refname[PATH_MAX];
|
|
|
|
|
2009-04-13 12:25:46 +02:00
|
|
|
/* skip matched rule */
|
|
|
|
if (i == j)
|
|
|
|
continue;
|
|
|
|
|
2009-04-07 09:14:20 +02:00
|
|
|
/*
|
|
|
|
* the short name is ambiguous, if it resolves
|
|
|
|
* (with this previous rule) to a valid ref
|
|
|
|
* read_ref() returns 0 on success
|
|
|
|
*/
|
|
|
|
mksnpath(refname, sizeof(refname),
|
|
|
|
rule, short_name_len, short_name);
|
2011-11-13 11:22:14 +01:00
|
|
|
if (ref_exists(refname))
|
2009-04-07 09:14:20 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* short name is non-ambiguous if all previous rules
|
|
|
|
* haven't resolved to a valid ref
|
|
|
|
*/
|
2009-04-13 12:25:46 +02:00
|
|
|
if (j == rules_to_fail)
|
2009-04-07 09:14:20 +02:00
|
|
|
return short_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(short_name);
|
2011-12-12 06:38:09 +01:00
|
|
|
return xstrdup(refname);
|
2009-04-07 09:14:20 +02:00
|
|
|
}
|