lock_ref_sha1(): do not sometimes error() and sometimes die().

diff --git a/refs.c b/refs.c
index b433c0c2d09e1ba363bd9c10f7144f089dd66b70..157de432ced603cd27f6c181195fa8f72a023c8f 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -66,12 +66,42 @@ static struct ref_list *add_ref(const char *name, const unsigned char *sha1,
        return list;
 }
 
-static struct ref_list *get_packed_refs(void)
+/*
+ * Future: need to be in "struct repository"
+ * when doing a full libification.
+ */
+struct cached_refs {
+       char did_loose;
+       char did_packed;
+       struct ref_list *loose;
+       struct ref_list *packed;
+} cached_refs;
+
+static void free_ref_list(struct ref_list *list)
 {
-       static int did_refs = 0;
-       static struct ref_list *refs = NULL;
+       struct ref_list *next;
+       for ( ; list; list = next) {
+               next = list->next;
+               free(list);
+       }
+}
+
+static void invalidate_cached_refs(void)
+{
+       struct cached_refs *ca = &cached_refs;
+
+       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;
+       ca->did_loose = ca->did_packed = 0;
+}
 
-       if (!did_refs) {
+static struct ref_list *get_packed_refs(void)
+{
+       if (!cached_refs.did_packed) {
+               struct ref_list *refs = NULL;
                FILE *f = fopen(git_path("packed-refs"), "r");
                if (f) {
                        struct ref_list *list = NULL;
@@ -86,9 +116,10 @@ static struct ref_list *get_packed_refs(void)
                        fclose(f);
                        refs = list;
                }
-               did_refs = 1;
+               cached_refs.packed = refs;
+               cached_refs.did_packed = 1;
        }
-       return refs;
+       return cached_refs.packed;
 }
 
 static struct ref_list *get_ref_dir(const char *base, struct ref_list *list)
@@ -138,14 +169,11 @@ static struct ref_list *get_ref_dir(const char *base, struct ref_list *list)
 
 static struct ref_list *get_loose_refs(void)
 {
-       static int did_refs = 0;
-       static struct ref_list *refs = NULL;
-
-       if (!did_refs) {
-               refs = get_ref_dir("refs", NULL);
-               did_refs = 1;
+       if (!cached_refs.did_loose) {
+               cached_refs.loose = get_ref_dir("refs", NULL);
+               cached_refs.did_loose = 1;
        }
-       return refs;
+       return cached_refs.loose;
 }
 
 /* We allow "recursive" symbolic refs. Only within reason, though */
@@ -401,6 +429,7 @@ int delete_ref(const char *refname, unsigned char *sha1)
                fprintf(stderr, "warning: unlink(%s) failed: %s",
                        lock->log_file, strerror(errno));
 
+       invalidate_cached_refs();
        return ret;
 }
 
@@ -532,6 +561,7 @@ static struct ref_lock *lock_ref_sha1_basic(const char *ref, const unsigned char
        const char *orig_ref = ref;
        struct ref_lock *lock;
        struct stat st;
+       int last_errno = 0;
        int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
 
        lock = xcalloc(1, sizeof(struct ref_lock));
@@ -545,17 +575,18 @@ static struct ref_lock *lock_ref_sha1_basic(const char *ref, const unsigned char
                 * to remain.
                 */
                ref_file = git_path("%s", orig_ref);
-               if (remove_empty_directories(ref_file))
-                       die("there are still refs under '%s'", orig_ref);
+               if (remove_empty_directories(ref_file)) {
+                       last_errno = errno;
+                       error("there are still refs under '%s'", orig_ref);
+                       goto error_return;
+               }
                ref = resolve_ref(orig_ref, lock->old_sha1, mustexist, NULL);
        }
        if (!ref) {
-               int last_errno = errno;
+               last_errno = errno;
                error("unable to resolve reference %s: %s",
                        orig_ref, strerror(errno));
-               unlock_ref(lock);
-               errno = last_errno;
-               return NULL;
+               goto error_return;
        }
        lock->lk = xcalloc(1, sizeof(struct lock_file));
 
@@ -564,11 +595,19 @@ static struct ref_lock *lock_ref_sha1_basic(const char *ref, const unsigned char
        ref_file = git_path("%s", ref);
        lock->force_write = lstat(ref_file, &st) && errno == ENOENT;
 
-       if (safe_create_leading_directories(ref_file))
-               die("unable to create directory for %s", ref_file);
+       if (safe_create_leading_directories(ref_file)) {
+               last_errno = errno;
+               error("unable to create directory for %s", ref_file);
+               goto error_return;
+       }
        lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, 1);
 
        return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;
+
+ error_return:
+       unlock_ref(lock);
+       errno = last_errno;
+       return NULL;
 }
 
 struct ref_lock *lock_ref_sha1(const char *ref, const unsigned char *old_sha1)
@@ -665,6 +704,7 @@ int write_ref_sha1(struct ref_lock *lock,
                unlock_ref(lock);
                return -1;
        }
+       invalidate_cached_refs();
        if (log_ref_write(lock, sha1, logmsg) < 0) {
                unlock_ref(lock);
                return -1;