kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity
Browse Source

Merge branch 'jp/get-ref-dir-unsorted' 

* jp/get-ref-dir-unsorted:
  refs.c: free duplicate entries in the ref array instead of leaking them
  refs.c: abort ref search if ref array is empty
  refs.c: ensure struct whose member may be passed to realloc is initialized
  refs: Use binary search to lookup refs faster
  Don't sort ref_list too early

Conflicts:
	refs.c
maint
Junio C Hamano 13 years ago
parent
9bd500048d 17d68a54de
commit
2c5c66be6e
2 changed files with 154 additions and 201 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 353
      refs.c
  2. 2
      refs.h

353
refs.c
Unescape View File

@ -8,14 +8,18 @@ @@ -8,14 +8,18 @@
#define REF_KNOWS_PEELED 04
#define REF_BROKEN 010

struct ref_list {
struct ref_list *next;
struct ref_entry {
unsigned char flag; /* ISSYMREF? ISPACKED? */
unsigned char sha1[20];
unsigned char peeled[20];
char name[FLEX_ARRAY];
};

struct ref_array {
int nr, alloc;
struct ref_entry **refs;
};

static const char *parse_ref_line(char *line, unsigned char *sha1)
{
/*
@ -44,110 +48,86 @@ static const char *parse_ref_line(char *line, unsigned char *sha1) @@ -44,110 +48,86 @@ static const char *parse_ref_line(char *line, unsigned char *sha1)
return line;
}

static struct ref_list *add_ref(const char *name, const unsigned char *sha1,
int flag, struct ref_list *list,
struct ref_list **new_entry)
static void add_ref(const char *name, const unsigned char *sha1,
int flag, struct ref_array *refs,
struct ref_entry **new_entry)
{
int len;
struct ref_list *entry;
struct ref_entry *entry;

/* Allocate it and add it in.. */
len = strlen(name) + 1;
entry = xmalloc(sizeof(struct ref_list) + len);
entry = xmalloc(sizeof(struct ref_entry) + len);
hashcpy(entry->sha1, sha1);
hashclr(entry->peeled);
if (check_refname_format(name, REFNAME_ALLOW_ONELEVEL|REFNAME_DOT_COMPONENT))
die("Reference has invalid format: '%s'", name);
memcpy(entry->name, name, len);
entry->flag = flag;
entry->next = list;
if (new_entry)
*new_entry = entry;
return entry;
ALLOC_GROW(refs->refs, refs->nr + 1, refs->alloc);
refs->refs[refs->nr++] = entry;
}

/* merge sort the ref list */
static struct ref_list *sort_ref_list(struct ref_list *list)
static int ref_entry_cmp(const void *a, const void *b)
{
int psize, qsize, last_merge_count, cmp;
struct ref_list *p, *q, *l, *e;
struct ref_list *new_list = list;
int k = 1;
int merge_count = 0;
struct ref_entry *one = *(struct ref_entry **)a;
struct ref_entry *two = *(struct ref_entry **)b;
return strcmp(one->name, two->name);
}

if (!list)
return list;
static void sort_ref_array(struct ref_array *array)
{
int i = 0, j = 1;

do {
last_merge_count = merge_count;
merge_count = 0;
/* Nothing to sort unless there are at least two entries */
if (array->nr < 2)
return;

psize = 0;
qsort(array->refs, array->nr, sizeof(*array->refs), ref_entry_cmp);

p = new_list;
q = new_list;
new_list = NULL;
l = NULL;
/* Remove any duplicates from the ref_array */
for (; j < array->nr; j++) {
struct ref_entry *a = array->refs[i];
struct ref_entry *b = array->refs[j];
if (!strcmp(a->name, b->name)) {
if (hashcmp(a->sha1, b->sha1))
die("Duplicated ref, and SHA1s don't match: %s",
a->name);
warning("Duplicated ref: %s", a->name);
free(b);
continue;
}
i++;
array->refs[i] = array->refs[j];
}
array->nr = i + 1;
}

while (p) {
merge_count++;
static struct ref_entry *search_ref_array(struct ref_array *array, const char *name)
{
struct ref_entry *e, **r;
int len;

while (psize < k && q->next) {
q = q->next;
psize++;
}
qsize = k;

while ((psize > 0) || (qsize > 0 && q)) {
if (qsize == 0 || !q) {
e = p;
p = p->next;
psize--;
} else if (psize == 0) {
e = q;
q = q->next;
qsize--;
} else {
cmp = strcmp(q->name, p->name);
if (cmp < 0) {
e = q;
q = q->next;
qsize--;
} else if (cmp > 0) {
e = p;
p = p->next;
psize--;
} else {
if (hashcmp(q->sha1, p->sha1))
die("Duplicated ref, and SHA1s don't match: %s",
q->name);
warning("Duplicated ref: %s", q->name);
e = q;
q = q->next;
qsize--;
free(e);
e = p;
p = p->next;
psize--;
}
}
if (name == NULL)
return NULL;

e->next = NULL;
if (!array->nr)
return NULL;

if (l)
l->next = e;
if (!new_list)
new_list = e;
l = e;
}
len = strlen(name) + 1;
e = xmalloc(sizeof(struct ref_entry) + len);
memcpy(e->name, name, len);

r = bsearch(&e, array->refs, array->nr, sizeof(*array->refs), ref_entry_cmp);

p = q;
};
free(e);

k = k * 2;
} while ((last_merge_count != merge_count) || (last_merge_count != 1));
if (r == NULL)
return NULL;

return new_list;
return *r;
}

/*
@ -158,32 +138,32 @@ static struct cached_refs { @@ -158,32 +138,32 @@ static struct cached_refs {
struct cached_refs *next;
char did_loose;
char did_packed;
struct ref_list *loose;
struct ref_list *packed;
struct ref_array loose;
struct ref_array packed;
/* The submodule name, or "" for the main repo. */
char name[FLEX_ARRAY];
} *cached_refs;

