From f6e75467ca83f116e96525c33d9b669e47f310fd Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:07 +0200 Subject: resolve_gitlink_ref(): eliminate temporary variable Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index a9ca003bae..d56fc15163 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1387,7 +1387,7 @@ static int resolve_gitlink_ref_recursive(struct ref_cache *refs, int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1) { - int len = strlen(path), retval; + int len = strlen(path); struct strbuf submodule = STRBUF_INIT; struct ref_cache *refs; @@ -1404,8 +1404,7 @@ int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sh } strbuf_release(&submodule); - retval = resolve_gitlink_ref_recursive(refs, refname, sha1, 0); - return retval; + return resolve_gitlink_ref_recursive(refs, refname, sha1, 0); } /* -- cgit v1.2.3 From ff3a299c457cb159a83df8382ed76731e03db530 Mon Sep 17 00:00:00 2001 From: David Turner Date: Sun, 4 Sep 2016 18:08:08 +0200 Subject: rename_ref_available(): add docstring And improve the internal variable names. Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 12 ++++++------ refs/refs-internal.h | 12 +++++++++++- 2 files changed, 17 insertions(+), 7 deletions(-) diff --git a/refs.c b/refs.c index 814cad3163..256fef5da0 100644 --- a/refs.c +++ b/refs.c @@ -1081,20 +1081,20 @@ const char *find_descendant_ref(const char *dirname, return NULL; } -int rename_ref_available(const char *oldname, const char *newname) +int rename_ref_available(const char *old_refname, const char *new_refname) { struct string_list skip = STRING_LIST_INIT_NODUP; struct strbuf err = STRBUF_INIT; - int ret; + int ok; - string_list_insert(&skip, oldname); - ret = !verify_refname_available(newname, NULL, &skip, &err); - if (!ret) + string_list_insert(&skip, old_refname); + ok = !verify_refname_available(new_refname, NULL, &skip, &err); + if (!ok) error("%s", err.buf); string_list_clear(&skip, 0); strbuf_release(&err); - return ret; + return ok; } int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data) diff --git a/refs/refs-internal.h b/refs/refs-internal.h index efe584701b..0206e2b959 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -240,7 +240,17 @@ const char *find_descendant_ref(const char *dirname, const struct string_list *extras, const struct string_list *skip); -int rename_ref_available(const char *oldname, const char *newname); +/* + * Check whether an attempt to rename old_refname to new_refname would + * cause a D/F conflict with any existing reference (other than + * possibly old_refname). If there would be a conflict, emit an error + * message and return false; otherwise, return true. + * + * Note that this function is not safe against all races with other + * processes (though rename_ref() catches some races that might get by + * this check). + */ +int rename_ref_available(const char *old_refname, const char *new_refname); /* We allow "recursive" symbolic refs. Only within reason, though */ #define SYMREF_MAXDEPTH 5 -- cgit v1.2.3 From 65a0a8e5facb42f41561a96af209016954878b63 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:09 +0200 Subject: refs: rename struct ref_cache to files_ref_store The greater goal of this patch series is to develop the concept of a reference store, which is a place that references, their values, and their reflogs are stored, and to virtualize the reference interface so that different types of ref_stores can be implemented. We will then, for example, use ref_store instances to access submodule references and worktree references. Currently, we keep a ref_cache for each submodule that has had its references iterated over. It is a far cry from a ref_store, but they are stored the way we will want to store ref_stores, and ref_stores will eventually have to hold the reference caches. So let's treat ref_caches as embryo ref_stores, and build them out from there. As the first step, simply rename `ref_cache` to `files_ref_store`, and rename some functions and attributes correspondingly. Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 126 +++++++++++++++++++++++++-------------------------- 1 file changed, 63 insertions(+), 63 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index d56fc15163..c229b56bd5 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -39,7 +39,7 @@ struct ref_value { struct object_id peeled; }; -struct ref_cache; +struct files_ref_store; /* * Information used (along with the information in ref_entry) to @@ -78,8 +78,8 @@ struct ref_dir { */ int sorted; - /* A pointer to the ref_cache that contains this ref_dir. */ - struct ref_cache *ref_cache; + /* A pointer to the files_ref_store that contains this ref_dir. */ + struct files_ref_store *ref_store; struct ref_entry **entries; }; @@ -161,7 +161,7 @@ struct ref_entry { static void read_loose_refs(const char *dirname, struct ref_dir *dir); static int search_ref_dir(struct ref_dir *dir, const char *refname, size_t len); -static struct ref_entry *create_dir_entry(struct ref_cache *ref_cache, +static struct ref_entry *create_dir_entry(struct files_ref_store *ref_store, const char *dirname, size_t len, int incomplete); static void add_entry_to_dir(struct ref_dir *dir, struct ref_entry *entry); @@ -183,7 +183,7 @@ static struct ref_dir *get_ref_dir(struct ref_entry *entry) int pos = search_ref_dir(dir, "refs/bisect/", 12); if (pos < 0) { struct ref_entry *child_entry; - child_entry = create_dir_entry(dir->ref_cache, + child_entry = create_dir_entry(dir->ref_store, "refs/bisect/", 12, 1); add_entry_to_dir(dir, child_entry); @@ -261,13 +261,13 @@ static void clear_ref_dir(struct ref_dir *dir) * dirname is the name of the directory with a trailing slash (e.g., * "refs/heads/") or "" for the top-level directory. */ -static struct ref_entry *create_dir_entry(struct ref_cache *ref_cache, +static struct ref_entry *create_dir_entry(struct files_ref_store *ref_store, const char *dirname, size_t len, int incomplete) { struct ref_entry *direntry; FLEX_ALLOC_MEM(direntry, name, dirname, len); - direntry->u.subdir.ref_cache = ref_cache; + direntry->u.subdir.ref_store = ref_store; direntry->flag = REF_DIR | (incomplete ? REF_INCOMPLETE : 0); return direntry; } @@ -343,7 +343,7 @@ static struct ref_dir *search_for_subdir(struct ref_dir *dir, * therefore, create an empty record for it but mark * the record complete. */ - entry = create_dir_entry(dir->ref_cache, subdirname, len, 0); + entry = create_dir_entry(dir->ref_store, subdirname, len, 0); add_entry_to_dir(dir, entry); } else { entry = dir->entries[entry_index]; @@ -887,9 +887,9 @@ struct packed_ref_cache { /* * Count of references to the data structure in this instance, - * including the pointer from ref_cache::packed if any. The - * data will not be freed as long as the reference count is - * nonzero. + * including the pointer from files_ref_store::packed if any. + * The data will not be freed as long as the reference count + * is nonzero. */ unsigned int referrers; @@ -910,17 +910,17 @@ struct packed_ref_cache { * Future: need to be in "struct repository" * when doing a full libification. */ -static struct ref_cache { - struct ref_cache *next; +static struct files_ref_store { + struct files_ref_store *next; struct ref_entry *loose; struct packed_ref_cache *packed; /* - * The submodule name, or "" for the main repo. We allocate - * length 1 rather than FLEX_ARRAY so that the main ref_cache - * is initialized correctly. + * The submodule name, or "" for the main repo. We allocate + * length 1 rather than FLEX_ARRAY so that the main + * files_ref_store is initialized correctly. */ char name[1]; -} ref_cache, *submodule_ref_caches; +} ref_store, *submodule_ref_stores; /* Lock used for the main packed-refs file: */ static struct lock_file packlock; @@ -949,7 +949,7 @@ static int release_packed_ref_cache(struct packed_ref_cache *packed_refs) } } -static void clear_packed_ref_cache(struct ref_cache *refs) +static void clear_packed_ref_cache(struct files_ref_store *refs) { if (refs->packed) { struct packed_ref_cache *packed_refs = refs->packed; @@ -961,7 +961,7 @@ static void clear_packed_ref_cache(struct ref_cache *refs) } } -static void clear_loose_ref_cache(struct ref_cache *refs) +static void clear_loose_ref_cache(struct files_ref_store *refs) { if (refs->loose) { free_ref_entry(refs->loose); @@ -973,32 +973,32 @@ static void clear_loose_ref_cache(struct ref_cache *refs) * Create a new submodule ref cache and add it to the internal * set of caches. */ -static struct ref_cache *create_ref_cache(const char *submodule) +static struct files_ref_store *create_ref_store(const char *submodule) { - struct ref_cache *refs; + struct files_ref_store *refs; if (!submodule) submodule = ""; FLEX_ALLOC_STR(refs, name, submodule); - refs->next = submodule_ref_caches; - submodule_ref_caches = refs; + refs->next = submodule_ref_stores; + submodule_ref_stores = refs; return refs; } -static struct ref_cache *lookup_ref_cache(const char *submodule) +static struct files_ref_store *lookup_ref_store(const char *submodule) { - struct ref_cache *refs; + struct files_ref_store *refs; if (!submodule || !*submodule) - return &ref_cache; + return &ref_store; - for (refs = submodule_ref_caches; refs; refs = refs->next) + for (refs = submodule_ref_stores; refs; refs = refs->next) if (!strcmp(submodule, refs->name)) return refs; return NULL; } /* - * Return a pointer to a ref_cache for the specified submodule. For + * Return a pointer to a files_ref_store for the specified submodule. For * the main repository, use submodule==NULL; such a call cannot fail. * For a submodule, the submodule must exist and be a nonbare * repository, otherwise return NULL. @@ -1006,16 +1006,16 @@ static struct ref_cache *lookup_ref_cache(const char *submodule) * The returned structure will be allocated and initialized but not * necessarily populated; it should not be freed. */ -static struct ref_cache *get_ref_cache(const char *submodule) +static struct files_ref_store *get_ref_store(const char *submodule) { - struct ref_cache *refs = lookup_ref_cache(submodule); + struct files_ref_store *refs = lookup_ref_store(submodule); if (!refs) { struct strbuf submodule_sb = STRBUF_INIT; strbuf_addstr(&submodule_sb, submodule); if (is_nonbare_repository_dir(&submodule_sb)) - refs = create_ref_cache(submodule); + refs = create_ref_store(submodule); strbuf_release(&submodule_sb); } @@ -1151,10 +1151,10 @@ static void read_packed_refs(FILE *f, struct ref_dir *dir) } /* - * Get the packed_ref_cache for the specified ref_cache, creating it - * if necessary. + * Get the packed_ref_cache for the specified files_ref_store, + * creating it if necessary. */ -static struct packed_ref_cache *get_packed_ref_cache(struct ref_cache *refs) +static struct packed_ref_cache *get_packed_ref_cache(struct files_ref_store *refs) { char *packed_refs_file; @@ -1189,7 +1189,7 @@ static struct ref_dir *get_packed_ref_dir(struct packed_ref_cache *packed_ref_ca return get_ref_dir(packed_ref_cache->root); } -static struct ref_dir *get_packed_refs(struct ref_cache *refs) +static struct ref_dir *get_packed_refs(struct files_ref_store *refs) { return get_packed_ref_dir(get_packed_ref_cache(refs)); } @@ -1203,7 +1203,7 @@ static struct ref_dir *get_packed_refs(struct ref_cache *refs) static void add_packed_ref(const char *refname, const unsigned char *sha1) { struct packed_ref_cache *packed_ref_cache = - get_packed_ref_cache(&ref_cache); + get_packed_ref_cache(&ref_store); if (!packed_ref_cache->lock) die("internal error: packed refs not locked"); @@ -1218,7 +1218,7 @@ static void add_packed_ref(const char *refname, const unsigned char *sha1) */ static void read_loose_refs(const char *dirname, struct ref_dir *dir) { - struct ref_cache *refs = dir->ref_cache; + struct files_ref_store *refs = dir->ref_store; DIR *d; struct dirent *de; int dirnamelen = strlen(dirname); @@ -1306,7 +1306,7 @@ static void read_loose_refs(const char *dirname, struct ref_dir *dir) closedir(d); } -static struct ref_dir *get_loose_refs(struct ref_cache *refs) +static struct ref_dir *get_loose_refs(struct files_ref_store *refs) { if (!refs->loose) { /* @@ -1328,10 +1328,10 @@ static struct ref_dir *get_loose_refs(struct ref_cache *refs) /* * Called by resolve_gitlink_ref_recursive() after it failed to read - * from the loose refs in ref_cache refs. Find in the - * packed-refs file for the submodule. + * from the loose refs in refs. Find in the packed-refs file + * for the submodule. */ -static int resolve_gitlink_packed_ref(struct ref_cache *refs, +static int resolve_gitlink_packed_ref(struct files_ref_store *refs, const char *refname, unsigned char *sha1) { struct ref_entry *ref; @@ -1345,7 +1345,7 @@ static int resolve_gitlink_packed_ref(struct ref_cache *refs, return 0; } -static int resolve_gitlink_ref_recursive(struct ref_cache *refs, +static int resolve_gitlink_ref_recursive(struct files_ref_store *refs, const char *refname, unsigned char *sha1, int recursion) { @@ -1389,7 +1389,7 @@ int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sh { int len = strlen(path); struct strbuf submodule = STRBUF_INIT; - struct ref_cache *refs; + struct files_ref_store *refs; while (len && path[len-1] == '/') len--; @@ -1397,7 +1397,7 @@ int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sh return -1; strbuf_add(&submodule, path, len); - refs = get_ref_cache(submodule.buf); + refs = get_ref_store(submodule.buf); if (!refs) { strbuf_release(&submodule); return -1; @@ -1413,7 +1413,7 @@ int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sh */ static struct ref_entry *get_packed_ref(const char *refname) { - return find_ref(get_packed_refs(&ref_cache), refname); + return find_ref(get_packed_refs(&ref_store), refname); } /* @@ -1745,7 +1745,7 @@ retry: REMOVE_DIR_EMPTY_ONLY)) { if (verify_refname_available_dir( refname, extras, skip, - get_loose_refs(&ref_cache), + get_loose_refs(&ref_store), err)) { /* * The error message set by @@ -1784,7 +1784,7 @@ retry: */ if (verify_refname_available_dir( refname, extras, skip, - get_packed_refs(&ref_cache), + get_packed_refs(&ref_store), err)) { goto error_return; } @@ -1942,7 +1942,7 @@ struct ref_iterator *files_ref_iterator_begin( const char *submodule, const char *prefix, unsigned int flags) { - struct ref_cache *refs = get_ref_cache(submodule); + struct files_ref_store *refs = get_ref_store(submodule); struct ref_dir *loose_dir, *packed_dir; struct ref_iterator *loose_iter, *packed_iter; struct files_ref_iterator *iter; @@ -2096,7 +2096,7 @@ static struct ref_lock *lock_ref_sha1_basic(const char *refname, if (remove_empty_directories(&ref_file)) { last_errno = errno; if (!verify_refname_available_dir(refname, extras, skip, - get_loose_refs(&ref_cache), err)) + get_loose_refs(&ref_store), err)) strbuf_addf(err, "there are still refs under '%s'", refname); goto error_return; @@ -2108,7 +2108,7 @@ static struct ref_lock *lock_ref_sha1_basic(const char *refname, last_errno = errno; if (last_errno != ENOTDIR || !verify_refname_available_dir(refname, extras, skip, - get_loose_refs(&ref_cache), err)) + get_loose_refs(&ref_store), err)) strbuf_addf(err, "unable to resolve reference '%s': %s", refname, strerror(last_errno)); @@ -2123,7 +2123,7 @@ static struct ref_lock *lock_ref_sha1_basic(const char *refname, */ if (is_null_oid(&lock->old_oid) && verify_refname_available_dir(refname, extras, skip, - get_packed_refs(&ref_cache), err)) { + get_packed_refs(&ref_store), err)) { last_errno = ENOTDIR; goto error_return; } @@ -2232,7 +2232,7 @@ static int lock_packed_refs(int flags) * this will automatically invalidate the cache and re-read * the packed-refs file. */ - packed_ref_cache = get_packed_ref_cache(&ref_cache); + packed_ref_cache = get_packed_ref_cache(&ref_store); packed_ref_cache->lock = &packlock; /* Increment the reference count to prevent it from being freed: */ acquire_packed_ref_cache(packed_ref_cache); @@ -2248,7 +2248,7 @@ static int lock_packed_refs(int flags) static int commit_packed_refs(void) { struct packed_ref_cache *packed_ref_cache = - get_packed_ref_cache(&ref_cache); + get_packed_ref_cache(&ref_store); int error = 0; int save_errno = 0; FILE *out; @@ -2282,14 +2282,14 @@ static int commit_packed_refs(void) static void rollback_packed_refs(void) { struct packed_ref_cache *packed_ref_cache = - get_packed_ref_cache(&ref_cache); + get_packed_ref_cache(&ref_store); if (!packed_ref_cache->lock) die("internal error: packed-refs not locked"); rollback_lock_file(packed_ref_cache->lock); packed_ref_cache->lock = NULL; release_packed_ref_cache(packed_ref_cache); - clear_packed_ref_cache(&ref_cache); + clear_packed_ref_cache(&ref_store); } struct ref_to_prune { @@ -2428,9 +2428,9 @@ int pack_refs(unsigned int flags) cbdata.flags = flags; lock_packed_refs(LOCK_DIE_ON_ERROR); - cbdata.packed_refs = get_packed_refs(&ref_cache); + cbdata.packed_refs = get_packed_refs(&ref_store); - do_for_each_entry_in_dir(get_loose_refs(&ref_cache), 0, + do_for_each_entry_in_dir(get_loose_refs(&ref_store), 0, pack_if_possible_fn, &cbdata); if (commit_packed_refs()) @@ -2471,7 +2471,7 @@ static int repack_without_refs(struct string_list *refnames, struct strbuf *err) unable_to_lock_message(git_path("packed-refs"), errno, err); return -1; } - packed = get_packed_refs(&ref_cache); + packed = get_packed_refs(&ref_store); /* Remove refnames from the cache */ for_each_string_list_item(refname, refnames) @@ -2616,8 +2616,8 @@ int verify_refname_available(const char *newname, const struct string_list *skip, struct strbuf *err) { - struct ref_dir *packed_refs = get_packed_refs(&ref_cache); - struct ref_dir *loose_refs = get_loose_refs(&ref_cache); + struct ref_dir *packed_refs = get_packed_refs(&ref_store); + struct ref_dir *loose_refs = get_loose_refs(&ref_store); if (verify_refname_available_dir(newname, extras, skip, packed_refs, err) || @@ -2968,7 +2968,7 @@ static int commit_ref_update(struct ref_lock *lock, const unsigned char *sha1, const char *logmsg, struct strbuf *err) { - clear_loose_ref_cache(&ref_cache); + clear_loose_ref_cache(&ref_store); if (log_ref_write(lock->ref_name, lock->old_oid.hash, sha1, logmsg, 0, err)) { char *old_msg = strbuf_detach(err, NULL); strbuf_addf(err, "cannot update the ref '%s': %s", @@ -3790,7 +3790,7 @@ int ref_transaction_commit(struct ref_transaction *transaction, } } if (update->flags & REF_NEEDS_COMMIT) { - clear_loose_ref_cache(&ref_cache); + clear_loose_ref_cache(&ref_store); if (commit_ref(lock)) { strbuf_addf(err, "couldn't set '%s'", lock->ref_name); unlock_ref(lock); @@ -3823,7 +3823,7 @@ int ref_transaction_commit(struct ref_transaction *transaction, } for_each_string_list_item(ref_to_delete, &refs_to_delete) unlink_or_warn(git_path("logs/%s", ref_to_delete->string)); - clear_loose_ref_cache(&ref_cache); + clear_loose_ref_cache(&ref_store); cleanup: transaction->state = REF_TRANSACTION_CLOSED; -- cgit v1.2.3 From 3dce444f178503bf3da13ade6f79c80d6964d175 Mon Sep 17 00:00:00 2001 From: Ronnie Sahlberg Date: Sun, 4 Sep 2016 18:08:10 +0200 Subject: refs: add a backend method structure Add a `struct ref_storage_be` to represent types of reference stores. In OO notation, this is the class, and will soon hold some class methods (e.g., a factory to create new ref_store instances) and will also serve as the vtable for ref_store instances of that type. As yet, the backends cannot do anything. Signed-off-by: Ronnie Sahlberg Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Jeff King Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 19 +++++++++++++++++++ refs.h | 2 ++ refs/files-backend.c | 5 +++++ refs/refs-internal.h | 8 ++++++++ 4 files changed, 34 insertions(+) diff --git a/refs.c b/refs.c index 256fef5da0..bee9a4571e 100644 --- a/refs.c +++ b/refs.c @@ -9,6 +9,25 @@ #include "object.h" #include "tag.h" +/* + * List of all available backends + */ +static struct ref_storage_be *refs_backends = &refs_be_files; + +static struct ref_storage_be *find_ref_storage_backend(const char *name) +{ + struct ref_storage_be *be; + for (be = refs_backends; be; be = be->next) + if (!strcmp(be->name, name)) + return be; + return NULL; +} + +int ref_storage_backend_exists(const char *name) +{ + return find_ref_storage_backend(name) != NULL; +} + /* * How to handle various characters in refnames: * 0: An acceptable character for refs diff --git a/refs.h b/refs.h index 442c1a5db8..52ea93b8c3 100644 --- a/refs.h +++ b/refs.h @@ -544,4 +544,6 @@ int reflog_expire(const char *refname, const unsigned char *sha1, reflog_expiry_cleanup_fn cleanup_fn, void *policy_cb_data); +int ref_storage_backend_exists(const char *name); + #endif /* REFS_H */ diff --git a/refs/files-backend.c b/refs/files-backend.c index c229b56bd5..0102491b13 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -4066,3 +4066,8 @@ int reflog_expire(const char *refname, const unsigned char *sha1, unlock_ref(lock); return -1; } + +struct ref_storage_be refs_be_files = { + NULL, + "files" +}; diff --git a/refs/refs-internal.h b/refs/refs-internal.h index 0206e2b959..2c9d134021 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -525,4 +525,12 @@ int do_for_each_ref_iterator(struct ref_iterator *iter, int read_raw_ref(const char *refname, unsigned char *sha1, struct strbuf *referent, unsigned int *type); +/* refs backends */ +struct ref_storage_be { + struct ref_storage_be *next; + const char *name; +}; + +extern struct ref_storage_be refs_be_files; + #endif /* REFS_REFS_INTERNAL_H */ -- cgit v1.2.3 From 00eebe351c4b4626a7b8e0b2dc4b7a172f3fd8d9 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:11 +0200 Subject: refs: create a base class "ref_store" for files_ref_store We want ref_stores to be polymorphic, so invent a base class of which files_ref_store is a derived class. For now there is exactly one ref_store for the main repository and one for any submodules whose references have been accessed. Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 93 +++++++++++++++++++++++++++ refs/files-backend.c | 177 ++++++++++++++++++++++++++++----------------------- refs/refs-internal.h | 78 +++++++++++++++++++++++ 3 files changed, 270 insertions(+), 78 deletions(-) diff --git a/refs.c b/refs.c index bee9a4571e..ca57a6e1e5 100644 --- a/refs.c +++ b/refs.c @@ -1151,8 +1151,12 @@ int head_ref(each_ref_fn fn, void *cb_data) static int do_for_each_ref(const char *submodule, const char *prefix, each_ref_fn fn, int trim, int flags, void *cb_data) { + struct ref_store *refs = get_ref_store(submodule); struct ref_iterator *iter; + if (!refs) + return 0; + iter = files_ref_iterator_begin(submodule, prefix, flags); iter = prefix_ref_iterator_begin(iter, prefix, trim); @@ -1284,3 +1288,92 @@ const char *resolve_ref_unsafe(const char *refname, int resolve_flags, errno = ELOOP; return NULL; } + +/* A pointer to the ref_store for the main repository: */ +static struct ref_store *main_ref_store; + +/* A linked list of ref_stores for submodules: */ +static struct ref_store *submodule_ref_stores; + +void base_ref_store_init(struct ref_store *refs, + const struct ref_storage_be *be, + const char *submodule) +{ + refs->be = be; + if (!submodule) { + if (main_ref_store) + die("BUG: main_ref_store initialized twice"); + + refs->submodule = ""; + refs->next = NULL; + main_ref_store = refs; + } else { + if (lookup_ref_store(submodule)) + die("BUG: ref_store for submodule '%s' initialized twice", + submodule); + + refs->submodule = xstrdup(submodule); + refs->next = submodule_ref_stores; + submodule_ref_stores = refs; + } +} + +struct ref_store *ref_store_init(const char *submodule) +{ + const char *be_name = "files"; + struct ref_storage_be *be = find_ref_storage_backend(be_name); + + if (!be) + die("BUG: reference backend %s is unknown", be_name); + + if (!submodule || !*submodule) + return be->init(NULL); + else + return be->init(submodule); +} + +struct ref_store *lookup_ref_store(const char *submodule) +{ + struct ref_store *refs; + + if (!submodule || !*submodule) + return main_ref_store; + + for (refs = submodule_ref_stores; refs; refs = refs->next) { + if (!strcmp(submodule, refs->submodule)) + return refs; + } + + return NULL; +} + +struct ref_store *get_ref_store(const char *submodule) +{ + struct ref_store *refs; + + if (!submodule || !*submodule) { + refs = lookup_ref_store(NULL); + + if (!refs) + refs = ref_store_init(NULL); + } else { + refs = lookup_ref_store(submodule); + + if (!refs) { + struct strbuf submodule_sb = STRBUF_INIT; + + strbuf_addstr(&submodule_sb, submodule); + if (is_nonbare_repository_dir(&submodule_sb)) + refs = ref_store_init(submodule); + strbuf_release(&submodule_sb); + } + } + + return refs; +} + +void assert_main_repository(struct ref_store *refs, const char *caller) +{ + if (*refs->submodule) + die("BUG: %s called for a submodule", caller); +} diff --git a/refs/files-backend.c b/refs/files-backend.c index 0102491b13..c31f9b6f3a 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -910,17 +910,11 @@ struct packed_ref_cache { * Future: need to be in "struct repository" * when doing a full libification. */ -static struct files_ref_store { - struct files_ref_store *next; +struct files_ref_store { + struct ref_store base; struct ref_entry *loose; struct packed_ref_cache *packed; - /* - * The submodule name, or "" for the main repo. We allocate - * length 1 rather than FLEX_ARRAY so that the main - * files_ref_store is initialized correctly. - */ - char name[1]; -} ref_store, *submodule_ref_stores; +}; /* Lock used for the main packed-refs file: */ static struct lock_file packlock; @@ -973,53 +967,50 @@ static void clear_loose_ref_cache(struct files_ref_store *refs) * Create a new submodule ref cache and add it to the internal * set of caches. */ -static struct files_ref_store *create_ref_store(const char *submodule) +static struct ref_store *files_ref_store_create(const char *submodule) { - struct files_ref_store *refs; - if (!submodule) - submodule = ""; - FLEX_ALLOC_STR(refs, name, submodule); - refs->next = submodule_ref_stores; - submodule_ref_stores = refs; - return refs; + struct files_ref_store *refs = xcalloc(1, sizeof(*refs)); + struct ref_store *ref_store = (struct ref_store *)refs; + + base_ref_store_init(ref_store, &refs_be_files, submodule); + + return ref_store; } -static struct files_ref_store *lookup_ref_store(const char *submodule) +/* + * Downcast ref_store to files_ref_store. Die if ref_store is not a + * files_ref_store. If submodule_allowed is not true, then also die if + * files_ref_store is for a submodule (i.e., not for the main + * repository). caller is used in any necessary error messages. + */ +static struct files_ref_store *files_downcast( + struct ref_store *ref_store, int submodule_allowed, + const char *caller) { - struct files_ref_store *refs; + if (ref_store->be != &refs_be_files) + die("BUG: ref_store is type \"%s\" not \"files\" in %s", + ref_store->be->name, caller); - if (!submodule || !*submodule) - return &ref_store; + if (!submodule_allowed) + assert_main_repository(ref_store, caller); - for (refs = submodule_ref_stores; refs; refs = refs->next) - if (!strcmp(submodule, refs->name)) - return refs; - return NULL; + return (struct files_ref_store *)ref_store; } /* - * Return a pointer to a files_ref_store for the specified submodule. For - * the main repository, use submodule==NULL; such a call cannot fail. - * For a submodule, the submodule must exist and be a nonbare - * repository, otherwise return NULL. - * - * The returned structure will be allocated and initialized but not - * necessarily populated; it should not be freed. + * Return a pointer to the reference store for the specified + * submodule. For the main repository, use submodule==NULL; such a + * call cannot fail. For a submodule, the submodule must exist and be + * a nonbare repository, otherwise return NULL. Verify that the + * reference store is a files_ref_store, and cast it to that type + * before returning it. */ -static struct files_ref_store *get_ref_store(const char *submodule) +static struct files_ref_store *get_files_ref_store(const char *submodule, + const char *caller) { - struct files_ref_store *refs = lookup_ref_store(submodule); + struct ref_store *refs = get_ref_store(submodule); - if (!refs) { - struct strbuf submodule_sb = STRBUF_INIT; - - strbuf_addstr(&submodule_sb, submodule); - if (is_nonbare_repository_dir(&submodule_sb)) - refs = create_ref_store(submodule); - strbuf_release(&submodule_sb); - } - - return refs; + return refs ? files_downcast(refs, 1, caller) : NULL; } /* The length of a peeled reference line in packed-refs, including EOL: */ @@ -1158,8 +1149,9 @@ static struct packed_ref_cache *get_packed_ref_cache(struct files_ref_store *ref { char *packed_refs_file; - if (*refs->name) - packed_refs_file = git_pathdup_submodule(refs->name, "packed-refs"); + if (*refs->base.submodule) + packed_refs_file = git_pathdup_submodule(refs->base.submodule, + "packed-refs"); else packed_refs_file = git_pathdup("packed-refs"); @@ -1202,8 +1194,9 @@ static struct ref_dir *get_packed_refs(struct files_ref_store *refs) */ static void add_packed_ref(const char *refname, const unsigned char *sha1) { - struct packed_ref_cache *packed_ref_cache = - get_packed_ref_cache(&ref_store); + struct files_ref_store *refs = + get_files_ref_store(NULL, "add_packed_ref"); + struct packed_ref_cache *packed_ref_cache = get_packed_ref_cache(refs); if (!packed_ref_cache->lock) die("internal error: packed refs not locked"); @@ -1226,8 +1219,8 @@ static void read_loose_refs(const char *dirname, struct ref_dir *dir) struct strbuf path = STRBUF_INIT; size_t path_baselen; - if (*refs->name) - strbuf_git_path_submodule(&path, refs->name, "%s", dirname); + if (*refs->base.submodule) + strbuf_git_path_submodule(&path, refs->base.submodule, "%s", dirname); else strbuf_git_path(&path, "%s", dirname); path_baselen = path.len; @@ -1262,10 +1255,10 @@ static void read_loose_refs(const char *dirname, struct ref_dir *dir) } else { int read_ok; - if (*refs->name) { + if (*refs->base.submodule) { hashclr(sha1); flag = 0; - read_ok = !resolve_gitlink_ref(refs->name, + read_ok = !resolve_gitlink_ref(refs->base.submodule, refname.buf, sha1); } else { read_ok = !read_ref_full(refname.buf, @@ -1355,8 +1348,8 @@ static int resolve_gitlink_ref_recursive(struct files_ref_store *refs, if (recursion > SYMREF_MAXDEPTH || strlen(refname) > MAXREFLEN) return -1; - path = *refs->name - ? git_pathdup_submodule(refs->name, "%s", refname) + path = *refs->base.submodule + ? git_pathdup_submodule(refs->base.submodule, "%s", refname) : git_pathdup("%s", refname); fd = open(path, O_RDONLY); free(path); @@ -1397,7 +1390,7 @@ int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sh return -1; strbuf_add(&submodule, path, len); - refs = get_ref_store(submodule.buf); + refs = get_files_ref_store(submodule.buf, "resolve_gitlink_ref"); if (!refs) { strbuf_release(&submodule); return -1; @@ -1413,7 +1406,10 @@ int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sh */ static struct ref_entry *get_packed_ref(const char *refname) { - return find_ref(get_packed_refs(&ref_store), refname); + struct files_ref_store *refs = + get_files_ref_store(NULL, "get_packed_ref"); + + return find_ref(get_packed_refs(refs), refname); } /* @@ -1613,6 +1609,8 @@ static int lock_raw_ref(const char *refname, int mustexist, unsigned int *type, struct strbuf *err) { + struct files_ref_store *refs = + get_files_ref_store(NULL, "lock_raw_ref"); struct ref_lock *lock; struct strbuf ref_file = STRBUF_INIT; int attempts_remaining = 3; @@ -1745,7 +1743,7 @@ retry: REMOVE_DIR_EMPTY_ONLY)) { if (verify_refname_available_dir( refname, extras, skip, - get_loose_refs(&ref_store), + get_loose_refs(refs), err)) { /* * The error message set by @@ -1784,7 +1782,7 @@ retry: */ if (verify_refname_available_dir( refname, extras, skip, - get_packed_refs(&ref_store), + get_packed_refs(refs), err)) { goto error_return; } @@ -1942,7 +1940,8 @@ struct ref_iterator *files_ref_iterator_begin( const char *submodule, const char *prefix, unsigned int flags) { - struct files_ref_store *refs = get_ref_store(submodule); + struct files_ref_store *refs = + get_files_ref_store(submodule, "ref_iterator_begin"); struct ref_dir *loose_dir, *packed_dir; struct ref_iterator *loose_iter, *packed_iter; struct files_ref_iterator *iter; @@ -2065,6 +2064,8 @@ static struct ref_lock *lock_ref_sha1_basic(const char *refname, unsigned int flags, int *type, struct strbuf *err) { + struct files_ref_store *refs = + get_files_ref_store(NULL, "lock_ref_sha1_basic"); struct strbuf ref_file = STRBUF_INIT; struct ref_lock *lock; int last_errno = 0; @@ -2095,8 +2096,9 @@ static struct ref_lock *lock_ref_sha1_basic(const char *refname, */ if (remove_empty_directories(&ref_file)) { last_errno = errno; - if (!verify_refname_available_dir(refname, extras, skip, - get_loose_refs(&ref_store), err)) + if (!verify_refname_available_dir( + refname, extras, skip, + get_loose_refs(refs), err)) strbuf_addf(err, "there are still refs under '%s'", refname); goto error_return; @@ -2107,8 +2109,9 @@ static struct ref_lock *lock_ref_sha1_basic(const char *refname, if (!resolved) { last_errno = errno; if (last_errno != ENOTDIR || - !verify_refname_available_dir(refname, extras, skip, - get_loose_refs(&ref_store), err)) + !verify_refname_available_dir( + refname, extras, skip, + get_loose_refs(refs), err)) strbuf_addf(err, "unable to resolve reference '%s': %s", refname, strerror(last_errno)); @@ -2123,7 +2126,8 @@ static struct ref_lock *lock_ref_sha1_basic(const char *refname, */ if (is_null_oid(&lock->old_oid) && verify_refname_available_dir(refname, extras, skip, - get_packed_refs(&ref_store), err)) { + get_packed_refs(refs), + err)) { last_errno = ENOTDIR; goto error_return; } @@ -2212,9 +2216,10 @@ static int write_packed_entry_fn(struct ref_entry *entry, void *cb_data) */ static int lock_packed_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; if (!timeout_configured) { @@ -2232,7 +2237,7 @@ static int lock_packed_refs(int flags) * this will automatically invalidate the cache and re-read * the packed-refs file. */ - packed_ref_cache = get_packed_ref_cache(&ref_store); + 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); @@ -2247,8 +2252,10 @@ static int lock_packed_refs(int flags) */ static int commit_packed_refs(void) { + struct files_ref_store *refs = + get_files_ref_store(NULL, "commit_packed_refs"); struct packed_ref_cache *packed_ref_cache = - get_packed_ref_cache(&ref_store); + get_packed_ref_cache(refs); int error = 0; int save_errno = 0; FILE *out; @@ -2281,15 +2288,17 @@ static int commit_packed_refs(void) */ static void rollback_packed_refs(void) { + struct files_ref_store *refs = + get_files_ref_store(NULL, "rollback_packed_refs"); struct packed_ref_cache *packed_ref_cache = - get_packed_ref_cache(&ref_store); + get_packed_ref_cache(refs); if (!packed_ref_cache->lock) die("internal error: packed-refs not locked"); rollback_lock_file(packed_ref_cache->lock); packed_ref_cache->lock = NULL; release_packed_ref_cache(packed_ref_cache); - clear_packed_ref_cache(&ref_store); + clear_packed_ref_cache(refs); } struct ref_to_prune { @@ -2422,15 +2431,17 @@ static void prune_refs(struct ref_to_prune *r) int pack_refs(unsigned int flags) { + struct files_ref_store *refs = + get_files_ref_store(NULL, "pack_refs"); struct pack_refs_cb_data cbdata; memset(&cbdata, 0, sizeof(cbdata)); cbdata.flags = flags; lock_packed_refs(LOCK_DIE_ON_ERROR); - cbdata.packed_refs = get_packed_refs(&ref_store); + cbdata.packed_refs = get_packed_refs(refs); - do_for_each_entry_in_dir(get_loose_refs(&ref_store), 0, + do_for_each_entry_in_dir(get_loose_refs(refs), 0, pack_if_possible_fn, &cbdata); if (commit_packed_refs()) @@ -2449,6 +2460,8 @@ int pack_refs(unsigned int flags) */ static int repack_without_refs(struct string_list *refnames, struct strbuf *err) { + struct files_ref_store *refs = + get_files_ref_store(NULL, "repack_without_refs"); struct ref_dir *packed; struct string_list_item *refname; int ret, needs_repacking = 0, removed = 0; @@ -2471,7 +2484,7 @@ static int repack_without_refs(struct string_list *refnames, struct strbuf *err) unable_to_lock_message(git_path("packed-refs"), errno, err); return -1; } - packed = get_packed_refs(&ref_store); + packed = get_packed_refs(refs); /* Remove refnames from the cache */ for_each_string_list_item(refname, refnames) @@ -2616,8 +2629,10 @@ int verify_refname_available(const char *newname, const struct string_list *skip, struct strbuf *err) { - struct ref_dir *packed_refs = get_packed_refs(&ref_store); - struct ref_dir *loose_refs = get_loose_refs(&ref_store); + struct files_ref_store *refs = + get_files_ref_store(NULL, "verify_refname_available"); + struct ref_dir *packed_refs = get_packed_refs(refs); + struct ref_dir *loose_refs = get_loose_refs(refs); if (verify_refname_available_dir(newname, extras, skip, packed_refs, err) || @@ -2968,7 +2983,10 @@ static int commit_ref_update(struct ref_lock *lock, const unsigned char *sha1, const char *logmsg, struct strbuf *err) { - clear_loose_ref_cache(&ref_store); + struct files_ref_store *refs = + get_files_ref_store(NULL, "commit_ref_update"); + + clear_loose_ref_cache(refs); if (log_ref_write(lock->ref_name, lock->old_oid.hash, sha1, logmsg, 0, err)) { char *old_msg = strbuf_detach(err, NULL); strbuf_addf(err, "cannot update the ref '%s': %s", @@ -3684,6 +3702,8 @@ static int lock_ref_for_update(struct ref_update *update, int ref_transaction_commit(struct ref_transaction *transaction, struct strbuf *err) { + struct files_ref_store *refs = + get_files_ref_store(NULL, "ref_transaction_commit"); int ret = 0, i; struct string_list refs_to_delete = STRING_LIST_INIT_NODUP; struct string_list_item *ref_to_delete; @@ -3790,7 +3810,7 @@ int ref_transaction_commit(struct ref_transaction *transaction, } } if (update->flags & REF_NEEDS_COMMIT) { - clear_loose_ref_cache(&ref_store); + clear_loose_ref_cache(refs); if (commit_ref(lock)) { strbuf_addf(err, "couldn't set '%s'", lock->ref_name); unlock_ref(lock); @@ -3823,7 +3843,7 @@ int ref_transaction_commit(struct ref_transaction *transaction, } for_each_string_list_item(ref_to_delete, &refs_to_delete) unlink_or_warn(git_path("logs/%s", ref_to_delete->string)); - clear_loose_ref_cache(&ref_store); + clear_loose_ref_cache(refs); cleanup: transaction->state = REF_TRANSACTION_CLOSED; @@ -4069,5 +4089,6 @@ int reflog_expire(const char *refname, const unsigned char *sha1, struct ref_storage_be refs_be_files = { NULL, - "files" + "files", + files_ref_store_create }; diff --git a/refs/refs-internal.h b/refs/refs-internal.h index 2c9d134021..b952038bf1 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -526,11 +526,89 @@ int read_raw_ref(const char *refname, unsigned char *sha1, struct strbuf *referent, unsigned int *type); /* refs backends */ + +/* + * Initialize the ref_store for the specified submodule, or for the + * main repository if submodule == NULL. These functions should call + * base_ref_store_init() to initialize the shared part of the + * ref_store and to record the ref_store for later lookup. + */ +typedef struct ref_store *ref_store_init_fn(const char *submodule); + struct ref_storage_be { struct ref_storage_be *next; const char *name; + ref_store_init_fn *init; }; extern struct ref_storage_be refs_be_files; +/* + * A representation of the reference store for the main repository or + * a submodule. The ref_store instances for submodules are kept in a + * linked list. + */ +struct ref_store { + /* The backend describing this ref_store's storage scheme: */ + const struct ref_storage_be *be; + + /* + * The name of the submodule represented by this object, or + * the empty string if it represents the main repository's + * reference store: + */ + const char *submodule; + + /* + * Submodule reference store instances are stored in a linked + * list using this pointer. + */ + struct ref_store *next; +}; + +/* + * Fill in the generic part of refs for the specified submodule and + * add it to our collection of reference stores. + */ +void base_ref_store_init(struct ref_store *refs, + const struct ref_storage_be *be, + const char *submodule); + +/* + * Create, record, and return a ref_store instance for the specified + * submodule (or the main repository if submodule is NULL). + * + * For backwards compatibility, submodule=="" is treated the same as + * submodule==NULL. + */ +struct ref_store *ref_store_init(const char *submodule); + +/* + * Return the ref_store instance for the specified submodule (or the + * main repository if submodule is NULL). If that ref_store hasn't + * been initialized yet, return NULL. + * + * For backwards compatibility, submodule=="" is treated the same as + * submodule==NULL. + */ +struct ref_store *lookup_ref_store(const char *submodule); + +/* + * Return the ref_store instance for the specified submodule. For the + * main repository, use submodule==NULL; such a call cannot fail. For + * a submodule, the submodule must exist and be a nonbare repository, + * otherwise return NULL. If the requested reference store has not yet + * been initialized, initialize it first. + * + * For backwards compatibility, submodule=="" is treated the same as + * submodule==NULL. + */ +struct ref_store *get_ref_store(const char *submodule); + +/* + * Die if refs is for a submodule (i.e., not for the main repository). + * caller is used in any necessary error messages. + */ +void assert_main_repository(struct ref_store *refs, const char *caller); + #endif /* REFS_REFS_INTERNAL_H */ -- cgit v1.2.3 From d99825ab73bbe2ae21e3056ffc1b594800a87cd7 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:12 +0200 Subject: add_packed_ref(): add a files_ref_store argument Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index c31f9b6f3a..08340755d7 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1192,10 +1192,9 @@ static struct ref_dir *get_packed_refs(struct files_ref_store *refs) * lock_packed_refs()). To actually write the packed-refs file, call * commit_packed_refs(). */ -static void add_packed_ref(const char *refname, const unsigned char *sha1) +static void add_packed_ref(struct files_ref_store *refs, + const char *refname, const unsigned char *sha1) { - struct files_ref_store *refs = - get_files_ref_store(NULL, "add_packed_ref"); struct packed_ref_cache *packed_ref_cache = get_packed_ref_cache(refs); if (!packed_ref_cache->lock) @@ -3869,6 +3868,8 @@ static int ref_present(const char *refname, int initial_ref_transaction_commit(struct ref_transaction *transaction, struct strbuf *err) { + struct files_ref_store *refs = + get_files_ref_store(NULL, "initial_ref_transaction_commit"); int ret = 0, i; struct string_list affected_refnames = STRING_LIST_INIT_NODUP; @@ -3928,7 +3929,7 @@ int initial_ref_transaction_commit(struct ref_transaction *transaction, if ((update->flags & REF_HAVE_NEW) && !is_null_sha1(update->new_sha1)) - add_packed_ref(update->refname, update->new_sha1); + add_packed_ref(refs, update->refname, update->new_sha1); } if (commit_packed_refs()) { -- cgit v1.2.3 From f0d21efc3536b369e4a95d78628c19a941381be3 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:13 +0200 Subject: get_packed_ref(): add a files_ref_store argument Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 08340755d7..16d5b9f14b 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1403,11 +1403,9 @@ int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sh * Return the ref_entry for the given refname from the packed * references. If it does not exist, return NULL. */ -static struct ref_entry *get_packed_ref(const char *refname) +static struct ref_entry *get_packed_ref(struct files_ref_store *refs, + const char *refname) { - struct files_ref_store *refs = - get_files_ref_store(NULL, "get_packed_ref"); - return find_ref(get_packed_refs(refs), refname); } @@ -1418,13 +1416,16 @@ static int resolve_missing_loose_ref(const char *refname, unsigned char *sha1, unsigned int *flags) { + struct files_ref_store *refs = + get_files_ref_store(NULL, "resolve_missing_loose_ref"); + struct ref_entry *entry; /* * The loose reference file does not exist; check for a packed * reference. */ - entry = get_packed_ref(refname); + entry = get_packed_ref(refs, refname); if (entry) { hashcpy(sha1, entry->u.value.oid.hash); *flags |= REF_ISPACKED; @@ -1836,6 +1837,7 @@ static enum peel_status peel_entry(struct ref_entry *entry, int repeel) int peel_ref(const char *refname, unsigned char *sha1) { + struct files_ref_store *refs = get_files_ref_store(NULL, "peel_ref"); int flag; unsigned char base[20]; @@ -1860,7 +1862,7 @@ int peel_ref(const char *refname, unsigned char *sha1) * have REF_KNOWS_PEELED. */ if (flag & REF_ISPACKED) { - struct ref_entry *r = get_packed_ref(refname); + struct ref_entry *r = get_packed_ref(refs, refname); if (r) { if (peel_entry(r, 0)) return -1; @@ -2469,7 +2471,7 @@ static int repack_without_refs(struct string_list *refnames, struct strbuf *err) /* Look for a packed ref */ for_each_string_list_item(refname, refnames) { - if (get_packed_ref(refname->string)) { + if (get_packed_ref(refs, refname->string)) { needs_repacking = 1; break; } -- cgit v1.2.3 From 4308651c3cbef316d070e3dbbbf5e53d56a56548 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:14 +0200 Subject: resolve_missing_loose_ref(): add a files_ref_store argument Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 16d5b9f14b..9c81af900c 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1412,13 +1412,11 @@ static struct ref_entry *get_packed_ref(struct files_ref_store *refs, /* * A loose ref file doesn't exist; check for a packed ref. */ -static int resolve_missing_loose_ref(const char *refname, +static int resolve_missing_loose_ref(struct files_ref_store *refs, + const char *refname, unsigned char *sha1, unsigned int *flags) { - struct files_ref_store *refs = - get_files_ref_store(NULL, "resolve_missing_loose_ref"); - struct ref_entry *entry; /* @@ -1438,6 +1436,8 @@ static int resolve_missing_loose_ref(const char *refname, int read_raw_ref(const char *refname, unsigned char *sha1, struct strbuf *referent, unsigned int *type) { + struct files_ref_store *refs = + get_files_ref_store(NULL, "read_raw_ref"); struct strbuf sb_contents = STRBUF_INIT; struct strbuf sb_path = STRBUF_INIT; const char *path; @@ -1466,7 +1466,7 @@ stat_ref: if (lstat(path, &st) < 0) { if (errno != ENOENT) goto out; - if (resolve_missing_loose_ref(refname, sha1, type)) { + if (resolve_missing_loose_ref(refs, refname, sha1, type)) { errno = ENOENT; goto out; } @@ -1500,7 +1500,7 @@ stat_ref: * ref is supposed to be, there could still be a * packed ref: */ - if (resolve_missing_loose_ref(refname, sha1, type)) { + if (resolve_missing_loose_ref(refs, refname, sha1, type)) { errno = EISDIR; goto out; } -- cgit v1.2.3 From 49c0df6a68c6c02a75e306c34e4e9d2bfa645892 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:15 +0200 Subject: {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 Signed-off-by: Junio C Hamano --- refs/files-backend.c | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 9c81af900c..17404413cc 100644 --- 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. */ -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; + assert_main_repository(&refs->base, "lock_packed_refs"); + 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 */ -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; + assert_main_repository(&refs->base, "commit_packed_refs"); + 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.) */ -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); + 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); @@ -2439,13 +2439,13 @@ int pack_refs(unsigned int 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); - if (commit_packed_refs()) + if (commit_packed_refs(refs)) 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 (lock_packed_refs(0)) { + if (lock_packed_refs(refs, 0)) { 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. */ - rollback_packed_refs(); + rollback_packed_refs(refs); 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)); @@ -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; @@ -3934,7 +3934,7 @@ int initial_ref_transaction_commit(struct ref_transaction *transaction, 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; -- cgit v1.2.3 From 127b42a18618538438b811a29cd95e79c646eb70 Mon Sep 17 00:00:00 2001 From: Ronnie Sahlberg Date: Sun, 4 Sep 2016 18:08:16 +0200 Subject: refs: add a transaction_commit() method Signed-off-by: Ronnie Sahlberg Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Jeff King Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 9 +++++++++ refs/files-backend.c | 10 ++++++---- refs/refs-internal.h | 5 +++++ 3 files changed, 20 insertions(+), 4 deletions(-) diff --git a/refs.c b/refs.c index ca57a6e1e5..abccd7ebd7 100644 --- a/refs.c +++ b/refs.c @@ -1377,3 +1377,12 @@ void assert_main_repository(struct ref_store *refs, const char *caller) if (*refs->submodule) die("BUG: %s called for a submodule", caller); } + +/* backend functions */ +int ref_transaction_commit(struct ref_transaction *transaction, + struct strbuf *err) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->transaction_commit(refs, transaction, err); +} diff --git a/refs/files-backend.c b/refs/files-backend.c index 17404413cc..2d847f57e4 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -3700,11 +3700,12 @@ static int lock_ref_for_update(struct ref_update *update, return 0; } -int ref_transaction_commit(struct ref_transaction *transaction, - struct strbuf *err) +static int files_transaction_commit(struct ref_store *ref_store, + struct ref_transaction *transaction, + struct strbuf *err) { struct files_ref_store *refs = - get_files_ref_store(NULL, "ref_transaction_commit"); + files_downcast(ref_store, 0, "ref_transaction_commit"); int ret = 0, i; struct string_list refs_to_delete = STRING_LIST_INIT_NODUP; struct string_list_item *ref_to_delete; @@ -4093,5 +4094,6 @@ int reflog_expire(const char *refname, const unsigned char *sha1, struct ref_storage_be refs_be_files = { NULL, "files", - files_ref_store_create + files_ref_store_create, + files_transaction_commit }; diff --git a/refs/refs-internal.h b/refs/refs-internal.h index b952038bf1..b7367ab4c1 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -535,10 +535,15 @@ int read_raw_ref(const char *refname, unsigned char *sha1, */ typedef struct ref_store *ref_store_init_fn(const char *submodule); +typedef int ref_transaction_commit_fn(struct ref_store *refs, + struct ref_transaction *transaction, + struct strbuf *err); + struct ref_storage_be { struct ref_storage_be *next; const char *name; ref_store_init_fn *init; + ref_transaction_commit_fn *transaction_commit; }; extern struct ref_storage_be refs_be_files; -- cgit v1.2.3 From 6356c658e424dbd45b278f164b0c36a2062a1bcb Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:17 +0200 Subject: refs: reorder definitions Move resolve_gitlink_ref() and related functions lower in the file to avoid the need for forward declarations in the next step. Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 166 +++++++++++++++++++++++++-------------------------- 1 file changed, 83 insertions(+), 83 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 2d847f57e4..748e5cb076 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1316,89 +1316,6 @@ static struct ref_dir *get_loose_refs(struct files_ref_store *refs) return get_ref_dir(refs->loose); } -#define MAXREFLEN (1024) - -/* - * Called by resolve_gitlink_ref_recursive() after it failed to read - * from the loose refs in refs. Find in the packed-refs file - * for the submodule. - */ -static int resolve_gitlink_packed_ref(struct files_ref_store *refs, - const char *refname, unsigned char *sha1) -{ - struct ref_entry *ref; - struct ref_dir *dir = get_packed_refs(refs); - - ref = find_ref(dir, refname); - if (ref == NULL) - return -1; - - hashcpy(sha1, ref->u.value.oid.hash); - return 0; -} - -static int resolve_gitlink_ref_recursive(struct files_ref_store *refs, - const char *refname, unsigned char *sha1, - int recursion) -{ - int fd, len; - char buffer[128], *p; - char *path; - - if (recursion > SYMREF_MAXDEPTH || strlen(refname) > MAXREFLEN) - return -1; - path = *refs->base.submodule - ? git_pathdup_submodule(refs->base.submodule, "%s", refname) - : git_pathdup("%s", refname); - fd = open(path, O_RDONLY); - free(path); - if (fd < 0) - return resolve_gitlink_packed_ref(refs, refname, sha1); - - len = read(fd, buffer, sizeof(buffer)-1); - close(fd); - if (len < 0) - return -1; - while (len && isspace(buffer[len-1])) - len--; - buffer[len] = 0; - - /* Was it a detached head or an old-fashioned symlink? */ - if (!get_sha1_hex(buffer, sha1)) - return 0; - - /* Symref? */ - if (strncmp(buffer, "ref:", 4)) - return -1; - p = buffer + 4; - while (isspace(*p)) - p++; - - return resolve_gitlink_ref_recursive(refs, p, sha1, recursion+1); -} - -int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1) -{ - int len = strlen(path); - struct strbuf submodule = STRBUF_INIT; - struct files_ref_store *refs; - - while (len && path[len-1] == '/') - len--; - if (!len) - return -1; - - strbuf_add(&submodule, path, len); - refs = get_files_ref_store(submodule.buf, "resolve_gitlink_ref"); - if (!refs) { - strbuf_release(&submodule); - return -1; - } - strbuf_release(&submodule); - - return resolve_gitlink_ref_recursive(refs, refname, sha1, 0); -} - /* * Return the ref_entry for the given refname from the packed * references. If it does not exist, return NULL. @@ -1572,6 +1489,89 @@ static void unlock_ref(struct ref_lock *lock) free(lock); } +#define MAXREFLEN (1024) + +/* + * Called by resolve_gitlink_ref_recursive() after it failed to read + * from the loose refs in refs. Find in the packed-refs file + * for the submodule. + */ +static int resolve_gitlink_packed_ref(struct files_ref_store *refs, + const char *refname, unsigned char *sha1) +{ + struct ref_entry *ref; + struct ref_dir *dir = get_packed_refs(refs); + + ref = find_ref(dir, refname); + if (ref == NULL) + return -1; + + hashcpy(sha1, ref->u.value.oid.hash); + return 0; +} + +static int resolve_gitlink_ref_recursive(struct files_ref_store *refs, + const char *refname, unsigned char *sha1, + int recursion) +{ + int fd, len; + char buffer[128], *p; + char *path; + + if (recursion > SYMREF_MAXDEPTH || strlen(refname) > MAXREFLEN) + return -1; + path = *refs->base.submodule + ? git_pathdup_submodule(refs->base.submodule, "%s", refname) + : git_pathdup("%s", refname); + fd = open(path, O_RDONLY); + free(path); + if (fd < 0) + return resolve_gitlink_packed_ref(refs, refname, sha1); + + len = read(fd, buffer, sizeof(buffer)-1); + close(fd); + if (len < 0) + return -1; + while (len && isspace(buffer[len-1])) + len--; + buffer[len] = 0; + + /* Was it a detached head or an old-fashioned symlink? */ + if (!get_sha1_hex(buffer, sha1)) + return 0; + + /* Symref? */ + if (strncmp(buffer, "ref:", 4)) + return -1; + p = buffer + 4; + while (isspace(*p)) + p++; + + return resolve_gitlink_ref_recursive(refs, p, sha1, recursion+1); +} + +int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1) +{ + int len = strlen(path); + struct strbuf submodule = STRBUF_INIT; + struct files_ref_store *refs; + + while (len && path[len-1] == '/') + len--; + if (!len) + return -1; + + strbuf_add(&submodule, path, len); + refs = get_files_ref_store(submodule.buf, "resolve_gitlink_ref"); + if (!refs) { + strbuf_release(&submodule); + return -1; + } + strbuf_release(&submodule); + + return resolve_gitlink_ref_recursive(refs, refname, sha1, 0); +} + /* * Lock refname, without following symrefs, and set *lock_p to point * at a newly-allocated lock object. Fill in lock->old_oid, referent, -- cgit v1.2.3 From 611118d06ebba572424fa39473869eee1a1238fb Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:18 +0200 Subject: resolve_packed_ref(): rename function from resolve_missing_loose_ref() Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 748e5cb076..924bdda193 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1329,10 +1329,9 @@ static struct ref_entry *get_packed_ref(struct files_ref_store *refs, /* * A loose ref file doesn't exist; check for a packed ref. */ -static int resolve_missing_loose_ref(struct files_ref_store *refs, - const char *refname, - unsigned char *sha1, - unsigned int *flags) +static int resolve_packed_ref(struct files_ref_store *refs, + const char *refname, + unsigned char *sha1, unsigned int *flags) { struct ref_entry *entry; @@ -1383,7 +1382,7 @@ stat_ref: if (lstat(path, &st) < 0) { if (errno != ENOENT) goto out; - if (resolve_missing_loose_ref(refs, refname, sha1, type)) { + if (resolve_packed_ref(refs, refname, sha1, type)) { errno = ENOENT; goto out; } @@ -1417,7 +1416,7 @@ stat_ref: * ref is supposed to be, there could still be a * packed ref: */ - if (resolve_missing_loose_ref(refs, refname, sha1, type)) { + if (resolve_packed_ref(refs, refname, sha1, type)) { errno = EISDIR; goto out; } -- cgit v1.2.3 From b9180c9d5d13366e228130eb0d2f1451f2e4dfd6 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:19 +0200 Subject: resolve_gitlink_packed_ref(): remove function Now that resolve_packed_ref() can work with an arbitrary files_ref_store, there is no need to have a separate resolve_gitlink_packed_ref() function. Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 26 +++++--------------------- 1 file changed, 5 insertions(+), 21 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 924bdda193..5a76f893e1 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1490,25 +1490,6 @@ static void unlock_ref(struct ref_lock *lock) #define MAXREFLEN (1024) -/* - * Called by resolve_gitlink_ref_recursive() after it failed to read - * from the loose refs in refs. Find in the packed-refs file - * for the submodule. - */ -static int resolve_gitlink_packed_ref(struct files_ref_store *refs, - const char *refname, unsigned char *sha1) -{ - struct ref_entry *ref; - struct ref_dir *dir = get_packed_refs(refs); - - ref = find_ref(dir, refname); - if (ref == NULL) - return -1; - - hashcpy(sha1, ref->u.value.oid.hash); - return 0; -} - static int resolve_gitlink_ref_recursive(struct files_ref_store *refs, const char *refname, unsigned char *sha1, int recursion) @@ -1524,8 +1505,11 @@ static int resolve_gitlink_ref_recursive(struct files_ref_store *refs, : git_pathdup("%s", refname); fd = open(path, O_RDONLY); free(path); - if (fd < 0) - return resolve_gitlink_packed_ref(refs, refname, sha1); + if (fd < 0) { + unsigned int flags; + + return resolve_packed_ref(refs, refname, sha1, &flags); + } len = read(fd, buffer, sizeof(buffer)-1); close(fd); -- cgit v1.2.3 From 34c7ad8ffc79c64d7f2261e6bcf6efd3adb16e7e Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:20 +0200 Subject: read_raw_ref(): take a (struct ref_store *) argument And make the function work for submodules. Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 4 +++- refs/files-backend.c | 18 +++++++++++++----- refs/refs-internal.h | 9 ++++++--- 3 files changed, 22 insertions(+), 9 deletions(-) diff --git a/refs.c b/refs.c index abccd7ebd7..b3a775e640 100644 --- a/refs.c +++ b/refs.c @@ -1222,6 +1222,7 @@ const char *resolve_ref_unsafe(const char *refname, int resolve_flags, static struct strbuf sb_refname = STRBUF_INIT; int unused_flags; int symref_count; + struct ref_store *refs = get_ref_store(NULL); if (!flags) flags = &unused_flags; @@ -1249,7 +1250,8 @@ const char *resolve_ref_unsafe(const char *refname, int resolve_flags, for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) { unsigned int read_flags = 0; - if (read_raw_ref(refname, sha1, &sb_refname, &read_flags)) { + if (read_raw_ref(refs, refname, + sha1, &sb_refname, &read_flags)) { *flags |= read_flags; if (errno != ENOENT || (resolve_flags & RESOLVE_REF_READING)) return NULL; diff --git a/refs/files-backend.c b/refs/files-backend.c index 5a76f893e1..a743da4c1e 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1349,11 +1349,12 @@ static int resolve_packed_ref(struct files_ref_store *refs, return -1; } -int read_raw_ref(const char *refname, unsigned char *sha1, +int read_raw_ref(struct ref_store *ref_store, + const char *refname, unsigned char *sha1, struct strbuf *referent, unsigned int *type) { struct files_ref_store *refs = - get_files_ref_store(NULL, "read_raw_ref"); + files_downcast(ref_store, 1, "read_raw_ref"); struct strbuf sb_contents = STRBUF_INIT; struct strbuf sb_path = STRBUF_INIT; const char *path; @@ -1365,7 +1366,12 @@ int read_raw_ref(const char *refname, unsigned char *sha1, *type = 0; strbuf_reset(&sb_path); - strbuf_git_path(&sb_path, "%s", refname); + + if (*refs->base.submodule) + strbuf_git_path_submodule(&sb_path, refs->base.submodule, "%s", refname); + else + strbuf_git_path(&sb_path, "%s", refname); + path = sb_path.buf; stat_ref: @@ -1592,8 +1598,9 @@ static int lock_raw_ref(const char *refname, int mustexist, unsigned int *type, struct strbuf *err) { + struct ref_store *ref_store = get_ref_store(NULL); struct files_ref_store *refs = - get_files_ref_store(NULL, "lock_raw_ref"); + files_downcast(ref_store, 0, "lock_raw_ref"); struct ref_lock *lock; struct strbuf ref_file = STRBUF_INIT; int attempts_remaining = 3; @@ -1683,7 +1690,8 @@ retry: * fear that its value will change. */ - if (read_raw_ref(refname, lock->old_oid.hash, referent, type)) { + if (read_raw_ref(ref_store, refname, + lock->old_oid.hash, referent, type)) { if (errno == ENOENT) { if (mustexist) { /* Garden variety missing reference. */ diff --git a/refs/refs-internal.h b/refs/refs-internal.h index b7367ab4c1..fa41d510c2 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -484,9 +484,11 @@ extern struct ref_iterator *current_ref_iter; int do_for_each_ref_iterator(struct ref_iterator *iter, each_ref_fn fn, void *cb_data); +struct ref_store; + /* - * Read the specified reference from the filesystem or packed refs - * file, non-recursively. Set type to describe the reference, and: + * Read a reference from the specified reference store, non-recursively. + * Set type to describe the reference, and: * * - If refname is the name of a normal reference, fill in sha1 * (leaving referent unchanged). @@ -522,7 +524,8 @@ int do_for_each_ref_iterator(struct ref_iterator *iter, * - in all other cases, referent will be untouched, and therefore * refname will still be valid and unchanged. */ -int read_raw_ref(const char *refname, unsigned char *sha1, +int read_raw_ref(struct ref_store *ref_store, + const char *refname, unsigned char *sha1, struct strbuf *referent, unsigned int *type); /* refs backends */ -- cgit v1.2.3 From bd40dcda27cc7d6b8b247caa5b650992c5e397fb Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:21 +0200 Subject: resolve_ref_recursively(): new function Add a new function, resolve_ref_recursively(), which is basically like the old resolve_ref_unsafe() except that it takes a (ref_store *) argument and also works for submodules. Re-implement resolve_ref_unsafe() as a thin wrapper around resolve_ref_recursively(). Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/refs.c b/refs.c index b3a775e640..464fe71928 100644 --- a/refs.c +++ b/refs.c @@ -1216,13 +1216,14 @@ int for_each_rawref(each_ref_fn fn, void *cb_data) } /* This function needs to return a meaningful errno on failure */ -const char *resolve_ref_unsafe(const char *refname, int resolve_flags, - unsigned char *sha1, int *flags) +static const char *resolve_ref_recursively(struct ref_store *refs, + const char *refname, + int resolve_flags, + unsigned char *sha1, int *flags) { static struct strbuf sb_refname = STRBUF_INIT; int unused_flags; int symref_count; - struct ref_store *refs = get_ref_store(NULL); if (!flags) flags = &unused_flags; @@ -1291,6 +1292,13 @@ const char *resolve_ref_unsafe(const char *refname, int resolve_flags, return NULL; } +const char *resolve_ref_unsafe(const char *refname, int resolve_flags, + unsigned char *sha1, int *flags) +{ + return resolve_ref_recursively(get_ref_store(NULL), refname, + resolve_flags, sha1, flags); +} + /* A pointer to the ref_store for the main repository: */ static struct ref_store *main_ref_store; -- cgit v1.2.3 From 424dcc7683a37d1f14aa0dd485300001cb854f6c Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:22 +0200 Subject: resolve_gitlink_ref(): implement using resolve_ref_recursively() resolve_ref_recursively() can handle references in arbitrary files reference stores, so use it to resolve "gitlink" (i.e., submodule) references. Aside from removing redundant code, this allows submodule lookups to benefit from the much more robust code that we use for reading non-submodule references. And, since the code is now agnostic about reference backends, it will work for any future references backend (so move its definition to refs.c). Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 24 +++++++++++++++++++ refs/files-backend.c | 67 ---------------------------------------------------- 2 files changed, 24 insertions(+), 67 deletions(-) diff --git a/refs.c b/refs.c index 464fe71928..7b86b4eab5 100644 --- a/refs.c +++ b/refs.c @@ -1299,6 +1299,30 @@ const char *resolve_ref_unsafe(const char *refname, int resolve_flags, resolve_flags, sha1, flags); } +int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1) +{ + int len = strlen(path); + struct strbuf submodule = STRBUF_INIT; + struct ref_store *refs; + int flags; + + while (len && path[len-1] == '/') + len--; + if (!len) + return -1; + + strbuf_add(&submodule, path, len); + refs = get_ref_store(submodule.buf); + strbuf_release(&submodule); + if (!refs) + return -1; + + if (!resolve_ref_recursively(refs, refname, 0, sha1, &flags) || + is_null_sha1(sha1)) + return -1; + return 0; +} + /* A pointer to the ref_store for the main repository: */ static struct ref_store *main_ref_store; diff --git a/refs/files-backend.c b/refs/files-backend.c index a743da4c1e..979cee884a 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1494,73 +1494,6 @@ static void unlock_ref(struct ref_lock *lock) free(lock); } -#define MAXREFLEN (1024) - -static int resolve_gitlink_ref_recursive(struct files_ref_store *refs, - const char *refname, unsigned char *sha1, - int recursion) -{ - int fd, len; - char buffer[128], *p; - char *path; - - if (recursion > SYMREF_MAXDEPTH || strlen(refname) > MAXREFLEN) - return -1; - path = *refs->base.submodule - ? git_pathdup_submodule(refs->base.submodule, "%s", refname) - : git_pathdup("%s", refname); - fd = open(path, O_RDONLY); - free(path); - if (fd < 0) { - unsigned int flags; - - return resolve_packed_ref(refs, refname, sha1, &flags); - } - - len = read(fd, buffer, sizeof(buffer)-1); - close(fd); - if (len < 0) - return -1; - while (len && isspace(buffer[len-1])) - len--; - buffer[len] = 0; - - /* Was it a detached head or an old-fashioned symlink? */ - if (!get_sha1_hex(buffer, sha1)) - return 0; - - /* Symref? */ - if (strncmp(buffer, "ref:", 4)) - return -1; - p = buffer + 4; - while (isspace(*p)) - p++; - - return resolve_gitlink_ref_recursive(refs, p, sha1, recursion+1); -} - -int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1) -{ - int len = strlen(path); - struct strbuf submodule = STRBUF_INIT; - struct files_ref_store *refs; - - while (len && path[len-1] == '/') - len--; - if (!len) - return -1; - - strbuf_add(&submodule, path, len); - refs = get_files_ref_store(submodule.buf, "resolve_gitlink_ref"); - if (!refs) { - strbuf_release(&submodule); - return -1; - } - strbuf_release(&submodule); - - return resolve_gitlink_ref_recursive(refs, refname, sha1, 0); -} - /* * Lock refname, without following symrefs, and set *lock_p to point * at a newly-allocated lock object. Fill in lock->old_oid, referent, -- cgit v1.2.3 From 48a8475fd3f935d753cc2e0dd81562bc73f6d6d3 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:23 +0200 Subject: resolve_gitlink_ref(): avoid memory allocation in many cases If we don't have to strip trailing '/' from the submodule path, then don't allocate and copy the submodule name. Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/refs.c b/refs.c index 7b86b4eab5..17f3497a0b 100644 --- a/refs.c +++ b/refs.c @@ -1301,19 +1301,26 @@ const char *resolve_ref_unsafe(const char *refname, int resolve_flags, int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1) { - int len = strlen(path); - struct strbuf submodule = STRBUF_INIT; + size_t len = strlen(path); struct ref_store *refs; int flags; - while (len && path[len-1] == '/') + while (len && path[len - 1] == '/') len--; + if (!len) return -1; - strbuf_add(&submodule, path, len); - refs = get_ref_store(submodule.buf); - strbuf_release(&submodule); + if (path[len]) { + /* We need to strip off one or more trailing slashes */ + char *stripped = xmemdupz(path, len); + + refs = get_ref_store(stripped); + free(stripped); + } else { + refs = get_ref_store(path); + } + if (!refs) return -1; -- cgit v1.2.3 From a8355bb717aaf2d5d9b3781aa78402d0053fa87a Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:24 +0200 Subject: resolve_gitlink_ref(): rename path parameter to submodule Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 13 +++++++------ refs.h | 9 +++++---- 2 files changed, 12 insertions(+), 10 deletions(-) diff --git a/refs.c b/refs.c index 17f3497a0b..1a2a2bbbe7 100644 --- a/refs.c +++ b/refs.c @@ -1299,26 +1299,27 @@ const char *resolve_ref_unsafe(const char *refname, int resolve_flags, resolve_flags, sha1, flags); } -int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1) +int resolve_gitlink_ref(const char *submodule, const char *refname, + unsigned char *sha1) { - size_t len = strlen(path); + size_t len = strlen(submodule); struct ref_store *refs; int flags; - while (len && path[len - 1] == '/') + while (len && submodule[len - 1] == '/') len--; if (!len) return -1; - if (path[len]) { + if (submodule[len]) { /* We need to strip off one or more trailing slashes */ - char *stripped = xmemdupz(path, len); + char *stripped = xmemdupz(submodule, len); refs = get_ref_store(stripped); free(stripped); } else { - refs = get_ref_store(path); + refs = get_ref_store(submodule); } if (!refs) diff --git a/refs.h b/refs.h index 52ea93b8c3..132dcef5af 100644 --- a/refs.h +++ b/refs.h @@ -77,11 +77,12 @@ int is_branch(const char *refname); int peel_ref(const char *refname, unsigned char *sha1); /** - * Resolve refname in the nested "gitlink" repository that is located - * at path. If the resolution is successful, return 0 and set sha1 to - * the name of the object; otherwise, return a non-zero value. + * Resolve refname in the nested "gitlink" repository in the specified + * submodule (which must be non-NULL). If the resolution is + * successful, return 0 and set sha1 to the name of the object; + * otherwise, return a non-zero value. */ -int resolve_gitlink_ref(const char *path, const char *refname, +int resolve_gitlink_ref(const char *submodule, const char *refname, unsigned char *sha1); /* -- cgit v1.2.3 From e1e33b722c50c26546335fd5a709f89726c2ea2a Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:25 +0200 Subject: refs: make read_raw_ref() virtual Reference backends will be able to customize this function to implement reference reading. Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 4 ++-- refs/files-backend.c | 14 ++++++++------ refs/refs-internal.h | 36 +++++++++++++++++++----------------- 3 files changed, 29 insertions(+), 25 deletions(-) diff --git a/refs.c b/refs.c index 1a2a2bbbe7..775c54eb47 100644 --- a/refs.c +++ b/refs.c @@ -1251,8 +1251,8 @@ static const char *resolve_ref_recursively(struct ref_store *refs, for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) { unsigned int read_flags = 0; - if (read_raw_ref(refs, refname, - sha1, &sb_refname, &read_flags)) { + if (refs->be->read_raw_ref(refs, refname, + sha1, &sb_refname, &read_flags)) { *flags |= read_flags; if (errno != ENOENT || (resolve_flags & RESOLVE_REF_READING)) return NULL; diff --git a/refs/files-backend.c b/refs/files-backend.c index 979cee884a..9cf2f82f74 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1349,9 +1349,9 @@ static int resolve_packed_ref(struct files_ref_store *refs, return -1; } -int read_raw_ref(struct ref_store *ref_store, - const char *refname, unsigned char *sha1, - struct strbuf *referent, unsigned int *type) +static int files_read_raw_ref(struct ref_store *ref_store, + const char *refname, unsigned char *sha1, + struct strbuf *referent, unsigned int *type) { struct files_ref_store *refs = files_downcast(ref_store, 1, "read_raw_ref"); @@ -1623,8 +1623,8 @@ retry: * fear that its value will change. */ - if (read_raw_ref(ref_store, refname, - lock->old_oid.hash, referent, type)) { + if (files_read_raw_ref(ref_store, refname, + lock->old_oid.hash, referent, type)) { if (errno == ENOENT) { if (mustexist) { /* Garden variety missing reference. */ @@ -4019,5 +4019,7 @@ struct ref_storage_be refs_be_files = { NULL, "files", files_ref_store_create, - files_transaction_commit + files_transaction_commit, + + files_read_raw_ref }; diff --git a/refs/refs-internal.h b/refs/refs-internal.h index fa41d510c2..19cb6e11ad 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -486,6 +486,20 @@ int do_for_each_ref_iterator(struct ref_iterator *iter, struct ref_store; +/* refs backends */ + +/* + * Initialize the ref_store for the specified submodule, or for the + * main repository if submodule == NULL. These functions should call + * base_ref_store_init() to initialize the shared part of the + * ref_store and to record the ref_store for later lookup. + */ +typedef struct ref_store *ref_store_init_fn(const char *submodule); + +typedef int ref_transaction_commit_fn(struct ref_store *refs, + struct ref_transaction *transaction, + struct strbuf *err); + /* * Read a reference from the specified reference store, non-recursively. * Set type to describe the reference, and: @@ -524,29 +538,17 @@ struct ref_store; * - in all other cases, referent will be untouched, and therefore * refname will still be valid and unchanged. */ -int read_raw_ref(struct ref_store *ref_store, - const char *refname, unsigned char *sha1, - struct strbuf *referent, unsigned int *type); - -/* refs backends */ - -/* - * Initialize the ref_store for the specified submodule, or for the - * main repository if submodule == NULL. These functions should call - * base_ref_store_init() to initialize the shared part of the - * ref_store and to record the ref_store for later lookup. - */ -typedef struct ref_store *ref_store_init_fn(const char *submodule); - -typedef int ref_transaction_commit_fn(struct ref_store *refs, - struct ref_transaction *transaction, - struct strbuf *err); +typedef int read_raw_ref_fn(struct ref_store *ref_store, + const char *refname, unsigned char *sha1, + struct strbuf *referent, unsigned int *type); struct ref_storage_be { struct ref_storage_be *next; const char *name; ref_store_init_fn *init; ref_transaction_commit_fn *transaction_commit; + + read_raw_ref_fn *read_raw_ref; }; extern struct ref_storage_be refs_be_files; -- cgit v1.2.3 From 62665823d2ddbe69abdac4a9db399769c3e278b4 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:26 +0200 Subject: refs: make verify_refname_available() virtual Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 10 ++++++++++ refs/files-backend.c | 14 ++++++++------ refs/refs-internal.h | 7 +++++++ 3 files changed, 25 insertions(+), 6 deletions(-) diff --git a/refs.c b/refs.c index 775c54eb47..a5c11088f2 100644 --- a/refs.c +++ b/refs.c @@ -1428,3 +1428,13 @@ int ref_transaction_commit(struct ref_transaction *transaction, return refs->be->transaction_commit(refs, transaction, err); } + +int verify_refname_available(const char *refname, + const struct string_list *extra, + const struct string_list *skip, + struct strbuf *err) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->verify_refname_available(refs, refname, extra, skip, err); +} diff --git a/refs/files-backend.c b/refs/files-backend.c index 9cf2f82f74..44eef1cec7 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -2549,13 +2549,14 @@ out: return ret; } -int verify_refname_available(const char *newname, - const struct string_list *extras, - const struct string_list *skip, - struct strbuf *err) +static int files_verify_refname_available(struct ref_store *ref_store, + const char *newname, + const struct string_list *extras, + const struct string_list *skip, + struct strbuf *err) { struct files_ref_store *refs = - get_files_ref_store(NULL, "verify_refname_available"); + files_downcast(ref_store, 1, "verify_refname_available"); struct ref_dir *packed_refs = get_packed_refs(refs); struct ref_dir *loose_refs = get_loose_refs(refs); @@ -4021,5 +4022,6 @@ struct ref_storage_be refs_be_files = { files_ref_store_create, files_transaction_commit, - files_read_raw_ref + files_read_raw_ref, + files_verify_refname_available }; diff --git a/refs/refs-internal.h b/refs/refs-internal.h index 19cb6e11ad..6c698f442d 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -542,6 +542,12 @@ typedef int read_raw_ref_fn(struct ref_store *ref_store, const char *refname, unsigned char *sha1, struct strbuf *referent, unsigned int *type); +typedef int verify_refname_available_fn(struct ref_store *ref_store, + const char *newname, + const struct string_list *extras, + const struct string_list *skip, + struct strbuf *err); + struct ref_storage_be { struct ref_storage_be *next; const char *name; @@ -549,6 +555,7 @@ struct ref_storage_be { ref_transaction_commit_fn *transaction_commit; read_raw_ref_fn *read_raw_ref; + verify_refname_available_fn *verify_refname_available; }; extern struct ref_storage_be refs_be_files; -- cgit v1.2.3 From 8231527e1510127a5611a2e2f9660e6aef1c981e Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:27 +0200 Subject: refs: make pack_refs() virtual Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 7 +++++++ refs/files-backend.c | 6 ++++-- refs/refs-internal.h | 4 ++++ 3 files changed, 15 insertions(+), 2 deletions(-) diff --git a/refs.c b/refs.c index a5c11088f2..cdd78b97ac 100644 --- a/refs.c +++ b/refs.c @@ -1421,6 +1421,13 @@ void assert_main_repository(struct ref_store *refs, const char *caller) } /* backend functions */ +int pack_refs(unsigned int flags) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->pack_refs(refs, flags); +} + int ref_transaction_commit(struct ref_transaction *transaction, struct strbuf *err) { diff --git a/refs/files-backend.c b/refs/files-backend.c index 44eef1cec7..5ba2804a86 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -2354,10 +2354,10 @@ static void prune_refs(struct ref_to_prune *r) } } -int pack_refs(unsigned int flags) +static int files_pack_refs(struct ref_store *ref_store, unsigned int flags) { struct files_ref_store *refs = - get_files_ref_store(NULL, "pack_refs"); + files_downcast(ref_store, 0, "pack_refs"); struct pack_refs_cb_data cbdata; memset(&cbdata, 0, sizeof(cbdata)); @@ -4022,6 +4022,8 @@ struct ref_storage_be refs_be_files = { files_ref_store_create, files_transaction_commit, + files_pack_refs, + files_read_raw_ref, files_verify_refname_available }; diff --git a/refs/refs-internal.h b/refs/refs-internal.h index 6c698f442d..256f7f581f 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -500,6 +500,8 @@ typedef int ref_transaction_commit_fn(struct ref_store *refs, struct ref_transaction *transaction, struct strbuf *err); +typedef int pack_refs_fn(struct ref_store *ref_store, unsigned int flags); + /* * Read a reference from the specified reference store, non-recursively. * Set type to describe the reference, and: @@ -554,6 +556,8 @@ struct ref_storage_be { ref_store_init_fn *init; ref_transaction_commit_fn *transaction_commit; + pack_refs_fn *pack_refs; + read_raw_ref_fn *read_raw_ref; verify_refname_available_fn *verify_refname_available; }; -- cgit v1.2.3 From 284689ba0ff7506d581bcee7481a2621492135ef Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:28 +0200 Subject: refs: make create_symref() virtual Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 9 +++++++++ refs/files-backend.c | 7 ++++++- refs/refs-internal.h | 5 +++++ 3 files changed, 20 insertions(+), 1 deletion(-) diff --git a/refs.c b/refs.c index cdd78b97ac..312c76619f 100644 --- a/refs.c +++ b/refs.c @@ -1428,6 +1428,15 @@ int pack_refs(unsigned int flags) return refs->be->pack_refs(refs, flags); } +int create_symref(const char *ref_target, const char *refs_heads_master, + const char *logmsg) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->create_symref(refs, ref_target, refs_heads_master, + logmsg); +} + int ref_transaction_commit(struct ref_transaction *transaction, struct strbuf *err) { diff --git a/refs/files-backend.c b/refs/files-backend.c index 5ba2804a86..fc67cc6ec7 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -3011,12 +3011,16 @@ static int create_symref_locked(struct ref_lock *lock, const char *refname, return 0; } -int create_symref(const char *refname, const char *target, const char *logmsg) +static int files_create_symref(struct ref_store *ref_store, + const char *refname, const char *target, + const char *logmsg) { struct strbuf err = STRBUF_INIT; struct ref_lock *lock; int ret; + files_downcast(ref_store, 0, "create_symref"); + lock = lock_ref_sha1_basic(refname, NULL, NULL, NULL, REF_NODEREF, NULL, &err); if (!lock) { @@ -4023,6 +4027,7 @@ struct ref_storage_be refs_be_files = { files_transaction_commit, files_pack_refs, + files_create_symref, files_read_raw_ref, files_verify_refname_available diff --git a/refs/refs-internal.h b/refs/refs-internal.h index 256f7f581f..bf96503856 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -501,6 +501,10 @@ typedef int ref_transaction_commit_fn(struct ref_store *refs, struct strbuf *err); typedef int pack_refs_fn(struct ref_store *ref_store, unsigned int flags); +typedef int create_symref_fn(struct ref_store *ref_store, + const char *ref_target, + const char *refs_heads_master, + const char *logmsg); /* * Read a reference from the specified reference store, non-recursively. @@ -557,6 +561,7 @@ struct ref_storage_be { ref_transaction_commit_fn *transaction_commit; pack_refs_fn *pack_refs; + create_symref_fn *create_symref; read_raw_ref_fn *read_raw_ref; verify_refname_available_fn *verify_refname_available; -- cgit v1.2.3 From bd427cf27f561174fa8fa14e2c8c321d2df82c47 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:29 +0200 Subject: refs: make peel_ref() virtual For now it only supports the main reference store. Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 7 +++++++ refs/files-backend.c | 6 ++++-- refs/refs-internal.h | 3 +++ 3 files changed, 14 insertions(+), 2 deletions(-) diff --git a/refs.c b/refs.c index 312c76619f..3130c0e019 100644 --- a/refs.c +++ b/refs.c @@ -1428,6 +1428,13 @@ int pack_refs(unsigned int flags) return refs->be->pack_refs(refs, flags); } +int peel_ref(const char *refname, unsigned char *sha1) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->peel_ref(refs, refname, sha1); +} + int create_symref(const char *ref_target, const char *refs_heads_master, const char *logmsg) { diff --git a/refs/files-backend.c b/refs/files-backend.c index fc67cc6ec7..af3ad83fe5 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1759,9 +1759,10 @@ static enum peel_status peel_entry(struct ref_entry *entry, int repeel) return status; } -int peel_ref(const char *refname, unsigned char *sha1) +static int files_peel_ref(struct ref_store *ref_store, + const char *refname, unsigned char *sha1) { - struct files_ref_store *refs = get_files_ref_store(NULL, "peel_ref"); + struct files_ref_store *refs = files_downcast(ref_store, 0, "peel_ref"); int flag; unsigned char base[20]; @@ -4027,6 +4028,7 @@ struct ref_storage_be refs_be_files = { files_transaction_commit, files_pack_refs, + files_peel_ref, files_create_symref, files_read_raw_ref, diff --git a/refs/refs-internal.h b/refs/refs-internal.h index bf96503856..84c81ad08e 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -501,6 +501,8 @@ typedef int ref_transaction_commit_fn(struct ref_store *refs, struct strbuf *err); typedef int pack_refs_fn(struct ref_store *ref_store, unsigned int flags); +typedef int peel_ref_fn(struct ref_store *ref_store, + const char *refname, unsigned char *sha1); typedef int create_symref_fn(struct ref_store *ref_store, const char *ref_target, const char *refs_heads_master, @@ -561,6 +563,7 @@ struct ref_storage_be { ref_transaction_commit_fn *transaction_commit; pack_refs_fn *pack_refs; + peel_ref_fn *peel_ref; create_symref_fn *create_symref; read_raw_ref_fn *read_raw_ref; -- cgit v1.2.3 From 0a95ac5f630c01ba8a50b72cae9e067cb256cb0f Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:30 +0200 Subject: repack_without_refs(): add a files_ref_store argument Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index af3ad83fe5..af711f6f3d 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -2384,14 +2384,14 @@ static int files_pack_refs(struct ref_store *ref_store, unsigned int flags) * * The refs in 'refnames' needn't be sorted. `err` must not be NULL. */ -static int repack_without_refs(struct string_list *refnames, struct strbuf *err) +static int repack_without_refs(struct files_ref_store *refs, + struct string_list *refnames, struct strbuf *err) { - struct files_ref_store *refs = - get_files_ref_store(NULL, "repack_without_refs"); struct ref_dir *packed; struct string_list_item *refname; int ret, needs_repacking = 0, removed = 0; + assert_main_repository(&refs->base, "repack_without_refs"); assert(err); /* Look for a packed ref */ @@ -2453,13 +2453,15 @@ static int delete_ref_loose(struct ref_lock *lock, int flag, struct strbuf *err) int delete_refs(struct string_list *refnames, unsigned int flags) { + struct files_ref_store *refs = + get_files_ref_store(NULL, "delete_refs"); struct strbuf err = STRBUF_INIT; int i, result = 0; if (!refnames->nr) return 0; - result = repack_without_refs(refnames, &err); + result = repack_without_refs(refs, refnames, &err); if (result) { /* * If we failed to rewrite the packed-refs file, then @@ -3769,7 +3771,7 @@ static int files_transaction_commit(struct ref_store *ref_store, } } - if (repack_without_refs(&refs_to_delete, err)) { + if (repack_without_refs(refs, &refs_to_delete, err)) { ret = TRANSACTION_GENERIC_ERROR; goto cleanup; } -- cgit v1.2.3 From f7b0a987b564b356ffcf7eb62fa33b200cbd5b87 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:31 +0200 Subject: lock_raw_ref(): add a files_ref_store argument Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index af711f6f3d..4f4ab0fd09 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1523,7 +1523,8 @@ static void unlock_ref(struct ref_lock *lock) * avoided, namely if we were successfully able to read the ref * - Generate informative error messages in the case of failure */ -static int lock_raw_ref(const char *refname, int mustexist, +static int lock_raw_ref(struct files_ref_store *refs, + const char *refname, int mustexist, const struct string_list *extras, const struct string_list *skip, struct ref_lock **lock_p, @@ -1531,15 +1532,14 @@ static int lock_raw_ref(const char *refname, int mustexist, unsigned int *type, struct strbuf *err) { - struct ref_store *ref_store = get_ref_store(NULL); - struct files_ref_store *refs = - files_downcast(ref_store, 0, "lock_raw_ref"); struct ref_lock *lock; struct strbuf ref_file = STRBUF_INIT; int attempts_remaining = 3; int ret = TRANSACTION_GENERIC_ERROR; assert(err); + assert_main_repository(&refs->base, "lock_raw_ref"); + *type = 0; /* First lock the file so it can't change out from under us. */ @@ -1623,7 +1623,7 @@ retry: * fear that its value will change. */ - if (files_read_raw_ref(ref_store, refname, + if (files_read_raw_ref(&refs->base, refname, lock->old_oid.hash, referent, type)) { if (errno == ENOENT) { if (mustexist) { @@ -3486,6 +3486,8 @@ static int lock_ref_for_update(struct ref_update *update, struct string_list *affected_refnames, struct strbuf *err) { + struct files_ref_store *refs = + get_files_ref_store(NULL, "lock_ref_for_update"); struct strbuf referent = STRBUF_INIT; int mustexist = (update->flags & REF_HAVE_OLD) && !is_null_sha1(update->old_sha1); @@ -3502,7 +3504,7 @@ static int lock_ref_for_update(struct ref_update *update, return ret; } - ret = lock_raw_ref(update->refname, mustexist, + ret = lock_raw_ref(refs, update->refname, mustexist, affected_refnames, NULL, &update->lock, &referent, &update->type, err); -- cgit v1.2.3 From f18a7892500d494b96c992084951fa85dec4abc2 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:32 +0200 Subject: commit_ref_update(): add a files_ref_store argument Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 4f4ab0fd09..82d9148b82 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -2574,12 +2574,14 @@ static int files_verify_refname_available(struct ref_store *ref_store, static int write_ref_to_lockfile(struct ref_lock *lock, const unsigned char *sha1, struct strbuf *err); -static int commit_ref_update(struct ref_lock *lock, +static int commit_ref_update(struct files_ref_store *refs, + struct ref_lock *lock, const unsigned char *sha1, const char *logmsg, struct strbuf *err); int rename_ref(const char *oldrefname, const char *newrefname, const char *logmsg) { + struct files_ref_store *refs = get_files_ref_store(NULL, "rename_ref"); unsigned char sha1[20], orig_sha1[20]; int flag = 0, logmoved = 0; struct ref_lock *lock; @@ -2652,7 +2654,7 @@ int rename_ref(const char *oldrefname, const char *newrefname, const char *logms hashcpy(lock->old_oid.hash, orig_sha1); if (write_ref_to_lockfile(lock, orig_sha1, &err) || - commit_ref_update(lock, orig_sha1, logmsg, &err)) { + commit_ref_update(refs, lock, orig_sha1, logmsg, &err)) { error("unable to write current sha1 into %s: %s", newrefname, err.buf); strbuf_release(&err); goto rollback; @@ -2672,7 +2674,7 @@ int rename_ref(const char *oldrefname, const char *newrefname, const char *logms flag = log_all_ref_updates; log_all_ref_updates = 0; if (write_ref_to_lockfile(lock, orig_sha1, &err) || - commit_ref_update(lock, orig_sha1, NULL, &err)) { + commit_ref_update(refs, lock, orig_sha1, NULL, &err)) { error("unable to write current sha1 into %s: %s", oldrefname, err.buf); strbuf_release(&err); } @@ -2908,12 +2910,12 @@ static int write_ref_to_lockfile(struct ref_lock *lock, * to the loose reference lockfile. Also update the reflogs if * necessary, using the specified lockmsg (which can be NULL). */ -static int commit_ref_update(struct ref_lock *lock, +static int commit_ref_update(struct files_ref_store *refs, + struct ref_lock *lock, const unsigned char *sha1, const char *logmsg, struct strbuf *err) { - struct files_ref_store *refs = - get_files_ref_store(NULL, "commit_ref_update"); + assert_main_repository(&refs->base, "commit_ref_update"); clear_loose_ref_cache(refs); if (log_ref_write(lock->ref_name, lock->old_oid.hash, sha1, logmsg, 0, err)) { -- cgit v1.2.3 From b3bbbc5c245b2599f3b53122f2bb57a054027413 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:33 +0200 Subject: lock_ref_for_update(): add a files_ref_store argument Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 82d9148b82..7e869ba037 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -3482,20 +3482,21 @@ static const char *original_update_refname(struct ref_update *update) * - If it is an update of head_ref, add a corresponding REF_LOG_ONLY * update of HEAD. */ -static int lock_ref_for_update(struct ref_update *update, +static int lock_ref_for_update(struct files_ref_store *refs, + struct ref_update *update, struct ref_transaction *transaction, const char *head_ref, struct string_list *affected_refnames, struct strbuf *err) { - struct files_ref_store *refs = - get_files_ref_store(NULL, "lock_ref_for_update"); struct strbuf referent = STRBUF_INIT; int mustexist = (update->flags & REF_HAVE_OLD) && !is_null_sha1(update->old_sha1); int ret; struct ref_lock *lock; + assert_main_repository(&refs->base, "lock_ref_for_update"); + if ((update->flags & REF_HAVE_NEW) && is_null_sha1(update->new_sha1)) update->flags |= REF_DELETING; @@ -3720,8 +3721,8 @@ static int files_transaction_commit(struct ref_store *ref_store, for (i = 0; i < transaction->nr; i++) { struct ref_update *update = transaction->updates[i]; - ret = lock_ref_for_update(update, transaction, head_ref, - &affected_refnames, err); + ret = lock_ref_for_update(refs, update, transaction, + head_ref, &affected_refnames, err); if (ret) goto cleanup; } -- cgit v1.2.3 From 7eb27cdfe67f07bcfcd7781bed8110e8ae70d001 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:34 +0200 Subject: lock_ref_sha1_basic(): add a files_ref_store argument Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 26 +++++++++++++++----------- 1 file changed, 15 insertions(+), 11 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 7e869ba037..396647b396 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1983,15 +1983,14 @@ static int remove_empty_directories(struct strbuf *path) * Locks a ref returning the lock on success and NULL on failure. * On failure errno is set to something meaningful. */ -static struct ref_lock *lock_ref_sha1_basic(const char *refname, +static struct ref_lock *lock_ref_sha1_basic(struct files_ref_store *refs, + const char *refname, const unsigned char *old_sha1, const struct string_list *extras, const struct string_list *skip, unsigned int flags, int *type, struct strbuf *err) { - struct files_ref_store *refs = - get_files_ref_store(NULL, "lock_ref_sha1_basic"); struct strbuf ref_file = STRBUF_INIT; struct ref_lock *lock; int last_errno = 0; @@ -2001,6 +2000,7 @@ static struct ref_lock *lock_ref_sha1_basic(const char *refname, int attempts_remaining = 3; int resolved; + assert_main_repository(&refs->base, "lock_ref_sha1_basic"); assert(err); lock = xcalloc(1, sizeof(struct ref_lock)); @@ -2644,8 +2644,8 @@ int rename_ref(const char *oldrefname, const char *newrefname, const char *logms logmoved = log; - lock = lock_ref_sha1_basic(newrefname, NULL, NULL, NULL, REF_NODEREF, - NULL, &err); + lock = lock_ref_sha1_basic(refs, newrefname, NULL, NULL, NULL, + REF_NODEREF, NULL, &err); if (!lock) { error("unable to rename '%s' to '%s': %s", oldrefname, newrefname, err.buf); strbuf_release(&err); @@ -2663,8 +2663,8 @@ int rename_ref(const char *oldrefname, const char *newrefname, const char *logms return 0; rollback: - lock = lock_ref_sha1_basic(oldrefname, NULL, NULL, NULL, REF_NODEREF, - NULL, &err); + lock = lock_ref_sha1_basic(refs, oldrefname, NULL, NULL, NULL, + REF_NODEREF, NULL, &err); if (!lock) { error("unable to lock %s for rollback: %s", oldrefname, err.buf); strbuf_release(&err); @@ -3020,13 +3020,14 @@ static int files_create_symref(struct ref_store *ref_store, const char *refname, const char *target, const char *logmsg) { + struct files_ref_store *refs = + files_downcast(ref_store, 0, "create_symref"); struct strbuf err = STRBUF_INIT; struct ref_lock *lock; int ret; - files_downcast(ref_store, 0, "create_symref"); - - lock = lock_ref_sha1_basic(refname, NULL, NULL, NULL, REF_NODEREF, NULL, + lock = lock_ref_sha1_basic(refs, refname, NULL, + NULL, NULL, REF_NODEREF, NULL, &err); if (!lock) { error("%s", err.buf); @@ -3929,6 +3930,8 @@ int reflog_expire(const char *refname, const unsigned char *sha1, reflog_expiry_cleanup_fn cleanup_fn, void *policy_cb_data) { + struct files_ref_store *refs = + get_files_ref_store(NULL, "reflog_expire"); static struct lock_file reflog_lock; struct expire_reflog_cb cb; struct ref_lock *lock; @@ -3947,7 +3950,8 @@ int reflog_expire(const char *refname, const unsigned char *sha1, * reference itself, plus we might need to update the * reference if --updateref was specified: */ - lock = lock_ref_sha1_basic(refname, sha1, NULL, NULL, REF_NODEREF, + lock = lock_ref_sha1_basic(refs, refname, sha1, + NULL, NULL, REF_NODEREF, &type, &err); if (!lock) { error("cannot lock ref '%s': %s", refname, err.buf); -- cgit v1.2.3 From fcc42ea0c92e357da40f7cbc598152e2f8dfe083 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:35 +0200 Subject: split_symref_update(): add a files_ref_store argument Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 396647b396..9607fbd17a 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -3401,7 +3401,8 @@ static int split_head_update(struct ref_update *update, * Note that the new update will itself be subject to splitting when * the iteration gets to it. */ -static int split_symref_update(struct ref_update *update, +static int split_symref_update(struct files_ref_store *refs, + struct ref_update *update, const char *referent, struct ref_transaction *transaction, struct string_list *affected_refnames, @@ -3562,7 +3563,8 @@ static int lock_ref_for_update(struct files_ref_store *refs, * of processing the split-off update, so we * don't have to do it here. */ - ret = split_symref_update(update, referent.buf, transaction, + ret = split_symref_update(refs, update, + referent.buf, transaction, affected_refnames, err); if (ret) return ret; -- cgit v1.2.3 From 37b6f6d5f41c493bc083b5ee4c54519f8dd6d46c Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:36 +0200 Subject: files_ref_iterator_begin(): take a ref_store argument Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 2 +- refs/files-backend.c | 4 ++-- refs/refs-internal.h | 8 ++++---- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/refs.c b/refs.c index 3130c0e019..3d007ba022 100644 --- a/refs.c +++ b/refs.c @@ -1157,7 +1157,7 @@ static int do_for_each_ref(const char *submodule, const char *prefix, if (!refs) return 0; - iter = files_ref_iterator_begin(submodule, prefix, flags); + iter = files_ref_iterator_begin(refs, prefix, flags); iter = prefix_ref_iterator_begin(iter, prefix, trim); return do_for_each_ref_iterator(iter, fn, cb_data); diff --git a/refs/files-backend.c b/refs/files-backend.c index 9607fbd17a..4918469f34 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1863,11 +1863,11 @@ static struct ref_iterator_vtable files_ref_iterator_vtable = { }; struct ref_iterator *files_ref_iterator_begin( - const char *submodule, + struct ref_store *ref_store, const char *prefix, unsigned int flags) { struct files_ref_store *refs = - get_files_ref_store(submodule, "ref_iterator_begin"); + files_downcast(ref_store, 1, "ref_iterator_begin"); struct ref_dir *loose_dir, *packed_dir; struct ref_iterator *loose_iter, *packed_iter; struct files_ref_iterator *iter; diff --git a/refs/refs-internal.h b/refs/refs-internal.h index 84c81ad08e..0af1079713 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -404,13 +404,15 @@ struct ref_iterator *prefix_ref_iterator_begin(struct ref_iterator *iter0, const char *prefix, int trim); +struct ref_store; + /* * Iterate over the packed and loose references in the specified - * submodule that are within find_containing_dir(prefix). If prefix is + * ref_store that are within find_containing_dir(prefix). If prefix is * NULL or the empty string, iterate over all references in the * submodule. */ -struct ref_iterator *files_ref_iterator_begin(const char *submodule, +struct ref_iterator *files_ref_iterator_begin(struct ref_store *ref_store, const char *prefix, unsigned int flags); @@ -484,8 +486,6 @@ extern struct ref_iterator *current_ref_iter; int do_for_each_ref_iterator(struct ref_iterator *iter, each_ref_fn fn, void *cb_data); -struct ref_store; - /* refs backends */ /* -- cgit v1.2.3 From 1a769003c19c106063f4bf474b0d7ef56be8df25 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:37 +0200 Subject: refs: add method iterator_begin Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 2 +- refs/files-backend.c | 3 ++- refs/refs-internal.h | 24 ++++++++++++------------ 3 files changed, 15 insertions(+), 14 deletions(-) diff --git a/refs.c b/refs.c index 3d007ba022..91174e60f7 100644 --- a/refs.c +++ b/refs.c @@ -1157,7 +1157,7 @@ static int do_for_each_ref(const char *submodule, const char *prefix, if (!refs) return 0; - iter = files_ref_iterator_begin(refs, prefix, flags); + iter = refs->be->iterator_begin(refs, prefix, flags); iter = prefix_ref_iterator_begin(iter, prefix, trim); return do_for_each_ref_iterator(iter, fn, cb_data); diff --git a/refs/files-backend.c b/refs/files-backend.c index 4918469f34..2cda511352 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1862,7 +1862,7 @@ static struct ref_iterator_vtable files_ref_iterator_vtable = { files_ref_iterator_abort }; -struct ref_iterator *files_ref_iterator_begin( +static struct ref_iterator *files_ref_iterator_begin( struct ref_store *ref_store, const char *prefix, unsigned int flags) { @@ -4044,6 +4044,7 @@ struct ref_storage_be refs_be_files = { files_peel_ref, files_create_symref, + files_ref_iterator_begin, files_read_raw_ref, files_verify_refname_available }; diff --git a/refs/refs-internal.h b/refs/refs-internal.h index 0af1079713..5be62a296a 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -404,18 +404,6 @@ struct ref_iterator *prefix_ref_iterator_begin(struct ref_iterator *iter0, const char *prefix, int trim); -struct ref_store; - -/* - * Iterate over the packed and loose references in the specified - * ref_store that are within find_containing_dir(prefix). If prefix is - * NULL or the empty string, iterate over all references in the - * submodule. - */ -struct ref_iterator *files_ref_iterator_begin(struct ref_store *ref_store, - const char *prefix, - unsigned int flags); - /* * Iterate over the references in the main ref_store that have a * reflog. The paths within a directory are iterated over in arbitrary @@ -488,6 +476,8 @@ int do_for_each_ref_iterator(struct ref_iterator *iter, /* refs backends */ +struct ref_store; + /* * Initialize the ref_store for the specified submodule, or for the * main repository if submodule == NULL. These functions should call @@ -508,6 +498,15 @@ typedef int create_symref_fn(struct ref_store *ref_store, const char *refs_heads_master, const char *logmsg); +/* + * Iterate over the references in the specified ref_store that are + * within find_containing_dir(prefix). If prefix is NULL or the empty + * string, iterate over all references in the submodule. + */ +typedef struct ref_iterator *ref_iterator_begin_fn( + struct ref_store *ref_store, + const char *prefix, unsigned int flags); + /* * Read a reference from the specified reference store, non-recursively. * Set type to describe the reference, and: @@ -566,6 +565,7 @@ struct ref_storage_be { peel_ref_fn *peel_ref; create_symref_fn *create_symref; + ref_iterator_begin_fn *iterator_begin; read_raw_ref_fn *read_raw_ref; verify_refname_available_fn *verify_refname_available; }; -- cgit v1.2.3 From e3688bd6cf159f6026a6bca7a6f53d0a22fe21a2 Mon Sep 17 00:00:00 2001 From: David Turner Date: Sun, 4 Sep 2016 18:08:38 +0200 Subject: refs: add methods for reflog In the file-based backend, the reflog piggybacks on the ref lock. Since other backends won't have the same sort of ref lock, ref backends must also handle reflogs. Signed-off-by: Ronnie Sahlberg Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 63 ++++++++++++++++++++++++++++++++++++++++++++++ refs/files-backend.c | 70 +++++++++++++++++++++++++++++++++++++--------------- refs/refs-internal.h | 44 +++++++++++++++++++++++++++------ 3 files changed, 150 insertions(+), 27 deletions(-) diff --git a/refs.c b/refs.c index 91174e60f7..47dcf494d4 100644 --- a/refs.c +++ b/refs.c @@ -1461,3 +1461,66 @@ int verify_refname_available(const char *refname, return refs->be->verify_refname_available(refs, refname, extra, skip, err); } + +int for_each_reflog(each_ref_fn fn, void *cb_data) +{ + struct ref_store *refs = get_ref_store(NULL); + struct ref_iterator *iter; + + iter = refs->be->reflog_iterator_begin(refs); + + return do_for_each_ref_iterator(iter, fn, cb_data); +} + +int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, + void *cb_data) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->for_each_reflog_ent_reverse(refs, refname, + fn, cb_data); +} + +int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, + void *cb_data) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data); +} + +int reflog_exists(const char *refname) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->reflog_exists(refs, refname); +} + +int safe_create_reflog(const char *refname, int force_create, + struct strbuf *err) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->create_reflog(refs, refname, force_create, err); +} + +int delete_reflog(const char *refname) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->delete_reflog(refs, refname); +} + +int reflog_expire(const char *refname, const unsigned char *sha1, + unsigned int flags, + reflog_expiry_prepare_fn prepare_fn, + reflog_expiry_should_prune_fn should_prune_fn, + reflog_expiry_cleanup_fn cleanup_fn, + void *policy_cb_data) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->reflog_expire(refs, refname, sha1, flags, + prepare_fn, should_prune_fn, + cleanup_fn, policy_cb_data); +} diff --git a/refs/files-backend.c b/refs/files-backend.c index 2cda511352..336d432572 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -2777,11 +2777,16 @@ static int log_ref_setup(const char *refname, struct strbuf *logfile, struct str } -int safe_create_reflog(const char *refname, int force_create, struct strbuf *err) +static int files_create_reflog(struct ref_store *ref_store, + const char *refname, int force_create, + struct strbuf *err) { int ret; struct strbuf sb = STRBUF_INIT; + /* Check validity (but we don't need the result): */ + files_downcast(ref_store, 0, "create_reflog"); + ret = log_ref_setup(refname, &sb, err, force_create); strbuf_release(&sb); return ret; @@ -3075,16 +3080,24 @@ int set_worktree_head_symref(const char *gitdir, const char *target) return ret; } -int reflog_exists(const char *refname) +static int files_reflog_exists(struct ref_store *ref_store, + const char *refname) { struct stat st; + /* Check validity (but we don't need the result): */ + files_downcast(ref_store, 0, "reflog_exists"); + return !lstat(git_path("logs/%s", refname), &st) && S_ISREG(st.st_mode); } -int delete_reflog(const char *refname) +static int files_delete_reflog(struct ref_store *ref_store, + const char *refname) { + /* Check validity (but we don't need the result): */ + files_downcast(ref_store, 0, "delete_reflog"); + return remove_path(git_path("logs/%s", refname)); } @@ -3127,13 +3140,19 @@ static char *find_beginning_of_line(char *bob, char *scan) return scan; } -int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, void *cb_data) +static int files_for_each_reflog_ent_reverse(struct ref_store *ref_store, + const char *refname, + each_reflog_ent_fn fn, + void *cb_data) { struct strbuf sb = STRBUF_INIT; FILE *logfp; long pos; int ret = 0, at_tail = 1; + /* Check validity (but we don't need the result): */ + files_downcast(ref_store, 0, "for_each_reflog_ent_reverse"); + logfp = fopen(git_path("logs/%s", refname), "r"); if (!logfp) return -1; @@ -3229,12 +3248,17 @@ int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, void return ret; } -int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, void *cb_data) +static int files_for_each_reflog_ent(struct ref_store *ref_store, + const char *refname, + each_reflog_ent_fn fn, void *cb_data) { FILE *logfp; struct strbuf sb = STRBUF_INIT; int ret = 0; + /* Check validity (but we don't need the result): */ + files_downcast(ref_store, 0, "for_each_reflog_ent"); + logfp = fopen(git_path("logs/%s", refname), "r"); if (!logfp) return -1; @@ -3313,22 +3337,19 @@ static struct ref_iterator_vtable files_reflog_iterator_vtable = { files_reflog_iterator_abort }; -struct ref_iterator *files_reflog_iterator_begin(void) +static struct ref_iterator *files_reflog_iterator_begin(struct ref_store *ref_store) { struct files_reflog_iterator *iter = xcalloc(1, sizeof(*iter)); struct ref_iterator *ref_iterator = &iter->base; + /* Check validity (but we don't need the result): */ + files_downcast(ref_store, 0, "reflog_iterator_begin"); + base_ref_iterator_init(ref_iterator, &files_reflog_iterator_vtable); iter->dir_iterator = dir_iterator_begin(git_path("logs")); return ref_iterator; } -int for_each_reflog(each_ref_fn fn, void *cb_data) -{ - return do_for_each_ref_iterator(files_reflog_iterator_begin(), - fn, cb_data); -} - static int ref_update_reject_duplicates(struct string_list *refnames, struct strbuf *err) { @@ -3925,15 +3946,16 @@ static int expire_reflog_ent(unsigned char *osha1, unsigned char *nsha1, return 0; } -int reflog_expire(const char *refname, const unsigned char *sha1, - unsigned int flags, - reflog_expiry_prepare_fn prepare_fn, - reflog_expiry_should_prune_fn should_prune_fn, - reflog_expiry_cleanup_fn cleanup_fn, - void *policy_cb_data) +static int files_reflog_expire(struct ref_store *ref_store, + const char *refname, const unsigned char *sha1, + unsigned int flags, + reflog_expiry_prepare_fn prepare_fn, + reflog_expiry_should_prune_fn should_prune_fn, + reflog_expiry_cleanup_fn cleanup_fn, + void *policy_cb_data) { struct files_ref_store *refs = - get_files_ref_store(NULL, "reflog_expire"); + files_downcast(ref_store, 0, "reflog_expire"); static struct lock_file reflog_lock; struct expire_reflog_cb cb; struct ref_lock *lock; @@ -4046,5 +4068,13 @@ struct ref_storage_be refs_be_files = { files_ref_iterator_begin, files_read_raw_ref, - files_verify_refname_available + files_verify_refname_available, + + files_reflog_iterator_begin, + files_for_each_reflog_ent, + files_for_each_reflog_ent_reverse, + files_reflog_exists, + files_create_reflog, + files_delete_reflog, + files_reflog_expire }; diff --git a/refs/refs-internal.h b/refs/refs-internal.h index 5be62a296a..a20b62261f 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -404,13 +404,6 @@ struct ref_iterator *prefix_ref_iterator_begin(struct ref_iterator *iter0, const char *prefix, int trim); -/* - * Iterate over the references in the main ref_store that have a - * reflog. The paths within a directory are iterated over in arbitrary - * order. - */ -struct ref_iterator *files_reflog_iterator_begin(void); - /* Internal implementation of reference iteration: */ /* @@ -507,6 +500,35 @@ typedef struct ref_iterator *ref_iterator_begin_fn( struct ref_store *ref_store, const char *prefix, unsigned int flags); +/* reflog functions */ + +/* + * Iterate over the references in the specified ref_store that have a + * reflog. The refs are iterated over in arbitrary order. + */ +typedef struct ref_iterator *reflog_iterator_begin_fn( + struct ref_store *ref_store); + +typedef int for_each_reflog_ent_fn(struct ref_store *ref_store, + const char *refname, + each_reflog_ent_fn fn, + void *cb_data); +typedef int for_each_reflog_ent_reverse_fn(struct ref_store *ref_store, + const char *refname, + each_reflog_ent_fn fn, + void *cb_data); +typedef int reflog_exists_fn(struct ref_store *ref_store, const char *refname); +typedef int create_reflog_fn(struct ref_store *ref_store, const char *refname, + int force_create, struct strbuf *err); +typedef int delete_reflog_fn(struct ref_store *ref_store, const char *refname); +typedef int reflog_expire_fn(struct ref_store *ref_store, + const char *refname, const unsigned char *sha1, + unsigned int flags, + reflog_expiry_prepare_fn prepare_fn, + reflog_expiry_should_prune_fn should_prune_fn, + reflog_expiry_cleanup_fn cleanup_fn, + void *policy_cb_data); + /* * Read a reference from the specified reference store, non-recursively. * Set type to describe the reference, and: @@ -568,6 +590,14 @@ struct ref_storage_be { ref_iterator_begin_fn *iterator_begin; read_raw_ref_fn *read_raw_ref; verify_refname_available_fn *verify_refname_available; + + reflog_iterator_begin_fn *reflog_iterator_begin; + for_each_reflog_ent_fn *for_each_reflog_ent; + for_each_reflog_ent_reverse_fn *for_each_reflog_ent_reverse; + reflog_exists_fn *reflog_exists; + create_reflog_fn *create_reflog; + delete_reflog_fn *delete_reflog; + reflog_expire_fn *reflog_expire; }; extern struct ref_storage_be refs_be_files; -- cgit v1.2.3 From fc6814637d2e756029b45cb5fd952359bfec6f88 Mon Sep 17 00:00:00 2001 From: David Turner Date: Sun, 4 Sep 2016 18:08:39 +0200 Subject: refs: add method for initial ref transaction commit Signed-off-by: Ronnie Sahlberg Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 8 ++++++++ refs/files-backend.c | 8 +++++--- refs/refs-internal.h | 1 + 3 files changed, 14 insertions(+), 3 deletions(-) diff --git a/refs.c b/refs.c index 47dcf494d4..693d10fba7 100644 --- a/refs.c +++ b/refs.c @@ -1524,3 +1524,11 @@ int reflog_expire(const char *refname, const unsigned char *sha1, prepare_fn, should_prune_fn, cleanup_fn, policy_cb_data); } + +int initial_ref_transaction_commit(struct ref_transaction *transaction, + struct strbuf *err) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->initial_transaction_commit(refs, transaction, err); +} diff --git a/refs/files-backend.c b/refs/files-backend.c index 336d432572..0a511bf5a4 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -3829,11 +3829,12 @@ static int ref_present(const char *refname, return string_list_has_string(affected_refnames, refname); } -int initial_ref_transaction_commit(struct ref_transaction *transaction, - struct strbuf *err) +static int files_initial_transaction_commit(struct ref_store *ref_store, + struct ref_transaction *transaction, + struct strbuf *err) { struct files_ref_store *refs = - get_files_ref_store(NULL, "initial_ref_transaction_commit"); + files_downcast(ref_store, 0, "initial_ref_transaction_commit"); int ret = 0, i; struct string_list affected_refnames = STRING_LIST_INIT_NODUP; @@ -4061,6 +4062,7 @@ struct ref_storage_be refs_be_files = { "files", files_ref_store_create, files_transaction_commit, + files_initial_transaction_commit, files_pack_refs, files_peel_ref, diff --git a/refs/refs-internal.h b/refs/refs-internal.h index a20b62261f..08c85861ec 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -582,6 +582,7 @@ struct ref_storage_be { const char *name; ref_store_init_fn *init; ref_transaction_commit_fn *transaction_commit; + ref_transaction_commit_fn *initial_transaction_commit; pack_refs_fn *pack_refs; peel_ref_fn *peel_ref; -- cgit v1.2.3 From a27dcf89b6867577bb714e181dd181cd1a1e6512 Mon Sep 17 00:00:00 2001 From: David Turner Date: Sun, 4 Sep 2016 18:08:40 +0200 Subject: refs: make delete_refs() virtual In the file-based backend, delete_refs has some special optimization to deal with packed refs. In other backends, we might be able to make ref deletion faster by putting all deletions into a single transaction. So we need a special backend function for this. Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 7 +++++++ refs/files-backend.c | 6 ++++-- refs/refs-internal.h | 3 +++ 3 files changed, 14 insertions(+), 2 deletions(-) diff --git a/refs.c b/refs.c index 693d10fba7..f26601dc0c 100644 --- a/refs.c +++ b/refs.c @@ -1532,3 +1532,10 @@ int initial_ref_transaction_commit(struct ref_transaction *transaction, return refs->be->initial_transaction_commit(refs, transaction, err); } + +int delete_refs(struct string_list *refnames, unsigned int flags) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->delete_refs(refs, refnames, flags); +} diff --git a/refs/files-backend.c b/refs/files-backend.c index 0a511bf5a4..33ec530384 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -2451,10 +2451,11 @@ static int delete_ref_loose(struct ref_lock *lock, int flag, struct strbuf *err) return 0; } -int delete_refs(struct string_list *refnames, unsigned int flags) +static int files_delete_refs(struct ref_store *ref_store, + struct string_list *refnames, unsigned int flags) { struct files_ref_store *refs = - get_files_ref_store(NULL, "delete_refs"); + files_downcast(ref_store, 0, "delete_refs"); struct strbuf err = STRBUF_INIT; int i, result = 0; @@ -4067,6 +4068,7 @@ struct ref_storage_be refs_be_files = { files_pack_refs, files_peel_ref, files_create_symref, + files_delete_refs, files_ref_iterator_begin, files_read_raw_ref, diff --git a/refs/refs-internal.h b/refs/refs-internal.h index 08c85861ec..ade65010d4 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -490,6 +490,8 @@ typedef int create_symref_fn(struct ref_store *ref_store, const char *ref_target, const char *refs_heads_master, const char *logmsg); +typedef int delete_refs_fn(struct ref_store *ref_store, + struct string_list *refnames, unsigned int flags); /* * Iterate over the references in the specified ref_store that are @@ -587,6 +589,7 @@ struct ref_storage_be { pack_refs_fn *pack_refs; peel_ref_fn *peel_ref; create_symref_fn *create_symref; + delete_refs_fn *delete_refs; ref_iterator_begin_fn *iterator_begin; read_raw_ref_fn *read_raw_ref; -- cgit v1.2.3 From 6fb5acfd8f7102f53dedc887233313f233a65932 Mon Sep 17 00:00:00 2001 From: David Turner Date: Sun, 4 Sep 2016 18:08:41 +0200 Subject: refs: add methods to init refs db Alternate refs backends might not need the refs/heads directory and so on, so we make ref db initialization part of the backend. Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- builtin/init-db.c | 21 +++++++++++---------- refs.c | 8 ++++++++ refs.h | 2 ++ refs/files-backend.c | 18 ++++++++++++++++++ refs/refs-internal.h | 3 +++ 5 files changed, 42 insertions(+), 10 deletions(-) diff --git a/builtin/init-db.c b/builtin/init-db.c index b2d8d40a67..082fa9f3ca 100644 --- a/builtin/init-db.c +++ b/builtin/init-db.c @@ -180,13 +180,7 @@ static int create_default_files(const char *template_path) char junk[2]; int reinit; int filemode; - - /* - * Create .git/refs/{heads,tags} - */ - safe_create_dir(git_path_buf(&buf, "refs"), 1); - safe_create_dir(git_path_buf(&buf, "refs/heads"), 1); - safe_create_dir(git_path_buf(&buf, "refs/tags"), 1); + struct strbuf err = STRBUF_INIT; /* Just look for `init.templatedir` */ git_config(git_init_db_config, NULL); @@ -210,11 +204,18 @@ static int create_default_files(const char *template_path) */ if (get_shared_repository()) { adjust_shared_perm(get_git_dir()); - adjust_shared_perm(git_path_buf(&buf, "refs")); - adjust_shared_perm(git_path_buf(&buf, "refs/heads")); - adjust_shared_perm(git_path_buf(&buf, "refs/tags")); } + /* + * We need to create a "refs" dir in any case so that older + * versions of git can tell that this is a repository. + */ + safe_create_dir(git_path("refs"), 1); + adjust_shared_perm(git_path("refs")); + + if (refs_init_db(&err)) + die("failed to set up refs db: %s", err.buf); + /* * Create the default symlink from ".git/HEAD" to the "master" * branch, if it does not exist yet. diff --git a/refs.c b/refs.c index f26601dc0c..3b0a658c56 100644 --- a/refs.c +++ b/refs.c @@ -1292,6 +1292,14 @@ static const char *resolve_ref_recursively(struct ref_store *refs, return NULL; } +/* backend functions */ +int refs_init_db(struct strbuf *err) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->init_db(refs, err); +} + const char *resolve_ref_unsafe(const char *refname, int resolve_flags, unsigned char *sha1, int *flags) { diff --git a/refs.h b/refs.h index 132dcef5af..20fae94d7d 100644 --- a/refs.h +++ b/refs.h @@ -66,6 +66,8 @@ int ref_exists(const char *refname); int is_branch(const char *refname); +extern int refs_init_db(struct strbuf *err); + /* * If refname is a non-symbolic reference that refers to a tag object, * and the tag can be (recursively) dereferenced to a non-tag object, diff --git a/refs/files-backend.c b/refs/files-backend.c index 33ec530384..40e789611c 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -4058,10 +4058,28 @@ static int files_reflog_expire(struct ref_store *ref_store, return -1; } +static int files_init_db(struct ref_store *ref_store, struct strbuf *err) +{ + /* Check validity (but we don't need the result): */ + files_downcast(ref_store, 0, "init_db"); + + /* + * Create .git/refs/{heads,tags} + */ + safe_create_dir(git_path("refs/heads"), 1); + safe_create_dir(git_path("refs/tags"), 1); + if (get_shared_repository()) { + adjust_shared_perm(git_path("refs/heads")); + adjust_shared_perm(git_path("refs/tags")); + } + return 0; +} + struct ref_storage_be refs_be_files = { NULL, "files", files_ref_store_create, + files_init_db, files_transaction_commit, files_initial_transaction_commit, diff --git a/refs/refs-internal.h b/refs/refs-internal.h index ade65010d4..b3a20955c3 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -479,6 +479,8 @@ struct ref_store; */ typedef struct ref_store *ref_store_init_fn(const char *submodule); +typedef int ref_init_db_fn(struct ref_store *refs, struct strbuf *err); + typedef int ref_transaction_commit_fn(struct ref_store *refs, struct ref_transaction *transaction, struct strbuf *err); @@ -583,6 +585,7 @@ struct ref_storage_be { struct ref_storage_be *next; const char *name; ref_store_init_fn *init; + ref_init_db_fn *init_db; ref_transaction_commit_fn *transaction_commit; ref_transaction_commit_fn *initial_transaction_commit; -- cgit v1.2.3 From 9b6b40d93a4c93d36225533ddc6717841b07d09d Mon Sep 17 00:00:00 2001 From: David Turner Date: Sun, 4 Sep 2016 18:08:42 +0200 Subject: refs: add method to rename refs This removes the last caller of function get_files_ref_store(), so remove it. Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 7 +++++++ refs/files-backend.c | 24 ++++++------------------ refs/refs-internal.h | 4 ++++ 3 files changed, 17 insertions(+), 18 deletions(-) diff --git a/refs.c b/refs.c index 3b0a658c56..60f518e004 100644 --- a/refs.c +++ b/refs.c @@ -1547,3 +1547,10 @@ int delete_refs(struct string_list *refnames, unsigned int flags) return refs->be->delete_refs(refs, refnames, flags); } + +int rename_ref(const char *oldref, const char *newref, const char *logmsg) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->rename_ref(refs, oldref, newref, logmsg); +} diff --git a/refs/files-backend.c b/refs/files-backend.c index 40e789611c..f61101a799 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -997,22 +997,6 @@ static struct files_ref_store *files_downcast( return (struct files_ref_store *)ref_store; } -/* - * Return a pointer to the reference store for the specified - * submodule. For the main repository, use submodule==NULL; such a - * call cannot fail. For a submodule, the submodule must exist and be - * a nonbare repository, otherwise return NULL. Verify that the - * reference store is a files_ref_store, and cast it to that type - * before returning it. - */ -static struct files_ref_store *get_files_ref_store(const char *submodule, - const char *caller) -{ - struct ref_store *refs = get_ref_store(submodule); - - return refs ? files_downcast(refs, 1, caller) : NULL; -} - /* The length of a peeled reference line in packed-refs, including EOL: */ #define PEELED_LINE_LENGTH 42 @@ -2580,9 +2564,12 @@ static int commit_ref_update(struct files_ref_store *refs, const unsigned char *sha1, const char *logmsg, struct strbuf *err); -int rename_ref(const char *oldrefname, const char *newrefname, const char *logmsg) +static int files_rename_ref(struct ref_store *ref_store, + const char *oldrefname, const char *newrefname, + const char *logmsg) { - struct files_ref_store *refs = get_files_ref_store(NULL, "rename_ref"); + struct files_ref_store *refs = + files_downcast(ref_store, 0, "rename_ref"); unsigned char sha1[20], orig_sha1[20]; int flag = 0, logmoved = 0; struct ref_lock *lock; @@ -4087,6 +4074,7 @@ struct ref_storage_be refs_be_files = { files_peel_ref, files_create_symref, files_delete_refs, + files_rename_ref, files_ref_iterator_begin, files_read_raw_ref, diff --git a/refs/refs-internal.h b/refs/refs-internal.h index b3a20955c3..c598cb19ab 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -494,6 +494,9 @@ typedef int create_symref_fn(struct ref_store *ref_store, const char *logmsg); typedef int delete_refs_fn(struct ref_store *ref_store, struct string_list *refnames, unsigned int flags); +typedef int rename_ref_fn(struct ref_store *ref_store, + const char *oldref, const char *newref, + const char *logmsg); /* * Iterate over the references in the specified ref_store that are @@ -593,6 +596,7 @@ struct ref_storage_be { peel_ref_fn *peel_ref; create_symref_fn *create_symref; delete_refs_fn *delete_refs; + rename_ref_fn *rename_ref; ref_iterator_begin_fn *iterator_begin; read_raw_ref_fn *read_raw_ref; -- cgit v1.2.3 From 7d618264394a17e6ecd83d9412ac9ddb4609a2e5 Mon Sep 17 00:00:00 2001 From: David Turner Date: Sun, 4 Sep 2016 18:08:43 +0200 Subject: refs: make lock generic Instead of including a files-backend-specific struct ref_lock, change the generic ref_update struct to include a void pointer that backends can use for their own arbitrary data. Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 25 +++++++++++++------------ refs/refs-internal.h | 2 +- 2 files changed, 14 insertions(+), 13 deletions(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index f61101a799..82b3ac0dbc 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -3520,9 +3520,8 @@ static int lock_ref_for_update(struct files_ref_store *refs, ret = lock_raw_ref(refs, update->refname, mustexist, affected_refnames, NULL, - &update->lock, &referent, + &lock, &referent, &update->type, err); - if (ret) { char *reason; @@ -3533,7 +3532,7 @@ static int lock_ref_for_update(struct files_ref_store *refs, return ret; } - lock = update->lock; + update->backend_data = lock; if (update->type & REF_ISSYMREF) { if (update->flags & REF_NODEREF) { @@ -3589,7 +3588,8 @@ static int lock_ref_for_update(struct files_ref_store *refs, for (parent_update = update->parent_update; parent_update; parent_update = parent_update->parent_update) { - oidcpy(&parent_update->lock->old_oid, &lock->old_oid); + struct ref_lock *parent_lock = parent_update->backend_data; + oidcpy(&parent_lock->old_oid, &lock->old_oid); } if ((update->flags & REF_HAVE_OLD) && @@ -3624,7 +3624,7 @@ static int lock_ref_for_update(struct files_ref_store *refs, * The lock was freed upon failure of * write_ref_to_lockfile(): */ - update->lock = NULL; + update->backend_data = NULL; strbuf_addf(err, "cannot update the ref '%s': %s", update->refname, write_err); @@ -3742,7 +3742,7 @@ static int files_transaction_commit(struct ref_store *ref_store, /* Perform updates first so live commits remain referenced */ for (i = 0; i < transaction->nr; i++) { struct ref_update *update = transaction->updates[i]; - struct ref_lock *lock = update->lock; + struct ref_lock *lock = update->backend_data; if (update->flags & REF_NEEDS_COMMIT || update->flags & REF_LOG_ONLY) { @@ -3755,7 +3755,7 @@ static int files_transaction_commit(struct ref_store *ref_store, lock->ref_name, old_msg); free(old_msg); unlock_ref(lock); - update->lock = NULL; + update->backend_data = NULL; ret = TRANSACTION_GENERIC_ERROR; goto cleanup; } @@ -3765,7 +3765,7 @@ static int files_transaction_commit(struct ref_store *ref_store, if (commit_ref(lock)) { strbuf_addf(err, "couldn't set '%s'", lock->ref_name); unlock_ref(lock); - update->lock = NULL; + update->backend_data = NULL; ret = TRANSACTION_GENERIC_ERROR; goto cleanup; } @@ -3774,17 +3774,18 @@ static int files_transaction_commit(struct ref_store *ref_store, /* Perform deletes now that updates are safely completed */ for (i = 0; i < transaction->nr; i++) { struct ref_update *update = transaction->updates[i]; + struct ref_lock *lock = update->backend_data; if (update->flags & REF_DELETING && !(update->flags & REF_LOG_ONLY)) { - if (delete_ref_loose(update->lock, update->type, err)) { + if (delete_ref_loose(lock, update->type, err)) { ret = TRANSACTION_GENERIC_ERROR; goto cleanup; } if (!(update->flags & REF_ISPRUNING)) string_list_append(&refs_to_delete, - update->lock->ref_name); + lock->ref_name); } } @@ -3800,8 +3801,8 @@ cleanup: transaction->state = REF_TRANSACTION_CLOSED; for (i = 0; i < transaction->nr; i++) - if (transaction->updates[i]->lock) - unlock_ref(transaction->updates[i]->lock); + if (transaction->updates[i]->backend_data) + unlock_ref(transaction->updates[i]->backend_data); string_list_clear(&refs_to_delete, 0); free(head_ref); string_list_clear(&affected_refnames, 0); diff --git a/refs/refs-internal.h b/refs/refs-internal.h index c598cb19ab..681982becd 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -162,7 +162,7 @@ struct ref_update { */ unsigned int flags; - struct ref_lock *lock; + void *backend_data; unsigned int type; char *msg; -- cgit v1.2.3 From 0c09ec07d1e617be5f2d7b5c937b60e77a30ede2 Mon Sep 17 00:00:00 2001 From: David Turner Date: Sun, 4 Sep 2016 18:08:44 +0200 Subject: refs: implement iteration over only per-worktree refs Alternate refs backends might still use files to store per-worktree refs. So provide a way to iterate over only the per-worktree references in a ref_store. The other backend can set up a files ref_store and iterate using the new DO_FOR_EACH_PER_WORKTREE_ONLY flag when iterating. Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs/files-backend.c | 4 ++++ refs/refs-internal.h | 10 +++++++++- 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/refs/files-backend.c b/refs/files-backend.c index 82b3ac0dbc..47710fcf28 100644 --- a/refs/files-backend.c +++ b/refs/files-backend.c @@ -1798,6 +1798,10 @@ static int files_ref_iterator_advance(struct ref_iterator *ref_iterator) int ok; while ((ok = ref_iterator_advance(iter->iter0)) == ITER_OK) { + if (iter->flags & DO_FOR_EACH_PER_WORKTREE_ONLY && + ref_type(iter->iter0->refname) != REF_TYPE_PER_WORKTREE) + continue; + if (!(iter->flags & DO_FOR_EACH_INCLUDE_BROKEN) && !ref_resolves_to_object(iter->iter0->refname, iter->iter0->oid, diff --git a/refs/refs-internal.h b/refs/refs-internal.h index 681982becd..708b26082a 100644 --- a/refs/refs-internal.h +++ b/refs/refs-internal.h @@ -467,10 +467,18 @@ extern struct ref_iterator *current_ref_iter; int do_for_each_ref_iterator(struct ref_iterator *iter, each_ref_fn fn, void *cb_data); -/* refs backends */ +/* + * Only include per-worktree refs in a do_for_each_ref*() iteration. + * Normally this will be used with a files ref_store, since that's + * where all reference backends will presumably store their + * per-worktree refs. + */ +#define DO_FOR_EACH_PER_WORKTREE_ONLY 0x02 struct ref_store; +/* refs backends */ + /* * Initialize the ref_store for the specified submodule, or for the * main repository if submodule == NULL. These functions should call -- cgit v1.2.3