*/
unsigned int referrers;
+ /* The metadata from when this packed-refs cache was read */
+ struct stat_validity validity;
+};
+
+/*
+ * A container for `packed-refs`-related data. It is not (yet) a
+ * `ref_store`.
+ */
+struct packed_ref_store {
+ unsigned int store_flags;
+
+ /* The path of the "packed-refs" file: */
+ char *path;
+
/*
- * Iff the packed-refs file associated with this instance is
- * currently locked for writing, this points at the associated
- * lock (which is owned by somebody else). The referrer count
- * is also incremented when the file is locked and decremented
- * when it is unlocked.
+ * A cache of the values read from the `packed-refs` file, if
+ * it might still be current; otherwise, NULL.
*/
- struct lock_file *lock;
+ struct packed_ref_cache *cache;
- /* The metadata from when this packed-refs cache was read */
- struct stat_validity validity;
+ /*
+ * Lock used for the "packed-refs" file. Note that this (and
+ * thus the enclosing `packed_ref_store`) must not be freed.
+ */
+ struct lock_file lock;
};
+static struct packed_ref_store *packed_ref_store_create(
+ const char *path, unsigned int store_flags)
+{
+ struct packed_ref_store *refs = xcalloc(1, sizeof(*refs));
+
+ refs->store_flags = store_flags;
+ refs->path = xstrdup(path);
+ return refs;
+}
+
+/*
+ * Die if refs is not the main ref store. caller is used in any
+ * necessary error messages.
+ */
+static void packed_assert_main_repository(struct packed_ref_store *refs,
+ const char *caller)
+{
+ if (refs->store_flags & REF_STORE_MAIN)
+ return;
+
+ die("BUG: operation %s only allowed for main ref store", caller);
+}
+
/*
* Future: need to be in "struct repository"
* when doing a full libification.
char *gitdir;
char *gitcommondir;
- char *packed_refs_path;
struct ref_cache *loose;
- struct packed_ref_cache *packed;
-};
-/* Lock used for the main packed-refs file: */
-static struct lock_file packlock;
+ struct packed_ref_store *packed_ref_store;
+};
/*
* Increment the reference count of *packed_refs.
}
}
-static void clear_packed_ref_cache(struct files_ref_store *refs)
+static void clear_packed_ref_cache(struct packed_ref_store *refs)
{
- if (refs->packed) {
- struct packed_ref_cache *packed_refs = refs->packed;
+ if (refs->cache) {
+ struct packed_ref_cache *cache = refs->cache;
- if (packed_refs->lock)
+ if (is_lock_file_locked(&refs->lock))
die("BUG: packed-ref cache cleared while locked");
- refs->packed = NULL;
- release_packed_ref_cache(packed_refs);
+ refs->cache = NULL;
+ release_packed_ref_cache(cache);
}
}
get_common_dir_noenv(&sb, gitdir);
refs->gitcommondir = strbuf_detach(&sb, NULL);
strbuf_addf(&sb, "%s/packed-refs", refs->gitcommondir);
- refs->packed_refs_path = strbuf_detach(&sb, NULL);
+ refs->packed_ref_store = packed_ref_store_create(sb.buf, flags);
+ strbuf_release(&sb);
return ref_store;
}
}
/*
- * Read f, which is a packed-refs file, into dir.
+ * Read from `packed_refs_file` into a newly-allocated
+ * `packed_ref_cache` and return it. The return value will already
+ * have its reference count incremented.
*
* A comment line of the form "# pack-refs with: " may contain zero or
* more traits. We interpret the traits as follows:
* compatibility with older clients, but we do not require it
* (i.e., "peeled" is a no-op if "fully-peeled" is set).
*/
-static void read_packed_refs(FILE *f, struct ref_dir *dir)
+static struct packed_ref_cache *read_packed_refs(const char *packed_refs_file)
{
+ FILE *f;
+ struct packed_ref_cache *packed_refs = xcalloc(1, sizeof(*packed_refs));
struct ref_entry *last = NULL;
struct strbuf line = STRBUF_INIT;
enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled = PEELED_NONE;
+ struct ref_dir *dir;
+
+ acquire_packed_ref_cache(packed_refs);
+ packed_refs->cache = create_ref_cache(NULL, NULL);
+ packed_refs->cache->root->flag &= ~REF_INCOMPLETE;
+ f = fopen(packed_refs_file, "r");
+ if (!f) {
+ if (errno == ENOENT) {
+ /*
+ * This is OK; it just means that no
+ * "packed-refs" file has been written yet,
+ * which is equivalent to it being empty.
+ */
+ return packed_refs;
+ } else {
+ die_errno("couldn't read %s", packed_refs_file);
+ }
+ }
+
+ stat_validity_update(&packed_refs->validity, fileno(f));
+
+ dir = get_ref_dir(packed_refs->cache->root);
while (strbuf_getwholeline(&line, f, '\n') != EOF) {
struct object_id oid;
const char *refname;
oidclr(&oid);
flag |= REF_BAD_NAME | REF_ISBROKEN;
}
- last = create_ref_entry(refname, &oid, flag, 0);
+ last = create_ref_entry(refname, &oid, flag);
if (peeled == PEELED_FULLY ||
(peeled == PEELED_TAGS && starts_with(refname, "refs/tags/")))
last->flag |= REF_KNOWS_PEELED;
}
}
+ fclose(f);
strbuf_release(&line);
-}
-static const char *files_packed_refs_path(struct files_ref_store *refs)
-{
- return refs->packed_refs_path;
+ return packed_refs;
}
static void files_reflog_path(struct files_ref_store *refs,
}
/*
- * Get the packed_ref_cache for the specified files_ref_store,
- * creating it if necessary.
+ * Check that the packed refs cache (if any) still reflects the
+ * contents of the file. If not, clear the cache.
*/
-static struct packed_ref_cache *get_packed_ref_cache(struct files_ref_store *refs)
+static void validate_packed_ref_cache(struct packed_ref_store *refs)
{
- const char *packed_refs_file = files_packed_refs_path(refs);
-
- if (refs->packed &&
- !stat_validity_check(&refs->packed->validity, packed_refs_file))
+ if (refs->cache &&
+ !stat_validity_check(&refs->cache->validity, refs->path))
clear_packed_ref_cache(refs);
+}
- if (!refs->packed) {
- FILE *f;
-
- refs->packed = xcalloc(1, sizeof(*refs->packed));
- acquire_packed_ref_cache(refs->packed);
- refs->packed->cache = create_ref_cache(&refs->base, NULL);
- refs->packed->cache->root->flag &= ~REF_INCOMPLETE;
- f = fopen(packed_refs_file, "r");
- if (f) {
- stat_validity_update(&refs->packed->validity, fileno(f));
- read_packed_refs(f, get_ref_dir(refs->packed->cache->root));
- fclose(f);
- }
- }
- return refs->packed;
+/*
+ * Get the packed_ref_cache for the specified packed_ref_store,
+ * creating and populating it if it hasn't been read before or if the
+ * file has been changed (according to its `validity` field) since it
+ * was last read. On the other hand, if we hold the lock, then assume
+ * that the file hasn't been changed out from under us, so skip the
+ * extra `stat()` call in `stat_validity_check()`.
+ */
+static struct packed_ref_cache *get_packed_ref_cache(struct packed_ref_store *refs)
+{
+ if (!is_lock_file_locked(&refs->lock))
+ validate_packed_ref_cache(refs);
+
+ if (!refs->cache)
+ refs->cache = read_packed_refs(refs->path);
+
+ return refs->cache;
}
static struct ref_dir *get_packed_ref_dir(struct packed_ref_cache *packed_ref_cache)
return get_ref_dir(packed_ref_cache->cache->root);
}
-static struct ref_dir *get_packed_refs(struct files_ref_store *refs)
+static struct ref_dir *get_packed_refs(struct packed_ref_store *refs)
{
return get_packed_ref_dir(get_packed_ref_cache(refs));
}
/*
- * Add a reference to the in-memory packed reference cache. This may
- * only be called while the packed-refs file is locked (see
- * lock_packed_refs()). To actually write the packed-refs file, call
- * commit_packed_refs().
+ * Add or overwrite a reference in the in-memory packed reference
+ * cache. This may only be called while the packed-refs file is locked
+ * (see lock_packed_refs()). To actually write the packed-refs file,
+ * call commit_packed_refs().
*/
-static void add_packed_ref(struct files_ref_store *refs,
+static void add_packed_ref(struct packed_ref_store *refs,
const char *refname, const struct object_id *oid)
{
- struct packed_ref_cache *packed_ref_cache = get_packed_ref_cache(refs);
+ struct ref_dir *packed_refs;
+ struct ref_entry *packed_entry;
- if (!packed_ref_cache->lock)
+ if (!is_lock_file_locked(&refs->lock))
die("BUG: packed refs not locked");
- add_ref_entry(get_packed_ref_dir(packed_ref_cache),
- create_ref_entry(refname, oid, REF_ISPACKED, 1));
+
+ if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))
+ die("Reference has invalid format: '%s'", refname);
+
+ packed_refs = get_packed_refs(refs);
+ packed_entry = find_ref_entry(packed_refs, refname);
+ if (packed_entry) {
+ /* Overwrite the existing entry: */
+ oidcpy(&packed_entry->u.value.oid, oid);
+ packed_entry->flag = REF_ISPACKED;
+ oidclr(&packed_entry->u.value.peeled);
+ } else {
+ packed_entry = create_ref_entry(refname, oid, REF_ISPACKED);
+ add_ref_entry(packed_refs, packed_entry);
+ }
}
/*
flag |= REF_BAD_NAME | REF_ISBROKEN;
}
add_entry_to_dir(dir,
- create_ref_entry(refname.buf, &oid, flag, 0));
+ create_ref_entry(refname.buf, &oid, flag));
}
strbuf_setlen(&refname, dirnamelen);
strbuf_setlen(&path, path_baselen);
static struct ref_entry *get_packed_ref(struct files_ref_store *refs,
const char *refname)
{
- return find_ref_entry(get_packed_refs(refs), refname);
+ return find_ref_entry(get_packed_refs(refs->packed_ref_store), refname);
}
/*
struct ref_iterator *loose_iter, *packed_iter;
struct files_ref_iterator *iter;
struct ref_iterator *ref_iterator;
+ unsigned int required_flags = REF_STORE_READ;
- if (ref_paranoia < 0)
- ref_paranoia = git_env_bool("GIT_REF_PARANOIA", 0);
- if (ref_paranoia)
- flags |= DO_FOR_EACH_INCLUDE_BROKEN;
+ if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN))
+ required_flags |= REF_STORE_ODB;
- refs = files_downcast(ref_store,
- REF_STORE_READ | (ref_paranoia ? 0 : REF_STORE_ODB),
- "ref_iterator_begin");
+ refs = files_downcast(ref_store, required_flags, "ref_iterator_begin");
iter = xcalloc(1, sizeof(*iter));
ref_iterator = &iter->base;
loose_iter = cache_ref_iterator_begin(get_loose_ref_cache(refs),
prefix, 1);
- iter->packed_ref_cache = get_packed_ref_cache(refs);
+ iter->packed_ref_cache = get_packed_ref_cache(refs->packed_ref_store);
acquire_packed_ref_cache(iter->packed_ref_cache);
packed_iter = cache_ref_iterator_begin(iter->packed_ref_cache->cache,
prefix, 0);
* hold_lock_file_for_update(). Return 0 on success. On errors, set
* errno appropriately and return a nonzero value.
*/
-static int lock_packed_refs(struct files_ref_store *refs, int flags)
+static int lock_packed_refs(struct packed_ref_store *refs, int flags)
{
static int timeout_configured = 0;
static int timeout_value = 1000;
struct packed_ref_cache *packed_ref_cache;
- files_assert_main_repository(refs, "lock_packed_refs");
+ packed_assert_main_repository(refs, "lock_packed_refs");
if (!timeout_configured) {
git_config_get_int("core.packedrefstimeout", &timeout_value);
}
if (hold_lock_file_for_update_timeout(
- &packlock, files_packed_refs_path(refs),
+ &refs->lock,
+ refs->path,
flags, timeout_value) < 0)
return -1;
+
/*
- * Get the current packed-refs while holding the lock. If the
- * packed-refs file has been modified since we last read it,
- * this will automatically invalidate the cache and re-read
- * the packed-refs file.
+ * Now that we hold the `packed-refs` lock, make sure that our
+ * cache matches the current version of the file. Normally
+ * `get_packed_ref_cache()` does that for us, but that
+ * function assumes that when the file is locked, any existing
+ * cache is still valid. We've just locked the file, but it
+ * might have changed the moment *before* we locked it.
*/
+ validate_packed_ref_cache(refs);
+
packed_ref_cache = get_packed_ref_cache(refs);
- packed_ref_cache->lock = &packlock;
/* Increment the reference count to prevent it from being freed: */
acquire_packed_ref_cache(packed_ref_cache);
return 0;
* lock_packed_refs()). Return zero on success. On errors, set errno
* and return a nonzero value
*/
-static int commit_packed_refs(struct files_ref_store *refs)
+static int commit_packed_refs(struct packed_ref_store *refs)
{
struct packed_ref_cache *packed_ref_cache =
get_packed_ref_cache(refs);
FILE *out;
struct ref_iterator *iter;
- files_assert_main_repository(refs, "commit_packed_refs");
+ packed_assert_main_repository(refs, "commit_packed_refs");
- if (!packed_ref_cache->lock)
+ if (!is_lock_file_locked(&refs->lock))
die("BUG: packed-refs not locked");
- out = fdopen_lock_file(packed_ref_cache->lock, "w");
+ out = fdopen_lock_file(&refs->lock, "w");
if (!out)
die_errno("unable to fdopen packed-refs descriptor");
if (ok != ITER_DONE)
die("error while iterating over references");
- if (commit_lock_file(packed_ref_cache->lock)) {
+ if (commit_lock_file(&refs->lock)) {
save_errno = errno;
error = -1;
}
- packed_ref_cache->lock = NULL;
release_packed_ref_cache(packed_ref_cache);
errno = save_errno;
return error;
static void rollback_packed_refs(struct files_ref_store *refs)
{
struct packed_ref_cache *packed_ref_cache =
- get_packed_ref_cache(refs);
+ get_packed_ref_cache(refs->packed_ref_store);
files_assert_main_repository(refs, "rollback_packed_refs");
- if (!packed_ref_cache->lock)
+ if (!is_lock_file_locked(&refs->packed_ref_store->lock))
die("BUG: packed-refs not locked");
- rollback_lock_file(packed_ref_cache->lock);
- packed_ref_cache->lock = NULL;
+ rollback_lock_file(&refs->packed_ref_store->lock);
release_packed_ref_cache(packed_ref_cache);
- clear_packed_ref_cache(refs);
+ clear_packed_ref_cache(refs->packed_ref_store);
}
struct ref_to_prune {
}
}
+/*
+ * Return true if the specified reference should be packed.
+ */
+static int should_pack_ref(const char *refname,
+ const struct object_id *oid, unsigned int ref_flags,
+ unsigned int pack_flags)
+{
+ /* Do not pack per-worktree refs: */
+ if (ref_type(refname) != REF_TYPE_NORMAL)
+ return 0;
+
+ /* Do not pack non-tags unless PACK_REFS_ALL is set: */
+ if (!(pack_flags & PACK_REFS_ALL) && !starts_with(refname, "refs/tags/"))
+ return 0;
+
+ /* Do not pack symbolic refs: */
+ if (ref_flags & REF_ISSYMREF)
+ return 0;
+
+ /* Do not pack broken refs: */
+ if (!ref_resolves_to_object(refname, oid, ref_flags))
+ return 0;
+
+ return 1;
+}
+
static int files_pack_refs(struct ref_store *ref_store, unsigned int flags)
{
struct files_ref_store *refs =
files_downcast(ref_store, REF_STORE_WRITE | REF_STORE_ODB,
"pack_refs");
struct ref_iterator *iter;
- struct ref_dir *packed_refs;
int ok;
struct ref_to_prune *refs_to_prune = NULL;
- lock_packed_refs(refs, LOCK_DIE_ON_ERROR);
- packed_refs = get_packed_refs(refs);
+ lock_packed_refs(refs->packed_ref_store, LOCK_DIE_ON_ERROR);
iter = cache_ref_iterator_begin(get_loose_ref_cache(refs), NULL, 0);
while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
* in the packed ref cache. If the reference should be
* pruned, also add it to refs_to_prune.
*/
- struct ref_entry *packed_entry;
- int is_tag_ref = starts_with(iter->refname, "refs/tags/");
-
- /* Do not pack per-worktree refs: */
- if (ref_type(iter->refname) != REF_TYPE_NORMAL)
- continue;
-
- /* ALWAYS pack tags */
- if (!(flags & PACK_REFS_ALL) && !is_tag_ref)
- continue;
-
- /* Do not pack symbolic or broken refs: */
- if (iter->flags & REF_ISSYMREF)
- continue;
-
- if (!ref_resolves_to_object(iter->refname, iter->oid, iter->flags))
+ if (!should_pack_ref(iter->refname, iter->oid, iter->flags,
+ flags))
continue;
/*
* we don't copy the peeled status, because we want it
* to be re-peeled.
*/
- packed_entry = find_ref_entry(packed_refs, iter->refname);
- if (packed_entry) {
- /* Overwrite existing packed entry with info from loose entry */
- packed_entry->flag = REF_ISPACKED;
- oidcpy(&packed_entry->u.value.oid, iter->oid);
- } else {
- packed_entry = create_ref_entry(iter->refname, iter->oid,
- REF_ISPACKED, 0);
- add_ref_entry(packed_refs, packed_entry);
- }
- oidclr(&packed_entry->u.value.peeled);
+ add_packed_ref(refs->packed_ref_store, iter->refname, iter->oid);
/* Schedule the loose reference for pruning if requested. */
if ((flags & PACK_REFS_PRUNE)) {
if (ok != ITER_DONE)
die("error while iterating over references");
- if (commit_packed_refs(refs))
+ if (commit_packed_refs(refs->packed_ref_store))
die_errno("unable to overwrite old ref-pack file");
prune_refs(refs, refs_to_prune);
if (!needs_repacking)
return 0; /* no refname exists in packed refs */
- if (lock_packed_refs(refs, 0)) {
- unable_to_lock_message(files_packed_refs_path(refs), errno, err);
+ if (lock_packed_refs(refs->packed_ref_store, 0)) {
+ unable_to_lock_message(refs->packed_ref_store->path, errno, err);
return -1;
}
- packed = get_packed_refs(refs);
+ packed = get_packed_refs(refs->packed_ref_store);
/* Remove refnames from the cache */
for_each_string_list_item(refname, refnames)
}
/* Write what remains */
- ret = commit_packed_refs(refs);
+ ret = commit_packed_refs(refs->packed_ref_store);
if (ret)
strbuf_addf(err, "unable to overwrite old ref-pack file: %s",
strerror(errno));
return ret;
}
-static int files_delete_refs(struct ref_store *ref_store,
+static int files_delete_refs(struct ref_store *ref_store, const char *msg,
struct string_list *refnames, unsigned int flags)
{
struct files_ref_store *refs =
for (i = 0; i < refnames->nr; i++) {
const char *refname = refnames->items[i].string;
- if (refs_delete_ref(&refs->base, NULL, refname, NULL, flags))
+ if (refs_delete_ref(&refs->base, msg, refname, NULL, flags))
result |= error(_("could not remove reference %s"), refname);
}
return ref_iterator;
}
-static int ref_update_reject_duplicates(struct string_list *refnames,
- struct strbuf *err)
-{
- int i, n = refnames->nr;
-
- assert(err);
-
- for (i = 1; i < n; i++)
- if (!strcmp(refnames->items[i - 1].string, refnames->items[i].string)) {
- strbuf_addf(err,
- "multiple updates for ref '%s' not allowed.",
- refnames->items[i].string);
- return 1;
- }
- return 0;
-}
-
/*
* If update is a direct update of head_ref (the reference pointed to
* by HEAD), then add an extra REF_LOG_ONLY update for HEAD.
return 0;
}
-static int files_transaction_commit(struct ref_store *ref_store,
- struct ref_transaction *transaction,
- struct strbuf *err)
+/*
+ * Unlock any references in `transaction` that are still locked, and
+ * mark the transaction closed.
+ */
+static void files_transaction_cleanup(struct ref_transaction *transaction)
+{
+ size_t i;
+
+ for (i = 0; i < transaction->nr; i++) {
+ struct ref_update *update = transaction->updates[i];
+ struct ref_lock *lock = update->backend_data;
+
+ if (lock) {
+ unlock_ref(lock);
+ update->backend_data = NULL;
+ }
+ }
+
+ transaction->state = REF_TRANSACTION_CLOSED;
+}
+
+static int files_transaction_prepare(struct ref_store *ref_store,
+ struct ref_transaction *transaction,
+ struct strbuf *err)
{
struct files_ref_store *refs =
files_downcast(ref_store, REF_STORE_WRITE,
- "ref_transaction_commit");
- int ret = 0, i;
- struct string_list refs_to_delete = STRING_LIST_INIT_NODUP;
- struct string_list_item *ref_to_delete;
+ "ref_transaction_prepare");
+ size_t i;
+ int ret = 0;
struct string_list affected_refnames = STRING_LIST_INIT_NODUP;
char *head_ref = NULL;
int head_type;
struct object_id head_oid;
- struct strbuf sb = STRBUF_INIT;
assert(err);
- if (transaction->state != REF_TRANSACTION_OPEN)
- die("BUG: commit called for transaction that is not open");
-
- if (!transaction->nr) {
- transaction->state = REF_TRANSACTION_CLOSED;
- return 0;
- }
+ if (!transaction->nr)
+ goto cleanup;
/*
* Fail if a refname appears more than once in the
* that new values are valid, and write new values to the
* lockfiles, ready to be activated. Only keep one lockfile
* open at a time to avoid running out of file descriptors.
+ * Note that lock_ref_for_update() might append more updates
+ * to the transaction.
*/
for (i = 0; i < transaction->nr; i++) {
struct ref_update *update = transaction->updates[i];
ret = lock_ref_for_update(refs, update, transaction,
head_ref, &affected_refnames, err);
if (ret)
- goto cleanup;
+ break;
+ }
+
+cleanup:
+ free(head_ref);
+ string_list_clear(&affected_refnames, 0);
+
+ if (ret)
+ files_transaction_cleanup(transaction);
+ else
+ transaction->state = REF_TRANSACTION_PREPARED;
+
+ return ret;
+}
+
+static int files_transaction_finish(struct ref_store *ref_store,
+ struct ref_transaction *transaction,
+ struct strbuf *err)
+{
+ struct files_ref_store *refs =
+ files_downcast(ref_store, 0, "ref_transaction_finish");
+ size_t i;
+ int ret = 0;
+ struct string_list refs_to_delete = STRING_LIST_INIT_NODUP;
+ struct string_list_item *ref_to_delete;
+ struct strbuf sb = STRBUF_INIT;
+
+ assert(err);
+
+ if (!transaction->nr) {
+ transaction->state = REF_TRANSACTION_CLOSED;
+ return 0;
}
/* Perform updates first so live commits remain referenced */
clear_loose_ref_cache(refs);
cleanup:
- strbuf_release(&sb);
- transaction->state = REF_TRANSACTION_CLOSED;
+ files_transaction_cleanup(transaction);
for (i = 0; i < transaction->nr; i++) {
struct ref_update *update = transaction->updates[i];
- struct ref_lock *lock = update->backend_data;
-
- if (lock)
- unlock_ref(lock);
if (update->flags & REF_DELETED_LOOSE) {
/*
}
}
+ strbuf_release(&sb);
string_list_clear(&refs_to_delete, 0);
- free(head_ref);
- string_list_clear(&affected_refnames, 0);
-
return ret;
}
+static int files_transaction_abort(struct ref_store *ref_store,
+ struct ref_transaction *transaction,
+ struct strbuf *err)
+{
+ files_transaction_cleanup(transaction);
+ return 0;
+}
+
static int ref_present(const char *refname,
const struct object_id *oid, int flags, void *cb_data)
{
struct files_ref_store *refs =
files_downcast(ref_store, REF_STORE_WRITE,
"initial_ref_transaction_commit");
- int ret = 0, i;
+ size_t i;
+ int ret = 0;
struct string_list affected_refnames = STRING_LIST_INIT_NODUP;
assert(err);
}
}
- if (lock_packed_refs(refs, 0)) {
+ if (lock_packed_refs(refs->packed_ref_store, 0)) {
strbuf_addf(err, "unable to lock packed-refs file: %s",
strerror(errno));
ret = TRANSACTION_GENERIC_ERROR;
if ((update->flags & REF_HAVE_NEW) &&
!is_null_oid(&update->new_oid))
- add_packed_ref(refs, update->refname,
+ add_packed_ref(refs->packed_ref_store, update->refname,
&update->new_oid);
}
- if (commit_packed_refs(refs)) {
+ if (commit_packed_refs(refs->packed_ref_store)) {
strbuf_addf(err, "unable to commit packed-refs file: %s",
strerror(errno));
ret = TRANSACTION_GENERIC_ERROR;
"files",
files_ref_store_create,
files_init_db,
- files_transaction_commit,
+ files_transaction_prepare,
+ files_transaction_finish,
+ files_transaction_abort,
files_initial_transaction_commit,
files_pack_refs,