{lock,commit,rollback}_packed_refs(): add files_ref_store arguments

These functions currently only work in the main repository, so add an
assert_main_repository() check to each function.

Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/refs/files-backend.c b/refs/files-backend.c
index 9c81af900c1805e26d623e2a560c5ab0f67212d2..17404413cc813b3f0b16bbb1ba0b0c463451481b 100644 (file)
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -2215,14 +2215,14 @@ static int write_packed_entry_fn(struct ref_entry *entry, void *cb_data)
  * hold_lock_file_for_update(). Return 0 on success. On errors, set
  * errno appropriately and return a nonzero value.
  */
  * hold_lock_file_for_update(). Return 0 on success. On errors, set
  * errno appropriately and return a nonzero value.
  */

-static int lock_packed_refs(int flags)
+static int lock_packed_refs(struct files_ref_store *refs, int flags)

 {
 {

-       struct files_ref_store *refs =
-               get_files_ref_store(NULL, "lock_packed_refs");

        static int timeout_configured = 0;
        static int timeout_value = 1000;
        struct packed_ref_cache *packed_ref_cache;
 
        static int timeout_configured = 0;
        static int timeout_value = 1000;
        struct packed_ref_cache *packed_ref_cache;
 

+       assert_main_repository(&refs->base, "lock_packed_refs");
+

        if (!timeout_configured) {
                git_config_get_int("core.packedrefstimeout", &timeout_value);
                timeout_configured = 1;
        if (!timeout_configured) {
                git_config_get_int("core.packedrefstimeout", &timeout_value);
                timeout_configured = 1;


@@ -2251,16 +2251,16 @@ static int lock_packed_refs(int flags)
  * lock_packed_refs()). Return zero on success. On errors, set errno
  * and return a nonzero value
  */
  * lock_packed_refs()). Return zero on success. On errors, set errno
  * and return a nonzero value
  */

-static int commit_packed_refs(void)
+static int commit_packed_refs(struct files_ref_store *refs)

 {
 {

-       struct files_ref_store *refs =
-               get_files_ref_store(NULL, "commit_packed_refs");

        struct packed_ref_cache *packed_ref_cache =
                get_packed_ref_cache(refs);
        int error = 0;
        int save_errno = 0;
        FILE *out;
 
        struct packed_ref_cache *packed_ref_cache =
                get_packed_ref_cache(refs);
        int error = 0;
        int save_errno = 0;
        FILE *out;
 

+       assert_main_repository(&refs->base, "commit_packed_refs");
+

        if (!packed_ref_cache->lock)
                die("internal error: packed-refs not locked");
 
        if (!packed_ref_cache->lock)
                die("internal error: packed-refs not locked");
 


@@ -2287,13 +2287,13 @@ static int commit_packed_refs(void)
  * in-memory packed reference cache.  (The packed-refs file will be
  * read anew if it is needed again after this function is called.)
  */
  * in-memory packed reference cache.  (The packed-refs file will be
  * read anew if it is needed again after this function is called.)
  */

-static void rollback_packed_refs(void)
+static void rollback_packed_refs(struct files_ref_store *refs)

 {
 {

-       struct files_ref_store *refs =
-               get_files_ref_store(NULL, "rollback_packed_refs");

        struct packed_ref_cache *packed_ref_cache =
                get_packed_ref_cache(refs);
 
        struct packed_ref_cache *packed_ref_cache =
                get_packed_ref_cache(refs);
 

+       assert_main_repository(&refs->base, "rollback_packed_refs");
+

        if (!packed_ref_cache->lock)
                die("internal error: packed-refs not locked");
        rollback_lock_file(packed_ref_cache->lock);
        if (!packed_ref_cache->lock)
                die("internal error: packed-refs not locked");
        rollback_lock_file(packed_ref_cache->lock);


@@ -2439,13 +2439,13 @@ int pack_refs(unsigned int flags)
        memset(&cbdata, 0, sizeof(cbdata));
        cbdata.flags = flags;
 
        memset(&cbdata, 0, sizeof(cbdata));
        cbdata.flags = flags;
 

-       lock_packed_refs(LOCK_DIE_ON_ERROR);
+       lock_packed_refs(refs, LOCK_DIE_ON_ERROR);

        cbdata.packed_refs = get_packed_refs(refs);
 
        do_for_each_entry_in_dir(get_loose_refs(refs), 0,
                                 pack_if_possible_fn, &cbdata);
 
        cbdata.packed_refs = get_packed_refs(refs);
 
        do_for_each_entry_in_dir(get_loose_refs(refs), 0,
                                 pack_if_possible_fn, &cbdata);
 

-       if (commit_packed_refs())
+       if (commit_packed_refs(refs))

                die_errno("unable to overwrite old ref-pack file");
 
        prune_refs(cbdata.ref_to_prune);
                die_errno("unable to overwrite old ref-pack file");
 
        prune_refs(cbdata.ref_to_prune);


@@ -2481,7 +2481,7 @@ static int repack_without_refs(struct string_list *refnames, struct strbuf *err)
        if (!needs_repacking)
                return 0; /* no refname exists in packed refs */
 
        if (!needs_repacking)
                return 0; /* no refname exists in packed refs */
 

-       if (lock_packed_refs(0)) {
+       if (lock_packed_refs(refs, 0)) {

                unable_to_lock_message(git_path("packed-refs"), errno, err);
                return -1;
        }
                unable_to_lock_message(git_path("packed-refs"), errno, err);
                return -1;
        }


@@ -2496,12 +2496,12 @@ static int repack_without_refs(struct string_list *refnames, struct strbuf *err)
                 * All packed entries disappeared while we were
                 * acquiring the lock.
                 */
                 * All packed entries disappeared while we were
                 * acquiring the lock.
                 */

-               rollback_packed_refs();
+               rollback_packed_refs(refs);

                return 0;
        }
 
        /* Write what remains */
                return 0;
        }
 
        /* Write what remains */

-       ret = commit_packed_refs();
+       ret = commit_packed_refs(refs);

        if (ret)
                strbuf_addf(err, "unable to overwrite old ref-pack file: %s",
                            strerror(errno));
        if (ret)
                strbuf_addf(err, "unable to overwrite old ref-pack file: %s",
                            strerror(errno));


@@ -3919,7 +3919,7 @@ int initial_ref_transaction_commit(struct ref_transaction *transaction,
                }
        }
 
                }
        }
 

-       if (lock_packed_refs(0)) {
+       if (lock_packed_refs(refs, 0)) {

                strbuf_addf(err, "unable to lock packed-refs file: %s",
                            strerror(errno));
                ret = TRANSACTION_GENERIC_ERROR;
                strbuf_addf(err, "unable to lock packed-refs file: %s",
                            strerror(errno));
                ret = TRANSACTION_GENERIC_ERROR;


@@ -3934,7 +3934,7 @@ int initial_ref_transaction_commit(struct ref_transaction *transaction,
                        add_packed_ref(refs, update->refname, update->new_sha1);
        }
 
                        add_packed_ref(refs, update->refname, update->new_sha1);
        }
 

-       if (commit_packed_refs()) {
+       if (commit_packed_refs(refs)) {

                strbuf_addf(err, "unable to commit packed-refs file: %s",
                            strerror(errno));
                ret = TRANSACTION_GENERIC_ERROR;
                strbuf_addf(err, "unable to commit packed-refs file: %s",
                            strerror(errno));
                ret = TRANSACTION_GENERIC_ERROR;