static struct ref_list *current_ref;
static struct ref_entry *current_ref;

static struct ref_list *extra_refs;
static struct ref_array extra_refs;

static void free_ref_list(struct ref_list *list)
static void free_ref_array(struct ref_array *array)
{
struct ref_list *next;
for ( ; list; list = next) {
next = list->next;
free(list);
}
int i;
for (i = 0; i < array->nr; i++)
free(array->refs[i]);
free(array->refs);
array->nr = array->alloc = 0;
array->refs = NULL;
}

static void clear_cached_refs(struct cached_refs *ca)
{
if (ca->did_loose && ca->loose)
free_ref_list(ca->loose);
if (ca->did_packed && ca->packed)
free_ref_list(ca->packed);
ca->loose = ca->packed = NULL;
if (ca->did_loose)
free_ref_array(&ca->loose);
if (ca->did_packed)
free_ref_array(&ca->packed);
ca->did_loose = ca->did_packed = 0;
}

@ -194,10 +174,7 @@ static struct cached_refs *create_cached_refs(const char *submodule) @@ -194,10 +174,7 @@ static struct cached_refs *create_cached_refs(const char *submodule)
if (!submodule)
submodule = "";
len = strlen(submodule) + 1;
refs = xmalloc(sizeof(struct cached_refs) + len);
refs->next = NULL;
refs->did_loose = refs->did_packed = 0;
refs->loose = refs->packed = NULL;
refs = xcalloc(1, sizeof(struct cached_refs) + len);
memcpy(refs->name, submodule, len);
return refs;
}
@ -234,10 +211,9 @@ static void invalidate_cached_refs(void) @@ -234,10 +211,9 @@ static void invalidate_cached_refs(void)
}
}

