struct packed_ref_store {
unsigned int store_flags;
+ /* The path of the "packed-refs" file: */
+ char *path;
+
/*
* A cache of the values read from the `packed-refs` file, if
* it might still be current; otherwise, NULL.
*/
struct packed_ref_cache *cache;
+
+ /*
+ * 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(unsigned int store_flags)
+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;
- /*
- * Lock used for the "packed-refs" file. Note that this (and
- * thus the enclosing `files_ref_store`) must not be freed.
- */
- struct lock_file packed_refs_lock;
-
struct packed_ref_store *packed_ref_store;
};
}
}
-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_ref_store->cache) {
- struct packed_ref_cache *packed_refs = refs->packed_ref_store->cache;
+ if (refs->cache) {
+ struct packed_ref_cache *cache = refs->cache;
- if (is_lock_file_locked(&refs->packed_refs_lock))
+ if (is_lock_file_locked(&refs->lock))
die("BUG: packed-ref cache cleared while locked");
- refs->packed_ref_store->cache = 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(flags);
+ refs->packed_ref_store = packed_ref_store_create(sb.buf, flags);
+ strbuf_release(&sb);
return ref_store;
}
return packed_refs;
}
-static const char *files_packed_refs_path(struct files_ref_store *refs)
-{
- return refs->packed_refs_path;
-}
-
static void files_reflog_path(struct files_ref_store *refs,
struct strbuf *sb,
const char *refname)
* Check that the packed refs cache (if any) still reflects the
* contents of the file. If not, clear the cache.
*/
-static void validate_packed_ref_cache(struct files_ref_store *refs)
+static void validate_packed_ref_cache(struct packed_ref_store *refs)
{
- if (refs->packed_ref_store->cache &&
- !stat_validity_check(&refs->packed_ref_store->cache->validity,
- files_packed_refs_path(refs)))
+ if (refs->cache &&
+ !stat_validity_check(&refs->cache->validity, refs->path))
clear_packed_ref_cache(refs);
}
/*
- * Get the packed_ref_cache for the specified files_ref_store,
+ * 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 files_ref_store *refs)
+static struct packed_ref_cache *get_packed_ref_cache(struct packed_ref_store *refs)
{
- const char *packed_refs_file = files_packed_refs_path(refs);
-
- if (!is_lock_file_locked(&refs->packed_refs_lock))
+ if (!is_lock_file_locked(&refs->lock))
validate_packed_ref_cache(refs);
- if (!refs->packed_ref_store->cache)
- refs->packed_ref_store->cache = read_packed_refs(packed_refs_file);
+ if (!refs->cache)
+ refs->cache = read_packed_refs(refs->path);
- return refs->packed_ref_store->cache;
+ 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));
}
* (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 ref_dir *packed_refs;
struct ref_entry *packed_entry;
- if (!is_lock_file_locked(&refs->packed_refs_lock))
+ if (!is_lock_file_locked(&refs->lock))
die("BUG: packed refs not locked");
if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))
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);
}
/*
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(
- &refs->packed_refs_lock, files_packed_refs_path(refs),
+ &refs->lock,
+ refs->path,
flags, timeout_value) < 0)
return -1;
* 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 (!is_lock_file_locked(&refs->packed_refs_lock))
+ if (!is_lock_file_locked(&refs->lock))
die("BUG: packed-refs not locked");
- out = fdopen_lock_file(&refs->packed_refs_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(&refs->packed_refs_lock)) {
+ if (commit_lock_file(&refs->lock)) {
save_errno = errno;
error = -1;
}
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 (!is_lock_file_locked(&refs->packed_refs_lock))
+ if (!is_lock_file_locked(&refs->packed_ref_store->lock))
die("BUG: packed-refs not locked");
- rollback_lock_file(&refs->packed_refs_lock);
+ 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 {
int ok;
struct ref_to_prune *refs_to_prune = NULL;
- lock_packed_refs(refs, LOCK_DIE_ON_ERROR);
+ 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) {
* we don't copy the peeled status, because we want it
* to be re-peeled.
*/
- add_packed_ref(refs, iter->refname, iter->oid);
+ 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));
}
}
- 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;