static struct ref_list *read_packed_refs(FILE *f)
static void read_packed_refs(FILE *f, struct ref_array *array)
{
struct ref_list *list = NULL;
struct ref_list *last = NULL;
struct ref_entry *last = NULL;
char refline[PATH_MAX];
int flag = REF_ISPACKED;

@ -256,7 +232,7 @@ static struct ref_list *read_packed_refs(FILE *f) @@ -256,7 +232,7 @@ static struct ref_list *read_packed_refs(FILE *f)

name = parse_ref_line(refline, sha1);
if (name) {
list = add_ref(name, sha1, flag, list, &last);
add_ref(name, sha1, flag, array, &last);
continue;
}
if (last &&
@ -266,21 +242,20 @@ static struct ref_list *read_packed_refs(FILE *f) @@ -266,21 +242,20 @@ static struct ref_list *read_packed_refs(FILE *f)
!get_sha1_hex(refline + 1, sha1))
hashcpy(last->peeled, sha1);
}
return sort_ref_list(list);
sort_ref_array(array);
}

void add_extra_ref(const char *name, const unsigned char *sha1, int flag)
{
extra_refs = add_ref(name, sha1, flag, extra_refs, NULL);
add_ref(name, sha1, flag, &extra_refs, NULL);
}

void clear_extra_refs(void)
{
free_ref_list(extra_refs);
extra_refs = NULL;
free_ref_array(&extra_refs);
}

static struct ref_list *get_packed_refs(const char *submodule)
static struct ref_array *get_packed_refs(const char *submodule)
{
struct cached_refs *refs = get_cached_refs(submodule);

@ -293,18 +268,17 @@ static struct ref_list *get_packed_refs(const char *submodule) @@ -293,18 +268,17 @@ static struct ref_list *get_packed_refs(const char *submodule)
else
packed_refs_file = git_path("packed-refs");
f = fopen(packed_refs_file, "r");
refs->packed = NULL;
if (f) {
refs->packed = read_packed_refs(f);
read_packed_refs(f, &refs->packed);
fclose(f);
}
refs->did_packed = 1;
}
return refs->packed;
return &refs->packed;
}

static struct ref_list *get_ref_dir(const char *submodule, const char *base,
struct ref_list *list)
static void get_ref_dir(const char *submodule, const char *base,
struct ref_array *array)
{
DIR *dir;
const char *path;
@ -347,7 +321,7 @@ static struct ref_list *get_ref_dir(const char *submodule, const char *base, @@ -347,7 +321,7 @@ static struct ref_list *get_ref_dir(const char *submodule, const char *base,
if (stat(refdir, &st) < 0)
continue;
if (S_ISDIR(st.st_mode)) {
list = get_ref_dir(submodule, ref, list);
get_ref_dir(submodule, ref, array);
continue;
}
if (submodule) {
@ -362,12 +336,11 @@ static struct ref_list *get_ref_dir(const char *submodule, const char *base, @@ -362,12 +336,11 @@ static struct ref_list *get_ref_dir(const char *submodule, const char *base,
hashclr(sha1);
flag |= REF_BROKEN;
}
list = add_ref(ref, sha1, flag, list, NULL);
add_ref(ref, sha1, flag, array, NULL);
}
free(ref);
closedir(dir);
}
return sort_ref_list(list);
}

struct warn_if_dangling_data {
@ -404,15 +377,16 @@ void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname) @@ -404,15 +377,16 @@ void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
for_each_rawref(warn_if_dangling_symref, &data);
}

static struct ref_list *get_loose_refs(const char *submodule)
static struct ref_array *get_loose_refs(const char *submodule)
{
struct cached_refs *refs = get_cached_refs(submodule);

if (!refs->did_loose) {
refs->loose = get_ref_dir(submodule, "refs", NULL);
get_ref_dir(submodule, "refs", &refs->loose);
sort_ref_array(&refs->loose);
refs->did_loose = 1;
}
return refs->loose;
return &refs->loose;
}

/* We allow "recursive" symbolic refs. Only within reason, though */
@ -421,28 +395,15 @@ static struct ref_list *get_loose_refs(const char *submodule) @@ -421,28 +395,15 @@ static struct ref_list *get_loose_refs(const char *submodule)

static int resolve_gitlink_packed_ref(char *name, int pathlen, const char *refname, unsigned char *result)
{
FILE *f;
struct ref_list *packed_refs;
struct ref_list *ref;
int retval;
int retval = -1;
struct ref_entry *ref;
struct ref_array *array = get_packed_refs(name);

strcpy(name + pathlen, "packed-refs");
f = fopen(name, "r");
if (!f)
return -1;
packed_refs = read_packed_refs(f);
fclose(f);
ref = packed_refs;
retval = -1;
while (ref) {
if (!strcmp(ref->name, refname)) {
retval = 0;
memcpy(result, ref->sha1, 20);
break;
}
ref = ref->next;
ref = search_ref_array(array, refname);
if (ref != NULL) {
memcpy(result, ref->sha1, 20);
retval = 0;
}
free_ref_list(packed_refs);
return retval;
}

@ -515,13 +476,11 @@ int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *re @@ -515,13 +476,11 @@ int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *re
*/
static int get_packed_ref(const char *ref, unsigned char *sha1)
{
struct ref_list *list = get_packed_refs(NULL);
while (list) {
if (!strcmp(ref, list->name)) {
hashcpy(sha1, list->sha1);
return 0;
}
list = list->next;
struct ref_array *packed = get_packed_refs(NULL);
struct ref_entry *entry = search_ref_array(packed, ref);
if (entry) {
hashcpy(sha1, entry->sha1);
return 0;
}
return -1;
}
@ -649,7 +608,7 @@ int read_ref(const char *ref, unsigned char *sha1) @@ -649,7 +608,7 @@ int read_ref(const char *ref, unsigned char *sha1)

#define DO_FOR_EACH_INCLUDE_BROKEN 01
static int do_one_ref(const char *base, each_ref_fn fn, int trim,
int flags, void *cb_data, struct ref_list *entry)
int flags, void *cb_data, struct ref_entry *entry)
{
if (prefixcmp(entry->name, base))
return 0;
@ -695,18 +654,12 @@ int peel_ref(const char *ref, unsigned char *sha1) @@ -695,18 +654,12 @@ int peel_ref(const char *ref, unsigned char *sha1)
return -1;

if ((flag & REF_ISPACKED)) {
struct ref_list *list = get_packed_refs(NULL);
struct ref_array *array = get_packed_refs(NULL);
struct ref_entry *r = search_ref_array(array, ref);

while (list) {
if (!strcmp(list->name, ref)) {
if (list->flag & REF_KNOWS_PEELED) {
hashcpy(sha1, list->peeled);
return 0;
}
/* older pack-refs did not leave peeled ones */
break;
}
list = list->next;
if (r != NULL && r->flag & REF_KNOWS_PEELED) {
hashcpy(sha1, r->peeled);
return 0;
}
}

@ -725,36 +678,39 @@ fallback: @@ -725,36 +678,39 @@ fallback:
static int do_for_each_ref(const char *submodule, const char *base, each_ref_fn fn,
int trim, int flags, void *cb_data)
{
int retval = 0;
struct ref_list *packed = get_packed_refs(submodule);
struct ref_list *loose = get_loose_refs(submodule);
int retval = 0, i, p = 0, l = 0;
struct ref_array *packed = get_packed_refs(submodule);
struct ref_array *loose = get_loose_refs(submodule);

struct ref_list *extra;
struct ref_array *extra = &extra_refs;

for (extra = extra_refs; extra; extra = extra->next)
retval = do_one_ref(base, fn, trim, flags, cb_data, extra);
for (i = 0; i < extra->nr; i++)
retval = do_one_ref(base, fn, trim, flags, cb_data, extra->refs[i]);

while (packed && loose) {
struct ref_list *entry;
int cmp = strcmp(packed->name, loose->name);
while (p < packed->nr && l < loose->nr) {
struct ref_entry *entry;
int cmp = strcmp(packed->refs[p]->name, loose->refs[l]->name);
if (!cmp) {
packed = packed->next;
p++;
continue;
}
if (cmp > 0) {
entry = loose;
loose = loose->next;
entry = loose->refs[l++];
} else {
entry = packed;
packed = packed->next;
entry = packed->refs[p++];
}
retval = do_one_ref(base, fn, trim, flags, cb_data, entry);
if (retval)
goto end_each;
}

for (packed = packed ? packed : loose; packed; packed = packed->next) {
retval = do_one_ref(base, fn, trim, flags, cb_data, packed);
if (l < loose->nr) {
p = l;
packed = loose;
}

for (; p < packed->nr; p++) {
retval = do_one_ref(base, fn, trim, flags, cb_data, packed->refs[p]);
if (retval)
goto end_each;
}
@ -1087,24 +1043,24 @@ static int remove_empty_directories(const char *file) @@ -1087,24 +1043,24 @@ static int remove_empty_directories(const char *file)
}

static int is_refname_available(const char *ref, const char *oldref,
struct ref_list *list, int quiet)
{
int namlen = strlen(ref); /* e.g. 'foo/bar' */
while (list) {
/* list->name could be 'foo' or 'foo/bar/baz' */
if (!oldref || strcmp(oldref, list->name)) {
int len = strlen(list->name);
struct ref_array *array, int quiet)
{
int i, namlen = strlen(ref); /* e.g. 'foo/bar' */
for (i = 0; i < array->nr; i++ ) {
struct ref_entry *entry = array->refs[i];
/* entry->name could be 'foo' or 'foo/bar/baz' */
if (!oldref || strcmp(oldref, entry->name)) {
int len = strlen(entry->name);
int cmplen = (namlen < len) ? namlen : len;
const char *lead = (namlen < len) ? list->name : ref;
if (!strncmp(ref, list->name, cmplen) &&
const char *lead = (namlen < len) ? entry->name : ref;
if (!strncmp(ref, entry->name, cmplen) &&
lead[cmplen] == '/') {
if (!quiet)
error("'%s' exists; cannot create '%s'",
list->name, ref);
entry->name, ref);
return 0;
}
}
list = list->next;
}
return 1;
}
@ -1207,18 +1163,13 @@ static struct lock_file packlock; @@ -1207,18 +1163,13 @@ static struct lock_file packlock;

static int repack_without_ref(const char *refname)
{
struct ref_list *list, *packed_ref_list;
int fd;
int found = 0;
struct ref_array *packed;
struct ref_entry *ref;
int fd, i;

packed_ref_list = get_packed_refs(NULL);
for (list = packed_ref_list; list; list = list->next) {
if (!strcmp(refname, list->name)) {
found = 1;
break;
}
}
if (!found)
packed = get_packed_refs(NULL);
ref = search_ref_array(packed, refname);
if (ref == NULL)
return 0;
fd = hold_lock_file_for_update(&packlock, git_path("packed-refs"), 0);
if (fd < 0) {
@ -1226,17 +1177,19 @@ static int repack_without_ref(const char *refname) @@ -1226,17 +1177,19 @@ static int repack_without_ref(const char *refname)
return error("cannot delete '%s' from packed refs", refname);
}

for (list = packed_ref_list; list; list = list->next) {
for (i = 0; i < packed->nr; i++) {
char line[PATH_MAX + 100];
int len;

if (!strcmp(refname, list->name))
ref = packed->refs[i];

if (!strcmp(refname, ref->name))
continue;
len = snprintf(line, sizeof(line), "%s %s\n",
sha1_to_hex(list->sha1), list->name);
sha1_to_hex(ref->sha1), ref->name);
/* this should not happen but just being defensive */
if (len > sizeof(line))
die("too long a refname '%s'", list->name);
die("too long a refname '%s'", ref->name);
write_or_die(fd, line, len);
}
return commit_lock_file(&packlock);
@ -1931,7 +1884,7 @@ int update_ref(const char *action, const char *refname, @@ -1931,7 +1884,7 @@ int update_ref(const char *action, const char *refname,
return 0;
}

int ref_exists(char *refname)
int ref_exists(const char *refname)
{
unsigned char sha1[20];
return !!resolve_ref(refname, sha1, 1, NULL);

2
refs.h
Unescape View File

@ -57,7 +57,7 @@ extern void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refn @@ -57,7 +57,7 @@ extern void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refn
*/
extern void add_extra_ref(const char *refname, const unsigned char *sha1, int flags);
extern void clear_extra_refs(void);
extern int ref_exists(char *);
extern int ref_exists(const char *);

extern int peel_ref(const char *, unsigned char *);


Write Preview
Loading…
Cancel
Save