diff options
Diffstat (limited to 'third_party/git/refs')
| -rw-r--r-- | third_party/git/refs/files-backend.c | 3201 | ||||
| -rw-r--r-- | third_party/git/refs/iterator.c | 435 | ||||
| -rw-r--r-- | third_party/git/refs/packed-backend.c | 1660 | ||||
| -rw-r--r-- | third_party/git/refs/packed-backend.h | 37 | ||||
| -rw-r--r-- | third_party/git/refs/ref-cache.c | 551 | ||||
| -rw-r--r-- | third_party/git/refs/ref-cache.h | 243 | ||||
| -rw-r--r-- | third_party/git/refs/refs-internal.h | 678 |
7 files changed, 0 insertions, 6805 deletions
diff --git a/third_party/git/refs/files-backend.c b/third_party/git/refs/files-backend.c deleted file mode 100644 index d60767ab73..0000000000 --- a/third_party/git/refs/files-backend.c +++ /dev/null @@ -1,3201 +0,0 @@ -#include "../cache.h" -#include "../config.h" -#include "../refs.h" -#include "refs-internal.h" -#include "ref-cache.h" -#include "packed-backend.h" -#include "../iterator.h" -#include "../dir-iterator.h" -#include "../lockfile.h" -#include "../object.h" -#include "../dir.h" -#include "../chdir-notify.h" -#include "worktree.h" - -/* - * This backend uses the following flags in `ref_update::flags` for - * internal bookkeeping purposes. Their numerical values must not - * conflict with REF_NO_DEREF, REF_FORCE_CREATE_REFLOG, REF_HAVE_NEW, - * REF_HAVE_OLD, or REF_IS_PRUNING, which are also stored in - * `ref_update::flags`. - */ - -/* - * Used as a flag in ref_update::flags when a loose ref is being - * pruned. This flag must only be used when REF_NO_DEREF is set. - */ -#define REF_IS_PRUNING (1 << 4) - -/* - * Flag passed to lock_ref_sha1_basic() telling it to tolerate broken - * refs (i.e., because the reference is about to be deleted anyway). - */ -#define REF_DELETING (1 << 5) - -/* - * Used as a flag in ref_update::flags when the lockfile needs to be - * committed. - */ -#define REF_NEEDS_COMMIT (1 << 6) - -/* - * Used as a flag in ref_update::flags when we want to log a ref - * update but not actually perform it. This is used when a symbolic - * ref update is split up. - */ -#define REF_LOG_ONLY (1 << 7) - -/* - * Used as a flag in ref_update::flags when the ref_update was via an - * update to HEAD. - */ -#define REF_UPDATE_VIA_HEAD (1 << 8) - -/* - * Used as a flag in ref_update::flags when the loose reference has - * been deleted. - */ -#define REF_DELETED_LOOSE (1 << 9) - -struct ref_lock { - char *ref_name; - struct lock_file lk; - struct object_id old_oid; -}; - -struct files_ref_store { - struct ref_store base; - unsigned int store_flags; - - char *gitdir; - char *gitcommondir; - - struct ref_cache *loose; - - struct ref_store *packed_ref_store; -}; - -static void clear_loose_ref_cache(struct files_ref_store *refs) -{ - if (refs->loose) { - free_ref_cache(refs->loose); - refs->loose = NULL; - } -} - -/* - * Create a new submodule ref cache and add it to the internal - * set of caches. - */ -static struct ref_store *files_ref_store_create(const char *gitdir, - unsigned int flags) -{ - struct files_ref_store *refs = xcalloc(1, sizeof(*refs)); - struct ref_store *ref_store = (struct ref_store *)refs; - struct strbuf sb = STRBUF_INIT; - - base_ref_store_init(ref_store, &refs_be_files); - refs->store_flags = flags; - - refs->gitdir = xstrdup(gitdir); - get_common_dir_noenv(&sb, gitdir); - refs->gitcommondir = strbuf_detach(&sb, NULL); - strbuf_addf(&sb, "%s/packed-refs", refs->gitcommondir); - refs->packed_ref_store = packed_ref_store_create(sb.buf, flags); - strbuf_release(&sb); - - chdir_notify_reparent("files-backend $GIT_DIR", - &refs->gitdir); - chdir_notify_reparent("files-backend $GIT_COMMONDIR", - &refs->gitcommondir); - - return ref_store; -} - -/* - * Die if refs is not the main ref store. caller is used in any - * necessary error messages. - */ -static void files_assert_main_repository(struct files_ref_store *refs, - const char *caller) -{ - if (refs->store_flags & REF_STORE_MAIN) - return; - - BUG("operation %s only allowed for main ref store", caller); -} - -/* - * Downcast ref_store to files_ref_store. Die if ref_store is not a - * files_ref_store. required_flags is compared with ref_store's - * store_flags to ensure the ref_store has all required capabilities. - * "caller" is used in any necessary error messages. - */ -static struct files_ref_store *files_downcast(struct ref_store *ref_store, - unsigned int required_flags, - const char *caller) -{ - struct files_ref_store *refs; - - if (ref_store->be != &refs_be_files) - BUG("ref_store is type \"%s\" not \"files\" in %s", - ref_store->be->name, caller); - - refs = (struct files_ref_store *)ref_store; - - if ((refs->store_flags & required_flags) != required_flags) - BUG("operation %s requires abilities 0x%x, but only have 0x%x", - caller, required_flags, refs->store_flags); - - return refs; -} - -static void files_reflog_path_other_worktrees(struct files_ref_store *refs, - struct strbuf *sb, - const char *refname) -{ - const char *real_ref; - const char *worktree_name; - int length; - - if (parse_worktree_ref(refname, &worktree_name, &length, &real_ref)) - BUG("refname %s is not a other-worktree ref", refname); - - if (worktree_name) - strbuf_addf(sb, "%s/worktrees/%.*s/logs/%s", refs->gitcommondir, - length, worktree_name, real_ref); - else - strbuf_addf(sb, "%s/logs/%s", refs->gitcommondir, - real_ref); -} - -static void files_reflog_path(struct files_ref_store *refs, - struct strbuf *sb, - const char *refname) -{ - switch (ref_type(refname)) { - case REF_TYPE_PER_WORKTREE: - case REF_TYPE_PSEUDOREF: - strbuf_addf(sb, "%s/logs/%s", refs->gitdir, refname); - break; - case REF_TYPE_OTHER_PSEUDOREF: - case REF_TYPE_MAIN_PSEUDOREF: - files_reflog_path_other_worktrees(refs, sb, refname); - break; - case REF_TYPE_NORMAL: - strbuf_addf(sb, "%s/logs/%s", refs->gitcommondir, refname); - break; - default: - BUG("unknown ref type %d of ref %s", - ref_type(refname), refname); - } -} - -static void files_ref_path(struct files_ref_store *refs, - struct strbuf *sb, - const char *refname) -{ - switch (ref_type(refname)) { - case REF_TYPE_PER_WORKTREE: - case REF_TYPE_PSEUDOREF: - strbuf_addf(sb, "%s/%s", refs->gitdir, refname); - break; - case REF_TYPE_MAIN_PSEUDOREF: - if (!skip_prefix(refname, "main-worktree/", &refname)) - BUG("ref %s is not a main pseudoref", refname); - /* fallthrough */ - case REF_TYPE_OTHER_PSEUDOREF: - case REF_TYPE_NORMAL: - strbuf_addf(sb, "%s/%s", refs->gitcommondir, refname); - break; - default: - BUG("unknown ref type %d of ref %s", - ref_type(refname), refname); - } -} - -/* - * Manually add refs/bisect, refs/rewritten and refs/worktree, which, being - * per-worktree, might not appear in the directory listing for - * refs/ in the main repo. - */ -static void add_per_worktree_entries_to_dir(struct ref_dir *dir, const char *dirname) -{ - const char *prefixes[] = { "refs/bisect/", "refs/worktree/", "refs/rewritten/" }; - int ip; - - if (strcmp(dirname, "refs/")) - return; - - for (ip = 0; ip < ARRAY_SIZE(prefixes); ip++) { - const char *prefix = prefixes[ip]; - int prefix_len = strlen(prefix); - struct ref_entry *child_entry; - int pos; - - pos = search_ref_dir(dir, prefix, prefix_len); - if (pos >= 0) - continue; - child_entry = create_dir_entry(dir->cache, prefix, prefix_len, 1); - add_entry_to_dir(dir, child_entry); - } -} - -/* - * Read the loose references from the namespace dirname into dir - * (without recursing). dirname must end with '/'. dir must be the - * directory entry corresponding to dirname. - */ -static void loose_fill_ref_dir(struct ref_store *ref_store, - struct ref_dir *dir, const char *dirname) -{ - struct files_ref_store *refs = - files_downcast(ref_store, REF_STORE_READ, "fill_ref_dir"); - DIR *d; - struct dirent *de; - int dirnamelen = strlen(dirname); - struct strbuf refname; - struct strbuf path = STRBUF_INIT; - size_t path_baselen; - - files_ref_path(refs, &path, dirname); - path_baselen = path.len; - - d = opendir(path.buf); - if (!d) { - strbuf_release(&path); - return; - } - - strbuf_init(&refname, dirnamelen + 257); - strbuf_add(&refname, dirname, dirnamelen); - - while ((de = readdir(d)) != NULL) { - struct object_id oid; - struct stat st; - int flag; - - if (de->d_name[0] == '.') - continue; - if (ends_with(de->d_name, ".lock")) - continue; - strbuf_addstr(&refname, de->d_name); - strbuf_addstr(&path, de->d_name); - if (stat(path.buf, &st) < 0) { - ; /* silently ignore */ - } else if (S_ISDIR(st.st_mode)) { - strbuf_addch(&refname, '/'); - add_entry_to_dir(dir, - create_dir_entry(dir->cache, refname.buf, - refname.len, 1)); - } else { - if (!refs_resolve_ref_unsafe(&refs->base, - refname.buf, - RESOLVE_REF_READING, - &oid, &flag)) { - oidclr(&oid); - flag |= REF_ISBROKEN; - } else if (is_null_oid(&oid)) { - /* - * It is so astronomically unlikely - * that null_oid is the OID of an - * actual object that we consider its - * appearance in a loose reference - * file to be repo corruption - * (probably due to a software bug). - */ - flag |= REF_ISBROKEN; - } - - if (check_refname_format(refname.buf, - REFNAME_ALLOW_ONELEVEL)) { - if (!refname_is_safe(refname.buf)) - die("loose refname is dangerous: %s", refname.buf); - oidclr(&oid); - flag |= REF_BAD_NAME | REF_ISBROKEN; - } - add_entry_to_dir(dir, - create_ref_entry(refname.buf, &oid, flag)); - } - strbuf_setlen(&refname, dirnamelen); - strbuf_setlen(&path, path_baselen); - } - strbuf_release(&refname); - strbuf_release(&path); - closedir(d); - - add_per_worktree_entries_to_dir(dir, dirname); -} - -static struct ref_cache *get_loose_ref_cache(struct files_ref_store *refs) -{ - if (!refs->loose) { - /* - * Mark the top-level directory complete because we - * are about to read the only subdirectory that can - * hold references: - */ - refs->loose = create_ref_cache(&refs->base, loose_fill_ref_dir); - - /* We're going to fill the top level ourselves: */ - refs->loose->root->flag &= ~REF_INCOMPLETE; - - /* - * Add an incomplete entry for "refs/" (to be filled - * lazily): - */ - add_entry_to_dir(get_ref_dir(refs->loose->root), - create_dir_entry(refs->loose, "refs/", 5, 1)); - } - return refs->loose; -} - -static int files_read_raw_ref(struct ref_store *ref_store, - const char *refname, struct object_id *oid, - struct strbuf *referent, unsigned int *type) -{ - struct files_ref_store *refs = - files_downcast(ref_store, REF_STORE_READ, "read_raw_ref"); - struct strbuf sb_contents = STRBUF_INIT; - struct strbuf sb_path = STRBUF_INIT; - const char *path; - const char *buf; - const char *p; - struct stat st; - int fd; - int ret = -1; - int save_errno; - int remaining_retries = 3; - - *type = 0; - strbuf_reset(&sb_path); - - files_ref_path(refs, &sb_path, refname); - - path = sb_path.buf; - -stat_ref: - /* - * We might have to loop back here to avoid a race - * condition: first we lstat() the file, then we try - * to read it as a link or as a file. But if somebody - * changes the type of the file (file <-> directory - * <-> symlink) between the lstat() and reading, then - * we don't want to report that as an error but rather - * try again starting with the lstat(). - * - * We'll keep a count of the retries, though, just to avoid - * any confusing situation sending us into an infinite loop. - */ - - if (remaining_retries-- <= 0) - goto out; - - if (lstat(path, &st) < 0) { - if (errno != ENOENT) - goto out; - if (refs_read_raw_ref(refs->packed_ref_store, refname, - oid, referent, type)) { - errno = ENOENT; - goto out; - } - ret = 0; - goto out; - } - - /* Follow "normalized" - ie "refs/.." symlinks by hand */ - if (S_ISLNK(st.st_mode)) { - strbuf_reset(&sb_contents); - if (strbuf_readlink(&sb_contents, path, st.st_size) < 0) { - if (errno == ENOENT || errno == EINVAL) - /* inconsistent with lstat; retry */ - goto stat_ref; - else - goto out; - } - if (starts_with(sb_contents.buf, "refs/") && - !check_refname_format(sb_contents.buf, 0)) { - strbuf_swap(&sb_contents, referent); - *type |= REF_ISSYMREF; - ret = 0; - goto out; - } - /* - * It doesn't look like a refname; fall through to just - * treating it like a non-symlink, and reading whatever it - * points to. - */ - } - - /* Is it a directory? */ - if (S_ISDIR(st.st_mode)) { - /* - * Even though there is a directory where the loose - * ref is supposed to be, there could still be a - * packed ref: - */ - if (refs_read_raw_ref(refs->packed_ref_store, refname, - oid, referent, type)) { - errno = EISDIR; - goto out; - } - ret = 0; - goto out; - } - - /* - * Anything else, just open it and try to use it as - * a ref - */ - fd = open(path, O_RDONLY); - if (fd < 0) { - if (errno == ENOENT && !S_ISLNK(st.st_mode)) - /* inconsistent with lstat; retry */ - goto stat_ref; - else - goto out; - } - strbuf_reset(&sb_contents); - if (strbuf_read(&sb_contents, fd, 256) < 0) { - int save_errno = errno; - close(fd); - errno = save_errno; - goto out; - } - close(fd); - strbuf_rtrim(&sb_contents); - buf = sb_contents.buf; - if (starts_with(buf, "ref:")) { - buf += 4; - while (isspace(*buf)) - buf++; - - strbuf_reset(referent); - strbuf_addstr(referent, buf); - *type |= REF_ISSYMREF; - ret = 0; - goto out; - } - - /* - * Please note that FETCH_HEAD has additional - * data after the sha. - */ - if (parse_oid_hex(buf, oid, &p) || - (*p != '\0' && !isspace(*p))) { - *type |= REF_ISBROKEN; - errno = EINVAL; - goto out; - } - - ret = 0; - -out: - save_errno = errno; - strbuf_release(&sb_path); - strbuf_release(&sb_contents); - errno = save_errno; - return ret; -} - -static void unlock_ref(struct ref_lock *lock) -{ - rollback_lock_file(&lock->lk); - free(lock->ref_name); - free(lock); -} - -/* - * Lock refname, without following symrefs, and set *lock_p to point - * at a newly-allocated lock object. Fill in lock->old_oid, referent, - * and type similarly to read_raw_ref(). - * - * The caller must verify that refname is a "safe" reference name (in - * the sense of refname_is_safe()) before calling this function. - * - * If the reference doesn't already exist, verify that refname doesn't - * have a D/F conflict with any existing references. extras and skip - * are passed to refs_verify_refname_available() for this check. - * - * If mustexist is not set and the reference is not found or is - * broken, lock the reference anyway but clear old_oid. - * - * Return 0 on success. On failure, write an error message to err and - * return TRANSACTION_NAME_CONFLICT or TRANSACTION_GENERIC_ERROR. - * - * Implementation note: This function is basically - * - * lock reference - * read_raw_ref() - * - * but it includes a lot more code to - * - Deal with possible races with other processes - * - Avoid calling refs_verify_refname_available() when it can be - * 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(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, - struct strbuf *referent, - unsigned int *type, - struct strbuf *err) -{ - struct ref_lock *lock; - struct strbuf ref_file = STRBUF_INIT; - int attempts_remaining = 3; - int ret = TRANSACTION_GENERIC_ERROR; - - assert(err); - files_assert_main_repository(refs, "lock_raw_ref"); - - *type = 0; - - /* First lock the file so it can't change out from under us. */ - - *lock_p = lock = xcalloc(1, sizeof(*lock)); - - lock->ref_name = xstrdup(refname); - files_ref_path(refs, &ref_file, refname); - -retry: - switch (safe_create_leading_directories(ref_file.buf)) { - case SCLD_OK: - break; /* success */ - case SCLD_EXISTS: - /* - * Suppose refname is "refs/foo/bar". We just failed - * to create the containing directory, "refs/foo", - * because there was a non-directory in the way. This - * indicates a D/F conflict, probably because of - * another reference such as "refs/foo". There is no - * reason to expect this error to be transitory. - */ - if (refs_verify_refname_available(&refs->base, refname, - extras, skip, err)) { - if (mustexist) { - /* - * To the user the relevant error is - * that the "mustexist" reference is - * missing: - */ - strbuf_reset(err); - strbuf_addf(err, "unable to resolve reference '%s'", - refname); - } else { - /* - * The error message set by - * refs_verify_refname_available() is - * OK. - */ - ret = TRANSACTION_NAME_CONFLICT; - } - } else { - /* - * The file that is in the way isn't a loose - * reference. Report it as a low-level - * failure. - */ - strbuf_addf(err, "unable to create lock file %s.lock; " - "non-directory in the way", - ref_file.buf); - } - goto error_return; - case SCLD_VANISHED: - /* Maybe another process was tidying up. Try again. */ - if (--attempts_remaining > 0) - goto retry; - /* fall through */ - default: - strbuf_addf(err, "unable to create directory for %s", - ref_file.buf); - goto error_return; - } - - if (hold_lock_file_for_update_timeout( - &lock->lk, ref_file.buf, LOCK_NO_DEREF, - get_files_ref_lock_timeout_ms()) < 0) { - if (errno == ENOENT && --attempts_remaining > 0) { - /* - * Maybe somebody just deleted one of the - * directories leading to ref_file. Try - * again: - */ - goto retry; - } else { - unable_to_lock_message(ref_file.buf, errno, err); - goto error_return; - } - } - - /* - * Now we hold the lock and can read the reference without - * fear that its value will change. - */ - - if (files_read_raw_ref(&refs->base, refname, - &lock->old_oid, referent, type)) { - if (errno == ENOENT) { - if (mustexist) { - /* Garden variety missing reference. */ - strbuf_addf(err, "unable to resolve reference '%s'", - refname); - goto error_return; - } else { - /* - * Reference is missing, but that's OK. We - * know that there is not a conflict with - * another loose reference because - * (supposing that we are trying to lock - * reference "refs/foo/bar"): - * - * - We were successfully able to create - * the lockfile refs/foo/bar.lock, so we - * know there cannot be a loose reference - * named "refs/foo". - * - * - We got ENOENT and not EISDIR, so we - * know that there cannot be a loose - * reference named "refs/foo/bar/baz". - */ - } - } else if (errno == EISDIR) { - /* - * There is a directory in the way. It might have - * contained references that have been deleted. If - * we don't require that the reference already - * exists, try to remove the directory so that it - * doesn't cause trouble when we want to rename the - * lockfile into place later. - */ - if (mustexist) { - /* Garden variety missing reference. */ - strbuf_addf(err, "unable to resolve reference '%s'", - refname); - goto error_return; - } else if (remove_dir_recursively(&ref_file, - REMOVE_DIR_EMPTY_ONLY)) { - if (refs_verify_refname_available( - &refs->base, refname, - extras, skip, err)) { - /* - * The error message set by - * verify_refname_available() is OK. - */ - ret = TRANSACTION_NAME_CONFLICT; - goto error_return; - } else { - /* - * We can't delete the directory, - * but we also don't know of any - * references that it should - * contain. - */ - strbuf_addf(err, "there is a non-empty directory '%s' " - "blocking reference '%s'", - ref_file.buf, refname); - goto error_return; - } - } - } else if (errno == EINVAL && (*type & REF_ISBROKEN)) { - strbuf_addf(err, "unable to resolve reference '%s': " - "reference broken", refname); - goto error_return; - } else { - strbuf_addf(err, "unable to resolve reference '%s': %s", - refname, strerror(errno)); - goto error_return; - } - - /* - * If the ref did not exist and we are creating it, - * make sure there is no existing packed ref that - * conflicts with refname: - */ - if (refs_verify_refname_available( - refs->packed_ref_store, refname, - extras, skip, err)) - goto error_return; - } - - ret = 0; - goto out; - -error_return: - unlock_ref(lock); - *lock_p = NULL; - -out: - strbuf_release(&ref_file); - return ret; -} - -struct files_ref_iterator { - struct ref_iterator base; - - struct ref_iterator *iter0; - unsigned int flags; -}; - -static int files_ref_iterator_advance(struct ref_iterator *ref_iterator) -{ - struct files_ref_iterator *iter = - (struct files_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, - iter->iter0->flags)) - continue; - - iter->base.refname = iter->iter0->refname; - iter->base.oid = iter->iter0->oid; - iter->base.flags = iter->iter0->flags; - return ITER_OK; - } - - iter->iter0 = NULL; - if (ref_iterator_abort(ref_iterator) != ITER_DONE) - ok = ITER_ERROR; - - return ok; -} - -static int files_ref_iterator_peel(struct ref_iterator *ref_iterator, - struct object_id *peeled) -{ - struct files_ref_iterator *iter = - (struct files_ref_iterator *)ref_iterator; - - return ref_iterator_peel(iter->iter0, peeled); -} - -static int files_ref_iterator_abort(struct ref_iterator *ref_iterator) -{ - struct files_ref_iterator *iter = - (struct files_ref_iterator *)ref_iterator; - int ok = ITER_DONE; - - if (iter->iter0) - ok = ref_iterator_abort(iter->iter0); - - base_ref_iterator_free(ref_iterator); - return ok; -} - -static struct ref_iterator_vtable files_ref_iterator_vtable = { - files_ref_iterator_advance, - files_ref_iterator_peel, - files_ref_iterator_abort -}; - -static struct ref_iterator *files_ref_iterator_begin( - struct ref_store *ref_store, - const char *prefix, unsigned int flags) -{ - struct files_ref_store *refs; - struct ref_iterator *loose_iter, *packed_iter, *overlay_iter; - struct files_ref_iterator *iter; - struct ref_iterator *ref_iterator; - unsigned int required_flags = REF_STORE_READ; - - if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN)) - required_flags |= REF_STORE_ODB; - - refs = files_downcast(ref_store, required_flags, "ref_iterator_begin"); - - /* - * We must make sure that all loose refs are read before - * accessing the packed-refs file; this avoids a race - * condition if loose refs are migrated to the packed-refs - * file by a simultaneous process, but our in-memory view is - * from before the migration. We ensure this as follows: - * First, we call start the loose refs iteration with its - * `prime_ref` argument set to true. This causes the loose - * references in the subtree to be pre-read into the cache. - * (If they've already been read, that's OK; we only need to - * guarantee that they're read before the packed refs, not - * *how much* before.) After that, we call - * packed_ref_iterator_begin(), which internally checks - * whether the packed-ref cache is up to date with what is on - * disk, and re-reads it if not. - */ - - loose_iter = cache_ref_iterator_begin(get_loose_ref_cache(refs), - prefix, 1); - - /* - * The packed-refs file might contain broken references, for - * example an old version of a reference that points at an - * object that has since been garbage-collected. This is OK as - * long as there is a corresponding loose reference that - * overrides it, and we don't want to emit an error message in - * this case. So ask the packed_ref_store for all of its - * references, and (if needed) do our own check for broken - * ones in files_ref_iterator_advance(), after we have merged - * the packed and loose references. - */ - packed_iter = refs_ref_iterator_begin( - refs->packed_ref_store, prefix, 0, - DO_FOR_EACH_INCLUDE_BROKEN); - - overlay_iter = overlay_ref_iterator_begin(loose_iter, packed_iter); - - iter = xcalloc(1, sizeof(*iter)); - ref_iterator = &iter->base; - base_ref_iterator_init(ref_iterator, &files_ref_iterator_vtable, - overlay_iter->ordered); - iter->iter0 = overlay_iter; - iter->flags = flags; - - return ref_iterator; -} - -/* - * Verify that the reference locked by lock has the value old_oid - * (unless it is NULL). Fail if the reference doesn't exist and - * mustexist is set. Return 0 on success. On error, write an error - * message to err, set errno, and return a negative value. - */ -static int verify_lock(struct ref_store *ref_store, struct ref_lock *lock, - const struct object_id *old_oid, int mustexist, - struct strbuf *err) -{ - assert(err); - - if (refs_read_ref_full(ref_store, lock->ref_name, - mustexist ? RESOLVE_REF_READING : 0, - &lock->old_oid, NULL)) { - if (old_oid) { - int save_errno = errno; - strbuf_addf(err, "can't verify ref '%s'", lock->ref_name); - errno = save_errno; - return -1; - } else { - oidclr(&lock->old_oid); - return 0; - } - } - if (old_oid && !oideq(&lock->old_oid, old_oid)) { - strbuf_addf(err, "ref '%s' is at %s but expected %s", - lock->ref_name, - oid_to_hex(&lock->old_oid), - oid_to_hex(old_oid)); - errno = EBUSY; - return -1; - } - return 0; -} - -static int remove_empty_directories(struct strbuf *path) -{ - /* - * we want to create a file but there is a directory there; - * if that is an empty directory (or a directory that contains - * only empty directories), remove them. - */ - return remove_dir_recursively(path, REMOVE_DIR_EMPTY_ONLY); -} - -static int create_reflock(const char *path, void *cb) -{ - struct lock_file *lk = cb; - - return hold_lock_file_for_update_timeout( - lk, path, LOCK_NO_DEREF, - get_files_ref_lock_timeout_ms()) < 0 ? -1 : 0; -} - -/* - * 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_oid_basic(struct files_ref_store *refs, - const char *refname, - const struct object_id *old_oid, - const struct string_list *extras, - const struct string_list *skip, - unsigned int flags, int *type, - struct strbuf *err) -{ - struct strbuf ref_file = STRBUF_INIT; - struct ref_lock *lock; - int last_errno = 0; - int mustexist = (old_oid && !is_null_oid(old_oid)); - int resolve_flags = RESOLVE_REF_NO_RECURSE; - int resolved; - - files_assert_main_repository(refs, "lock_ref_oid_basic"); - assert(err); - - lock = xcalloc(1, sizeof(struct ref_lock)); - - if (mustexist) - resolve_flags |= RESOLVE_REF_READING; - if (flags & REF_DELETING) - resolve_flags |= RESOLVE_REF_ALLOW_BAD_NAME; - - files_ref_path(refs, &ref_file, refname); - resolved = !!refs_resolve_ref_unsafe(&refs->base, - refname, resolve_flags, - &lock->old_oid, type); - if (!resolved && errno == EISDIR) { - /* - * we are trying to lock foo but we used to - * have foo/bar which now does not exist; - * it is normal for the empty directory 'foo' - * to remain. - */ - if (remove_empty_directories(&ref_file)) { - last_errno = errno; - if (!refs_verify_refname_available( - &refs->base, - refname, extras, skip, err)) - strbuf_addf(err, "there are still refs under '%s'", - refname); - goto error_return; - } - resolved = !!refs_resolve_ref_unsafe(&refs->base, - refname, resolve_flags, - &lock->old_oid, type); - } - if (!resolved) { - last_errno = errno; - if (last_errno != ENOTDIR || - !refs_verify_refname_available(&refs->base, refname, - extras, skip, err)) - strbuf_addf(err, "unable to resolve reference '%s': %s", - refname, strerror(last_errno)); - - goto error_return; - } - - /* - * If the ref did not exist and we are creating it, make sure - * there is no existing packed ref whose name begins with our - * refname, nor a packed ref whose name is a proper prefix of - * our refname. - */ - if (is_null_oid(&lock->old_oid) && - refs_verify_refname_available(refs->packed_ref_store, refname, - extras, skip, err)) { - last_errno = ENOTDIR; - goto error_return; - } - - lock->ref_name = xstrdup(refname); - - if (raceproof_create_file(ref_file.buf, create_reflock, &lock->lk)) { - last_errno = errno; - unable_to_lock_message(ref_file.buf, errno, err); - goto error_return; - } - - if (verify_lock(&refs->base, lock, old_oid, mustexist, err)) { - last_errno = errno; - goto error_return; - } - goto out; - - error_return: - unlock_ref(lock); - lock = NULL; - - out: - strbuf_release(&ref_file); - errno = last_errno; - return lock; -} - -struct ref_to_prune { - struct ref_to_prune *next; - struct object_id oid; - char name[FLEX_ARRAY]; -}; - -enum { - REMOVE_EMPTY_PARENTS_REF = 0x01, - REMOVE_EMPTY_PARENTS_REFLOG = 0x02 -}; - -/* - * Remove empty parent directories associated with the specified - * reference and/or its reflog, but spare [logs/]refs/ and immediate - * subdirs. flags is a combination of REMOVE_EMPTY_PARENTS_REF and/or - * REMOVE_EMPTY_PARENTS_REFLOG. - */ -static void try_remove_empty_parents(struct files_ref_store *refs, - const char *refname, - unsigned int flags) -{ - struct strbuf buf = STRBUF_INIT; - struct strbuf sb = STRBUF_INIT; - char *p, *q; - int i; - - strbuf_addstr(&buf, refname); - p = buf.buf; - for (i = 0; i < 2; i++) { /* refs/{heads,tags,...}/ */ - while (*p && *p != '/') - p++; - /* tolerate duplicate slashes; see check_refname_format() */ - while (*p == '/') - p++; - } - q = buf.buf + buf.len; - while (flags & (REMOVE_EMPTY_PARENTS_REF | REMOVE_EMPTY_PARENTS_REFLOG)) { - while (q > p && *q != '/') - q--; - while (q > p && *(q-1) == '/') - q--; - if (q == p) - break; - strbuf_setlen(&buf, q - buf.buf); - - strbuf_reset(&sb); - files_ref_path(refs, &sb, buf.buf); - if ((flags & REMOVE_EMPTY_PARENTS_REF) && rmdir(sb.buf)) - flags &= ~REMOVE_EMPTY_PARENTS_REF; - - strbuf_reset(&sb); - files_reflog_path(refs, &sb, buf.buf); - if ((flags & REMOVE_EMPTY_PARENTS_REFLOG) && rmdir(sb.buf)) - flags &= ~REMOVE_EMPTY_PARENTS_REFLOG; - } - strbuf_release(&buf); - strbuf_release(&sb); -} - -/* make sure nobody touched the ref, and unlink */ -static void prune_ref(struct files_ref_store *refs, struct ref_to_prune *r) -{ - struct ref_transaction *transaction; - struct strbuf err = STRBUF_INIT; - int ret = -1; - - if (check_refname_format(r->name, 0)) - return; - - transaction = ref_store_transaction_begin(&refs->base, &err); - if (!transaction) - goto cleanup; - ref_transaction_add_update( - transaction, r->name, - REF_NO_DEREF | REF_HAVE_NEW | REF_HAVE_OLD | REF_IS_PRUNING, - &null_oid, &r->oid, NULL); - if (ref_transaction_commit(transaction, &err)) - goto cleanup; - - ret = 0; - -cleanup: - if (ret) - error("%s", err.buf); - strbuf_release(&err); - ref_transaction_free(transaction); - return; -} - -/* - * Prune the loose versions of the references in the linked list - * `*refs_to_prune`, freeing the entries in the list as we go. - */ -static void prune_refs(struct files_ref_store *refs, struct ref_to_prune **refs_to_prune) -{ - while (*refs_to_prune) { - struct ref_to_prune *r = *refs_to_prune; - *refs_to_prune = r->next; - prune_ref(refs, r); - free(r); - } -} - -/* - * Return true if the specified reference should be packed. - */ -static int should_pack_ref(const char *refname, - const struct object_id *oid, unsigned int ref_flags, - unsigned int pack_flags) -{ - /* Do not pack per-worktree refs: */ - if (ref_type(refname) != REF_TYPE_NORMAL) - return 0; - - /* Do not pack non-tags unless PACK_REFS_ALL is set: */ - if (!(pack_flags & PACK_REFS_ALL) && !starts_with(refname, "refs/tags/")) - return 0; - - /* Do not pack symbolic refs: */ - if (ref_flags & REF_ISSYMREF) - return 0; - - /* Do not pack broken refs: */ - if (!ref_resolves_to_object(refname, oid, ref_flags)) - return 0; - - return 1; -} - -static int files_pack_refs(struct ref_store *ref_store, unsigned int flags) -{ - struct files_ref_store *refs = - files_downcast(ref_store, REF_STORE_WRITE | REF_STORE_ODB, - "pack_refs"); - struct ref_iterator *iter; - int ok; - struct ref_to_prune *refs_to_prune = NULL; - struct strbuf err = STRBUF_INIT; - struct ref_transaction *transaction; - - transaction = ref_store_transaction_begin(refs->packed_ref_store, &err); - if (!transaction) - return -1; - - packed_refs_lock(refs->packed_ref_store, LOCK_DIE_ON_ERROR, &err); - - iter = cache_ref_iterator_begin(get_loose_ref_cache(refs), NULL, 0); - while ((ok = ref_iterator_advance(iter)) == ITER_OK) { - /* - * If the loose reference can be packed, add an entry - * in the packed ref cache. If the reference should be - * pruned, also add it to refs_to_prune. - */ - if (!should_pack_ref(iter->refname, iter->oid, iter->flags, - flags)) - continue; - - /* - * Add a reference creation for this reference to the - * packed-refs transaction: - */ - if (ref_transaction_update(transaction, iter->refname, - iter->oid, NULL, - REF_NO_DEREF, NULL, &err)) - die("failure preparing to create packed reference %s: %s", - iter->refname, err.buf); - - /* Schedule the loose reference for pruning if requested. */ - if ((flags & PACK_REFS_PRUNE)) { - struct ref_to_prune *n; - FLEX_ALLOC_STR(n, name, iter->refname); - oidcpy(&n->oid, iter->oid); - n->next = refs_to_prune; - refs_to_prune = n; - } - } - if (ok != ITER_DONE) - die("error while iterating over references"); - - if (ref_transaction_commit(transaction, &err)) - die("unable to write new packed-refs: %s", err.buf); - - ref_transaction_free(transaction); - - packed_refs_unlock(refs->packed_ref_store); - - prune_refs(refs, &refs_to_prune); - strbuf_release(&err); - return 0; -} - -static int files_delete_refs(struct ref_store *ref_store, const char *msg, - struct string_list *refnames, unsigned int flags) -{ - struct files_ref_store *refs = - files_downcast(ref_store, REF_STORE_WRITE, "delete_refs"); - struct strbuf err = STRBUF_INIT; - int i, result = 0; - - if (!refnames->nr) - return 0; - - if (packed_refs_lock(refs->packed_ref_store, 0, &err)) - goto error; - - if (refs_delete_refs(refs->packed_ref_store, msg, refnames, flags)) { - packed_refs_unlock(refs->packed_ref_store); - goto error; - } - - packed_refs_unlock(refs->packed_ref_store); - - for (i = 0; i < refnames->nr; i++) { - const char *refname = refnames->items[i].string; - - if (refs_delete_ref(&refs->base, msg, refname, NULL, flags)) - result |= error(_("could not remove reference %s"), refname); - } - - strbuf_release(&err); - return result; - -error: - /* - * If we failed to rewrite the packed-refs file, then it is - * unsafe to try to remove loose refs, because doing so might - * expose an obsolete packed value for a reference that might - * even point at an object that has been garbage collected. - */ - if (refnames->nr == 1) - error(_("could not delete reference %s: %s"), - refnames->items[0].string, err.buf); - else - error(_("could not delete references: %s"), err.buf); - - strbuf_release(&err); - return -1; -} - -/* - * People using contrib's git-new-workdir have .git/logs/refs -> - * /some/other/path/.git/logs/refs, and that may live on another device. - * - * IOW, to avoid cross device rename errors, the temporary renamed log must - * live into logs/refs. - */ -#define TMP_RENAMED_LOG "refs/.tmp-renamed-log" - -struct rename_cb { - const char *tmp_renamed_log; - int true_errno; -}; - -static int rename_tmp_log_callback(const char *path, void *cb_data) -{ - struct rename_cb *cb = cb_data; - - if (rename(cb->tmp_renamed_log, path)) { - /* - * rename(a, b) when b is an existing directory ought - * to result in ISDIR, but Solaris 5.8 gives ENOTDIR. - * Sheesh. Record the true errno for error reporting, - * but report EISDIR to raceproof_create_file() so - * that it knows to retry. - */ - cb->true_errno = errno; - if (errno == ENOTDIR) - errno = EISDIR; - return -1; - } else { - return 0; - } -} - -static int rename_tmp_log(struct files_ref_store *refs, const char *newrefname) -{ - struct strbuf path = STRBUF_INIT; - struct strbuf tmp = STRBUF_INIT; - struct rename_cb cb; - int ret; - - files_reflog_path(refs, &path, newrefname); - files_reflog_path(refs, &tmp, TMP_RENAMED_LOG); - cb.tmp_renamed_log = tmp.buf; - ret = raceproof_create_file(path.buf, rename_tmp_log_callback, &cb); - if (ret) { - if (errno == EISDIR) - error("directory not empty: %s", path.buf); - else - error("unable to move logfile %s to %s: %s", - tmp.buf, path.buf, - strerror(cb.true_errno)); - } - - strbuf_release(&path); - strbuf_release(&tmp); - return ret; -} - -static int write_ref_to_lockfile(struct ref_lock *lock, - const struct object_id *oid, struct strbuf *err); -static int commit_ref_update(struct files_ref_store *refs, - struct ref_lock *lock, - const struct object_id *oid, const char *logmsg, - struct strbuf *err); - -static int files_copy_or_rename_ref(struct ref_store *ref_store, - const char *oldrefname, const char *newrefname, - const char *logmsg, int copy) -{ - struct files_ref_store *refs = - files_downcast(ref_store, REF_STORE_WRITE, "rename_ref"); - struct object_id oid, orig_oid; - int flag = 0, logmoved = 0; - struct ref_lock *lock; - struct stat loginfo; - struct strbuf sb_oldref = STRBUF_INIT; - struct strbuf sb_newref = STRBUF_INIT; - struct strbuf tmp_renamed_log = STRBUF_INIT; - int log, ret; - struct strbuf err = STRBUF_INIT; - - files_reflog_path(refs, &sb_oldref, oldrefname); - files_reflog_path(refs, &sb_newref, newrefname); - files_reflog_path(refs, &tmp_renamed_log, TMP_RENAMED_LOG); - - log = !lstat(sb_oldref.buf, &loginfo); - if (log && S_ISLNK(loginfo.st_mode)) { - ret = error("reflog for %s is a symlink", oldrefname); - goto out; - } - - if (!refs_resolve_ref_unsafe(&refs->base, oldrefname, - RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE, - &orig_oid, &flag)) { - ret = error("refname %s not found", oldrefname); - goto out; - } - - if (flag & REF_ISSYMREF) { - if (copy) - ret = error("refname %s is a symbolic ref, copying it is not supported", - oldrefname); - else - ret = error("refname %s is a symbolic ref, renaming it is not supported", - oldrefname); - goto out; - } - if (!refs_rename_ref_available(&refs->base, oldrefname, newrefname)) { - ret = 1; - goto out; - } - - if (!copy && log && rename(sb_oldref.buf, tmp_renamed_log.buf)) { - ret = error("unable to move logfile logs/%s to logs/"TMP_RENAMED_LOG": %s", - oldrefname, strerror(errno)); - goto out; - } - - if (copy && log && copy_file(tmp_renamed_log.buf, sb_oldref.buf, 0644)) { - ret = error("unable to copy logfile logs/%s to logs/"TMP_RENAMED_LOG": %s", - oldrefname, strerror(errno)); - goto out; - } - - if (!copy && refs_delete_ref(&refs->base, logmsg, oldrefname, - &orig_oid, REF_NO_DEREF)) { - error("unable to delete old %s", oldrefname); - goto rollback; - } - - /* - * Since we are doing a shallow lookup, oid is not the - * correct value to pass to delete_ref as old_oid. But that - * doesn't matter, because an old_oid check wouldn't add to - * the safety anyway; we want to delete the reference whatever - * its current value. - */ - if (!copy && !refs_read_ref_full(&refs->base, newrefname, - RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE, - &oid, NULL) && - refs_delete_ref(&refs->base, NULL, newrefname, - NULL, REF_NO_DEREF)) { - if (errno == EISDIR) { - struct strbuf path = STRBUF_INIT; - int result; - - files_ref_path(refs, &path, newrefname); - result = remove_empty_directories(&path); - strbuf_release(&path); - - if (result) { - error("Directory not empty: %s", newrefname); - goto rollback; - } - } else { - error("unable to delete existing %s", newrefname); - goto rollback; - } - } - - if (log && rename_tmp_log(refs, newrefname)) - goto rollback; - - logmoved = log; - - lock = lock_ref_oid_basic(refs, newrefname, NULL, NULL, NULL, - REF_NO_DEREF, NULL, &err); - if (!lock) { - if (copy) - error("unable to copy '%s' to '%s': %s", oldrefname, newrefname, err.buf); - else - error("unable to rename '%s' to '%s': %s", oldrefname, newrefname, err.buf); - strbuf_release(&err); - goto rollback; - } - oidcpy(&lock->old_oid, &orig_oid); - - if (write_ref_to_lockfile(lock, &orig_oid, &err) || - commit_ref_update(refs, lock, &orig_oid, logmsg, &err)) { - error("unable to write current sha1 into %s: %s", newrefname, err.buf); - strbuf_release(&err); - goto rollback; - } - - ret = 0; - goto out; - - rollback: - lock = lock_ref_oid_basic(refs, oldrefname, NULL, NULL, NULL, - REF_NO_DEREF, NULL, &err); - if (!lock) { - error("unable to lock %s for rollback: %s", oldrefname, err.buf); - strbuf_release(&err); - goto rollbacklog; - } - - flag = log_all_ref_updates; - log_all_ref_updates = LOG_REFS_NONE; - if (write_ref_to_lockfile(lock, &orig_oid, &err) || - commit_ref_update(refs, lock, &orig_oid, NULL, &err)) { - error("unable to write current sha1 into %s: %s", oldrefname, err.buf); - strbuf_release(&err); - } - log_all_ref_updates = flag; - - rollbacklog: - if (logmoved && rename(sb_newref.buf, sb_oldref.buf)) - error("unable to restore logfile %s from %s: %s", - oldrefname, newrefname, strerror(errno)); - if (!logmoved && log && - rename(tmp_renamed_log.buf, sb_oldref.buf)) - error("unable to restore logfile %s from logs/"TMP_RENAMED_LOG": %s", - oldrefname, strerror(errno)); - ret = 1; - out: - strbuf_release(&sb_newref); - strbuf_release(&sb_oldref); - strbuf_release(&tmp_renamed_log); - - return ret; -} - -static int files_rename_ref(struct ref_store *ref_store, - const char *oldrefname, const char *newrefname, - const char *logmsg) -{ - return files_copy_or_rename_ref(ref_store, oldrefname, - newrefname, logmsg, 0); -} - -static int files_copy_ref(struct ref_store *ref_store, - const char *oldrefname, const char *newrefname, - const char *logmsg) -{ - return files_copy_or_rename_ref(ref_store, oldrefname, - newrefname, logmsg, 1); -} - -static int close_ref_gently(struct ref_lock *lock) -{ - if (close_lock_file_gently(&lock->lk)) - return -1; - return 0; -} - -static int commit_ref(struct ref_lock *lock) -{ - char *path = get_locked_file_path(&lock->lk); - struct stat st; - - if (!lstat(path, &st) && S_ISDIR(st.st_mode)) { - /* - * There is a directory at the path we want to rename - * the lockfile to. Hopefully it is empty; try to - * delete it. - */ - size_t len = strlen(path); - struct strbuf sb_path = STRBUF_INIT; - - strbuf_attach(&sb_path, path, len, len); - - /* - * If this fails, commit_lock_file() will also fail - * and will report the problem. - */ - remove_empty_directories(&sb_path); - strbuf_release(&sb_path); - } else { - free(path); - } - - if (commit_lock_file(&lock->lk)) - return -1; - return 0; -} - -static int open_or_create_logfile(const char *path, void *cb) -{ - int *fd = cb; - - *fd = open(path, O_APPEND | O_WRONLY | O_CREAT, 0666); - return (*fd < 0) ? -1 : 0; -} - -/* - * Create a reflog for a ref. If force_create = 0, only create the - * reflog for certain refs (those for which should_autocreate_reflog - * returns non-zero). Otherwise, create it regardless of the reference - * name. If the logfile already existed or was created, return 0 and - * set *logfd to the file descriptor opened for appending to the file. - * If no logfile exists and we decided not to create one, return 0 and - * set *logfd to -1. On failure, fill in *err, set *logfd to -1, and - * return -1. - */ -static int log_ref_setup(struct files_ref_store *refs, - const char *refname, int force_create, - int *logfd, struct strbuf *err) -{ - struct strbuf logfile_sb = STRBUF_INIT; - char *logfile; - - files_reflog_path(refs, &logfile_sb, refname); - logfile = strbuf_detach(&logfile_sb, NULL); - - if (force_create || should_autocreate_reflog(refname)) { - if (raceproof_create_file(logfile, open_or_create_logfile, logfd)) { - if (errno == ENOENT) - strbuf_addf(err, "unable to create directory for '%s': " - "%s", logfile, strerror(errno)); - else if (errno == EISDIR) - strbuf_addf(err, "there are still logs under '%s'", - logfile); - else - strbuf_addf(err, "unable to append to '%s': %s", - logfile, strerror(errno)); - - goto error; - } - } else { - *logfd = open(logfile, O_APPEND | O_WRONLY, 0666); - if (*logfd < 0) { - if (errno == ENOENT || errno == EISDIR) { - /* - * The logfile doesn't already exist, - * but that is not an error; it only - * means that we won't write log - * entries to it. - */ - ; - } else { - strbuf_addf(err, "unable to append to '%s': %s", - logfile, strerror(errno)); - goto error; - } - } - } - - if (*logfd >= 0) - adjust_shared_perm(logfile); - - free(logfile); - return 0; - -error: - free(logfile); - return -1; -} - -static int files_create_reflog(struct ref_store *ref_store, - const char *refname, int force_create, - struct strbuf *err) -{ - struct files_ref_store *refs = - files_downcast(ref_store, REF_STORE_WRITE, "create_reflog"); - int fd; - - if (log_ref_setup(refs, refname, force_create, &fd, err)) - return -1; - - if (fd >= 0) - close(fd); - - return 0; -} - -static int log_ref_write_fd(int fd, const struct object_id *old_oid, - const struct object_id *new_oid, - const char *committer, const char *msg) -{ - struct strbuf sb = STRBUF_INIT; - int ret = 0; - - strbuf_addf(&sb, "%s %s %s", oid_to_hex(old_oid), oid_to_hex(new_oid), committer); - if (msg && *msg) - copy_reflog_msg(&sb, msg); - strbuf_addch(&sb, '\n'); - if (write_in_full(fd, sb.buf, sb.len) < 0) - ret = -1; - strbuf_release(&sb); - return ret; -} - -static int files_log_ref_write(struct files_ref_store *refs, - const char *refname, const struct object_id *old_oid, - const struct object_id *new_oid, const char *msg, - int flags, struct strbuf *err) -{ - int logfd, result; - - if (log_all_ref_updates == LOG_REFS_UNSET) - log_all_ref_updates = is_bare_repository() ? LOG_REFS_NONE : LOG_REFS_NORMAL; - - result = log_ref_setup(refs, refname, - flags & REF_FORCE_CREATE_REFLOG, - &logfd, err); - - if (result) - return result; - - if (logfd < 0) - return 0; - result = log_ref_write_fd(logfd, old_oid, new_oid, - git_committer_info(0), msg); - if (result) { - struct strbuf sb = STRBUF_INIT; - int save_errno = errno; - - files_reflog_path(refs, &sb, refname); - strbuf_addf(err, "unable to append to '%s': %s", - sb.buf, strerror(save_errno)); - strbuf_release(&sb); - close(logfd); - return -1; - } - if (close(logfd)) { - struct strbuf sb = STRBUF_INIT; - int save_errno = errno; - - files_reflog_path(refs, &sb, refname); - strbuf_addf(err, "unable to append to '%s': %s", - sb.buf, strerror(save_errno)); - strbuf_release(&sb); - return -1; - } - return 0; -} - -/* - * Write oid into the open lockfile, then close the lockfile. On - * errors, rollback the lockfile, fill in *err and return -1. - */ -static int write_ref_to_lockfile(struct ref_lock *lock, - const struct object_id *oid, struct strbuf *err) -{ - static char term = '\n'; - struct object *o; - int fd; - - o = parse_object(the_repository, oid); - if (!o) { - strbuf_addf(err, - "trying to write ref '%s' with nonexistent object %s", - lock->ref_name, oid_to_hex(oid)); - unlock_ref(lock); - return -1; - } - if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) { - strbuf_addf(err, - "trying to write non-commit object %s to branch '%s'", - oid_to_hex(oid), lock->ref_name); - unlock_ref(lock); - return -1; - } - fd = get_lock_file_fd(&lock->lk); - if (write_in_full(fd, oid_to_hex(oid), the_hash_algo->hexsz) < 0 || - write_in_full(fd, &term, 1) < 0 || - close_ref_gently(lock) < 0) { - strbuf_addf(err, - "couldn't write '%s'", get_lock_file_path(&lock->lk)); - unlock_ref(lock); - return -1; - } - return 0; -} - -/* - * Commit a change to a loose reference that has already been written - * 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 files_ref_store *refs, - struct ref_lock *lock, - const struct object_id *oid, const char *logmsg, - struct strbuf *err) -{ - files_assert_main_repository(refs, "commit_ref_update"); - - clear_loose_ref_cache(refs); - if (files_log_ref_write(refs, lock->ref_name, - &lock->old_oid, oid, - logmsg, 0, err)) { - char *old_msg = strbuf_detach(err, NULL); - strbuf_addf(err, "cannot update the ref '%s': %s", - lock->ref_name, old_msg); - free(old_msg); - unlock_ref(lock); - return -1; - } - - if (strcmp(lock->ref_name, "HEAD") != 0) { - /* - * Special hack: If a branch is updated directly and HEAD - * points to it (may happen on the remote side of a push - * for example) then logically the HEAD reflog should be - * updated too. - * A generic solution implies reverse symref information, - * but finding all symrefs pointing to the given branch - * would be rather costly for this rare event (the direct - * update of a branch) to be worth it. So let's cheat and - * check with HEAD only which should cover 99% of all usage - * scenarios (even 100% of the default ones). - */ - int head_flag; - const char *head_ref; - - head_ref = refs_resolve_ref_unsafe(&refs->base, "HEAD", - RESOLVE_REF_READING, - NULL, &head_flag); - if (head_ref && (head_flag & REF_ISSYMREF) && - !strcmp(head_ref, lock->ref_name)) { - struct strbuf log_err = STRBUF_INIT; - if (files_log_ref_write(refs, "HEAD", - &lock->old_oid, oid, - logmsg, 0, &log_err)) { - error("%s", log_err.buf); - strbuf_release(&log_err); - } - } - } - - if (commit_ref(lock)) { - strbuf_addf(err, "couldn't set '%s'", lock->ref_name); - unlock_ref(lock); - return -1; - } - - unlock_ref(lock); - return 0; -} - -static int create_ref_symlink(struct ref_lock *lock, const char *target) -{ - int ret = -1; -#ifndef NO_SYMLINK_HEAD - char *ref_path = get_locked_file_path(&lock->lk); - unlink(ref_path); - ret = symlink(target, ref_path); - free(ref_path); - - if (ret) - fprintf(stderr, "no symlink - falling back to symbolic ref\n"); -#endif - return ret; -} - -static void update_symref_reflog(struct files_ref_store *refs, - struct ref_lock *lock, const char *refname, - const char *target, const char *logmsg) -{ - struct strbuf err = STRBUF_INIT; - struct object_id new_oid; - if (logmsg && - !refs_read_ref_full(&refs->base, target, - RESOLVE_REF_READING, &new_oid, NULL) && - files_log_ref_write(refs, refname, &lock->old_oid, - &new_oid, logmsg, 0, &err)) { - error("%s", err.buf); - strbuf_release(&err); - } -} - -static int create_symref_locked(struct files_ref_store *refs, - struct ref_lock *lock, const char *refname, - const char *target, const char *logmsg) -{ - if (prefer_symlink_refs && !create_ref_symlink(lock, target)) { - update_symref_reflog(refs, lock, refname, target, logmsg); - return 0; - } - - if (!fdopen_lock_file(&lock->lk, "w")) - return error("unable to fdopen %s: %s", - lock->lk.tempfile->filename.buf, strerror(errno)); - - update_symref_reflog(refs, lock, refname, target, logmsg); - - /* no error check; commit_ref will check ferror */ - fprintf(lock->lk.tempfile->fp, "ref: %s\n", target); - if (commit_ref(lock) < 0) - return error("unable to write symref for %s: %s", refname, - strerror(errno)); - return 0; -} - -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, REF_STORE_WRITE, "create_symref"); - struct strbuf err = STRBUF_INIT; - struct ref_lock *lock; - int ret; - - lock = lock_ref_oid_basic(refs, refname, NULL, - NULL, NULL, REF_NO_DEREF, NULL, - &err); - if (!lock) { - error("%s", err.buf); - strbuf_release(&err); - return -1; - } - - ret = create_symref_locked(refs, lock, refname, target, logmsg); - unlock_ref(lock); - return ret; -} - -static int files_reflog_exists(struct ref_store *ref_store, - const char *refname) -{ - struct files_ref_store *refs = - files_downcast(ref_store, REF_STORE_READ, "reflog_exists"); - struct strbuf sb = STRBUF_INIT; - struct stat st; - int ret; - - files_reflog_path(refs, &sb, refname); - ret = !lstat(sb.buf, &st) && S_ISREG(st.st_mode); - strbuf_release(&sb); - return ret; -} - -static int files_delete_reflog(struct ref_store *ref_store, - const char *refname) -{ - struct files_ref_store *refs = - files_downcast(ref_store, REF_STORE_WRITE, "delete_reflog"); - struct strbuf sb = STRBUF_INIT; - int ret; - - files_reflog_path(refs, &sb, refname); - ret = remove_path(sb.buf); - strbuf_release(&sb); - return ret; -} - -static int show_one_reflog_ent(struct strbuf *sb, each_reflog_ent_fn fn, void *cb_data) -{ - struct object_id ooid, noid; - char *email_end, *message; - timestamp_t timestamp; - int tz; - const char *p = sb->buf; - - /* old SP new SP name <email> SP time TAB msg LF */ - if (!sb->len || sb->buf[sb->len - 1] != '\n' || - parse_oid_hex(p, &ooid, &p) || *p++ != ' ' || - parse_oid_hex(p, &noid, &p) || *p++ != ' ' || - !(email_end = strchr(p, '>')) || - email_end[1] != ' ' || - !(timestamp = parse_timestamp(email_end + 2, &message, 10)) || - !message || message[0] != ' ' || - (message[1] != '+' && message[1] != '-') || - !isdigit(message[2]) || !isdigit(message[3]) || - !isdigit(message[4]) || !isdigit(message[5])) - return 0; /* corrupt? */ - email_end[1] = '\0'; - tz = strtol(message + 1, NULL, 10); - if (message[6] != '\t') - message += 6; - else - message += 7; - return fn(&ooid, &noid, p, timestamp, tz, message, cb_data); -} - -static char *find_beginning_of_line(char *bob, char *scan) -{ - while (bob < scan && *(--scan) != '\n') - ; /* keep scanning backwards */ - /* - * Return either beginning of the buffer, or LF at the end of - * the previous line. - */ - return scan; -} - -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 files_ref_store *refs = - files_downcast(ref_store, REF_STORE_READ, - "for_each_reflog_ent_reverse"); - struct strbuf sb = STRBUF_INIT; - FILE *logfp; - long pos; - int ret = 0, at_tail = 1; - - files_reflog_path(refs, &sb, refname); - logfp = fopen(sb.buf, "r"); - strbuf_release(&sb); - if (!logfp) - return -1; - - /* Jump to the end */ - if (fseek(logfp, 0, SEEK_END) < 0) - ret = error("cannot seek back reflog for %s: %s", - refname, strerror(errno)); - pos = ftell(logfp); - while (!ret && 0 < pos) { - int cnt; - size_t nread; - char buf[BUFSIZ]; - char *endp, *scanp; - - /* Fill next block from the end */ - cnt = (sizeof(buf) < pos) ? sizeof(buf) : pos; - if (fseek(logfp, pos - cnt, SEEK_SET)) { - ret = error("cannot seek back reflog for %s: %s", - refname, strerror(errno)); - break; - } - nread = fread(buf, cnt, 1, logfp); - if (nread != 1) { - ret = error("cannot read %d bytes from reflog for %s: %s", - cnt, refname, strerror(errno)); - break; - } - pos -= cnt; - - scanp = endp = buf + cnt; - if (at_tail && scanp[-1] == '\n') - /* Looking at the final LF at the end of the file */ - scanp--; - at_tail = 0; - - while (buf < scanp) { - /* - * terminating LF of the previous line, or the beginning - * of the buffer. - */ - char *bp; - - bp = find_beginning_of_line(buf, scanp); - - if (*bp == '\n') { - /* - * The newline is the end of the previous line, - * so we know we have complete line starting - * at (bp + 1). Prefix it onto any prior data - * we collected for the line and process it. - */ - strbuf_splice(&sb, 0, 0, bp + 1, endp - (bp + 1)); - scanp = bp; - endp = bp + 1; - ret = show_one_reflog_ent(&sb, fn, cb_data); - strbuf_reset(&sb); - if (ret) - break; - } else if (!pos) { - /* - * We are at the start of the buffer, and the - * start of the file; there is no previous - * line, and we have everything for this one. - * Process it, and we can end the loop. - */ - strbuf_splice(&sb, 0, 0, buf, endp - buf); - ret = show_one_reflog_ent(&sb, fn, cb_data); - strbuf_reset(&sb); - break; - } - - if (bp == buf) { - /* - * We are at the start of the buffer, and there - * is more file to read backwards. Which means - * we are in the middle of a line. Note that we - * may get here even if *bp was a newline; that - * just means we are at the exact end of the - * previous line, rather than some spot in the - * middle. - * - * Save away what we have to be combined with - * the data from the next read. - */ - strbuf_splice(&sb, 0, 0, buf, endp - buf); - break; - } - } - - } - if (!ret && sb.len) - BUG("reverse reflog parser had leftover data"); - - fclose(logfp); - strbuf_release(&sb); - return ret; -} - -static int files_for_each_reflog_ent(struct ref_store *ref_store, - const char *refname, - each_reflog_ent_fn fn, void *cb_data) -{ - struct files_ref_store *refs = - files_downcast(ref_store, REF_STORE_READ, - "for_each_reflog_ent"); - FILE *logfp; - struct strbuf sb = STRBUF_INIT; - int ret = 0; - - files_reflog_path(refs, &sb, refname); - logfp = fopen(sb.buf, "r"); - strbuf_release(&sb); - if (!logfp) - return -1; - - while (!ret && !strbuf_getwholeline(&sb, logfp, '\n')) - ret = show_one_reflog_ent(&sb, fn, cb_data); - fclose(logfp); - strbuf_release(&sb); - return ret; -} - -struct files_reflog_iterator { - struct ref_iterator base; - - struct ref_store *ref_store; - struct dir_iterator *dir_iterator; - struct object_id oid; -}; - -static int files_reflog_iterator_advance(struct ref_iterator *ref_iterator) -{ - struct files_reflog_iterator *iter = - (struct files_reflog_iterator *)ref_iterator; - struct dir_iterator *diter = iter->dir_iterator; - int ok; - - while ((ok = dir_iterator_advance(diter)) == ITER_OK) { - int flags; - - if (!S_ISREG(diter->st.st_mode)) - continue; - if (diter->basename[0] == '.') - continue; - if (ends_with(diter->basename, ".lock")) - continue; - - if (refs_read_ref_full(iter->ref_store, - diter->relative_path, 0, - &iter->oid, &flags)) { - error("bad ref for %s", diter->path.buf); - continue; - } - - iter->base.refname = diter->relative_path; - iter->base.oid = &iter->oid; - iter->base.flags = flags; - return ITER_OK; - } - - iter->dir_iterator = NULL; - if (ref_iterator_abort(ref_iterator) == ITER_ERROR) - ok = ITER_ERROR; - return ok; -} - -static int files_reflog_iterator_peel(struct ref_iterator *ref_iterator, - struct object_id *peeled) -{ - BUG("ref_iterator_peel() called for reflog_iterator"); -} - -static int files_reflog_iterator_abort(struct ref_iterator *ref_iterator) -{ - struct files_reflog_iterator *iter = - (struct files_reflog_iterator *)ref_iterator; - int ok = ITER_DONE; - - if (iter->dir_iterator) - ok = dir_iterator_abort(iter->dir_iterator); - - base_ref_iterator_free(ref_iterator); - return ok; -} - -static struct ref_iterator_vtable files_reflog_iterator_vtable = { - files_reflog_iterator_advance, - files_reflog_iterator_peel, - files_reflog_iterator_abort -}; - -static struct ref_iterator *reflog_iterator_begin(struct ref_store *ref_store, - const char *gitdir) -{ - struct dir_iterator *diter; - struct files_reflog_iterator *iter; - struct ref_iterator *ref_iterator; - struct strbuf sb = STRBUF_INIT; - - strbuf_addf(&sb, "%s/logs", gitdir); - - diter = dir_iterator_begin(sb.buf, 0); - if (!diter) { - strbuf_release(&sb); - return empty_ref_iterator_begin(); - } - - iter = xcalloc(1, sizeof(*iter)); - ref_iterator = &iter->base; - - base_ref_iterator_init(ref_iterator, &files_reflog_iterator_vtable, 0); - iter->dir_iterator = diter; - iter->ref_store = ref_store; - strbuf_release(&sb); - - return ref_iterator; -} - -static enum iterator_selection reflog_iterator_select( - struct ref_iterator *iter_worktree, - struct ref_iterator *iter_common, - void *cb_data) -{ - if (iter_worktree) { - /* - * We're a bit loose here. We probably should ignore - * common refs if they are accidentally added as - * per-worktree refs. - */ - return ITER_SELECT_0; - } else if (iter_common) { - if (ref_type(iter_common->refname) == REF_TYPE_NORMAL) - return ITER_SELECT_1; - - /* - * The main ref store may contain main worktree's - * per-worktree refs, which should be ignored - */ - return ITER_SKIP_1; - } else - return ITER_DONE; -} - -static struct ref_iterator *files_reflog_iterator_begin(struct ref_store *ref_store) -{ - struct files_ref_store *refs = - files_downcast(ref_store, REF_STORE_READ, - "reflog_iterator_begin"); - - if (!strcmp(refs->gitdir, refs->gitcommondir)) { - return reflog_iterator_begin(ref_store, refs->gitcommondir); - } else { - return merge_ref_iterator_begin( - 0, - reflog_iterator_begin(ref_store, refs->gitdir), - reflog_iterator_begin(ref_store, refs->gitcommondir), - reflog_iterator_select, refs); - } -} - -/* - * If update is a direct update of head_ref (the reference pointed to - * by HEAD), then add an extra REF_LOG_ONLY update for HEAD. - */ -static int split_head_update(struct ref_update *update, - struct ref_transaction *transaction, - const char *head_ref, - struct string_list *affected_refnames, - struct strbuf *err) -{ - struct string_list_item *item; - struct ref_update *new_update; - - if ((update->flags & REF_LOG_ONLY) || - (update->flags & REF_IS_PRUNING) || - (update->flags & REF_UPDATE_VIA_HEAD)) - return 0; - - if (strcmp(update->refname, head_ref)) - return 0; - - /* - * First make sure that HEAD is not already in the - * transaction. This check is O(lg N) in the transaction - * size, but it happens at most once per transaction. - */ - if (string_list_has_string(affected_refnames, "HEAD")) { - /* An entry already existed */ - strbuf_addf(err, - "multiple updates for 'HEAD' (including one " - "via its referent '%s') are not allowed", - update->refname); - return TRANSACTION_NAME_CONFLICT; - } - - new_update = ref_transaction_add_update( - transaction, "HEAD", - update->flags | REF_LOG_ONLY | REF_NO_DEREF, - &update->new_oid, &update->old_oid, - update->msg); - - /* - * Add "HEAD". This insertion is O(N) in the transaction - * size, but it happens at most once per transaction. - * Add new_update->refname instead of a literal "HEAD". - */ - if (strcmp(new_update->refname, "HEAD")) - BUG("%s unexpectedly not 'HEAD'", new_update->refname); - item = string_list_insert(affected_refnames, new_update->refname); - item->util = new_update; - - return 0; -} - -/* - * update is for a symref that points at referent and doesn't have - * REF_NO_DEREF set. Split it into two updates: - * - The original update, but with REF_LOG_ONLY and REF_NO_DEREF set - * - A new, separate update for the referent reference - * 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, - const char *referent, - struct ref_transaction *transaction, - struct string_list *affected_refnames, - struct strbuf *err) -{ - struct string_list_item *item; - struct ref_update *new_update; - unsigned int new_flags; - - /* - * First make sure that referent is not already in the - * transaction. This check is O(lg N) in the transaction - * size, but it happens at most once per symref in a - * transaction. - */ - if (string_list_has_string(affected_refnames, referent)) { - /* An entry already exists */ - strbuf_addf(err, - "multiple updates for '%s' (including one " - "via symref '%s') are not allowed", - referent, update->refname); - return TRANSACTION_NAME_CONFLICT; - } - - new_flags = update->flags; - if (!strcmp(update->refname, "HEAD")) { - /* - * Record that the new update came via HEAD, so that - * when we process it, split_head_update() doesn't try - * to add another reflog update for HEAD. Note that - * this bit will be propagated if the new_update - * itself needs to be split. - */ - new_flags |= REF_UPDATE_VIA_HEAD; - } - - new_update = ref_transaction_add_update( - transaction, referent, new_flags, - &update->new_oid, &update->old_oid, - update->msg); - - new_update->parent_update = update; - - /* - * Change the symbolic ref update to log only. Also, it - * doesn't need to check its old OID value, as that will be - * done when new_update is processed. - */ - update->flags |= REF_LOG_ONLY | REF_NO_DEREF; - update->flags &= ~REF_HAVE_OLD; - - /* - * Add the referent. This insertion is O(N) in the transaction - * size, but it happens at most once per symref in a - * transaction. Make sure to add new_update->refname, which will - * be valid as long as affected_refnames is in use, and NOT - * referent, which might soon be freed by our caller. - */ - item = string_list_insert(affected_refnames, new_update->refname); - if (item->util) - BUG("%s unexpectedly found in affected_refnames", - new_update->refname); - item->util = new_update; - - return 0; -} - -/* - * Return the refname under which update was originally requested. - */ -static const char *original_update_refname(struct ref_update *update) -{ - while (update->parent_update) - update = update->parent_update; - - return update->refname; -} - -/* - * Check whether the REF_HAVE_OLD and old_oid values stored in update - * are consistent with oid, which is the reference's current value. If - * everything is OK, return 0; otherwise, write an error message to - * err and return -1. - */ -static int check_old_oid(struct ref_update *update, struct object_id *oid, - struct strbuf *err) -{ - if (!(update->flags & REF_HAVE_OLD) || - oideq(oid, &update->old_oid)) - return 0; - - if (is_null_oid(&update->old_oid)) - strbuf_addf(err, "cannot lock ref '%s': " - "reference already exists", - original_update_refname(update)); - else if (is_null_oid(oid)) - strbuf_addf(err, "cannot lock ref '%s': " - "reference is missing but expected %s", - original_update_refname(update), - oid_to_hex(&update->old_oid)); - else - strbuf_addf(err, "cannot lock ref '%s': " - "is at %s but expected %s", - original_update_refname(update), - oid_to_hex(oid), - oid_to_hex(&update->old_oid)); - - return -1; -} - -/* - * Prepare for carrying out update: - * - Lock the reference referred to by update. - * - Read the reference under lock. - * - Check that its old OID value (if specified) is correct, and in - * any case record it in update->lock->old_oid for later use when - * writing the reflog. - * - If it is a symref update without REF_NO_DEREF, split it up into a - * REF_LOG_ONLY update of the symref and add a separate update for - * the referent to transaction. - * - If it is an update of head_ref, add a corresponding REF_LOG_ONLY - * update of HEAD. - */ -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 strbuf referent = STRBUF_INIT; - int mustexist = (update->flags & REF_HAVE_OLD) && - !is_null_oid(&update->old_oid); - int ret = 0; - struct ref_lock *lock; - - files_assert_main_repository(refs, "lock_ref_for_update"); - - if ((update->flags & REF_HAVE_NEW) && is_null_oid(&update->new_oid)) - update->flags |= REF_DELETING; - - if (head_ref) { - ret = split_head_update(update, transaction, head_ref, - affected_refnames, err); - if (ret) - goto out; - } - - ret = lock_raw_ref(refs, update->refname, mustexist, - affected_refnames, NULL, - &lock, &referent, - &update->type, err); - if (ret) { - char *reason; - - reason = strbuf_detach(err, NULL); - strbuf_addf(err, "cannot lock ref '%s': %s", - original_update_refname(update), reason); - free(reason); - goto out; - } - - update->backend_data = lock; - - if (update->type & REF_ISSYMREF) { - if (update->flags & REF_NO_DEREF) { - /* - * We won't be reading the referent as part of - * the transaction, so we have to read it here - * to record and possibly check old_oid: - */ - if (refs_read_ref_full(&refs->base, - referent.buf, 0, - &lock->old_oid, NULL)) { - if (update->flags & REF_HAVE_OLD) { - strbuf_addf(err, "cannot lock ref '%s': " - "error reading reference", - original_update_refname(update)); - ret = TRANSACTION_GENERIC_ERROR; - goto out; - } - } else if (check_old_oid(update, &lock->old_oid, err)) { - ret = TRANSACTION_GENERIC_ERROR; - goto out; - } - } else { - /* - * Create a new update for the reference this - * symref is pointing at. Also, we will record - * and verify old_oid for this update as part - * of processing the split-off update, so we - * don't have to do it here. - */ - ret = split_symref_update(update, - referent.buf, transaction, - affected_refnames, err); - if (ret) - goto out; - } - } else { - struct ref_update *parent_update; - - if (check_old_oid(update, &lock->old_oid, err)) { - ret = TRANSACTION_GENERIC_ERROR; - goto out; - } - - /* - * If this update is happening indirectly because of a - * symref update, record the old OID in the parent - * update: - */ - for (parent_update = update->parent_update; - parent_update; - parent_update = parent_update->parent_update) { - struct ref_lock *parent_lock = parent_update->backend_data; - oidcpy(&parent_lock->old_oid, &lock->old_oid); - } - } - - if ((update->flags & REF_HAVE_NEW) && - !(update->flags & REF_DELETING) && - !(update->flags & REF_LOG_ONLY)) { - if (!(update->type & REF_ISSYMREF) && - oideq(&lock->old_oid, &update->new_oid)) { - /* - * The reference already has the desired - * value, so we don't need to write it. - */ - } else if (write_ref_to_lockfile(lock, &update->new_oid, - err)) { - char *write_err = strbuf_detach(err, NULL); - - /* - * The lock was freed upon failure of - * write_ref_to_lockfile(): - */ - update->backend_data = NULL; - strbuf_addf(err, - "cannot update ref '%s': %s", - update->refname, write_err); - free(write_err); - ret = TRANSACTION_GENERIC_ERROR; - goto out; - } else { - update->flags |= REF_NEEDS_COMMIT; - } - } - if (!(update->flags & REF_NEEDS_COMMIT)) { - /* - * We didn't call write_ref_to_lockfile(), so - * the lockfile is still open. Close it to - * free up the file descriptor: - */ - if (close_ref_gently(lock)) { - strbuf_addf(err, "couldn't close '%s.lock'", - update->refname); - ret = TRANSACTION_GENERIC_ERROR; - goto out; - } - } - -out: - strbuf_release(&referent); - return ret; -} - -struct files_transaction_backend_data { - struct ref_transaction *packed_transaction; - int packed_refs_locked; -}; - -/* - * Unlock any references in `transaction` that are still locked, and - * mark the transaction closed. - */ -static void files_transaction_cleanup(struct files_ref_store *refs, - struct ref_transaction *transaction) -{ - size_t i; - struct files_transaction_backend_data *backend_data = - transaction->backend_data; - struct strbuf err = STRBUF_INIT; - - for (i = 0; i < transaction->nr; i++) { - struct ref_update *update = transaction->updates[i]; - struct ref_lock *lock = update->backend_data; - - if (lock) { - unlock_ref(lock); - update->backend_data = NULL; - } - } - - if (backend_data->packed_transaction && - ref_transaction_abort(backend_data->packed_transaction, &err)) { - error("error aborting transaction: %s", err.buf); - strbuf_release(&err); - } - - if (backend_data->packed_refs_locked) - packed_refs_unlock(refs->packed_ref_store); - - free(backend_data); - - transaction->state = REF_TRANSACTION_CLOSED; -} - -static int files_transaction_prepare(struct ref_store *ref_store, - struct ref_transaction *transaction, - struct strbuf *err) -{ - struct files_ref_store *refs = - files_downcast(ref_store, REF_STORE_WRITE, - "ref_transaction_prepare"); - size_t i; - int ret = 0; - struct string_list affected_refnames = STRING_LIST_INIT_NODUP; - char *head_ref = NULL; - int head_type; - struct files_transaction_backend_data *backend_data; - struct ref_transaction *packed_transaction = NULL; - - assert(err); - - if (!transaction->nr) - goto cleanup; - - backend_data = xcalloc(1, sizeof(*backend_data)); - transaction->backend_data = backend_data; - - /* - * Fail if a refname appears more than once in the - * transaction. (If we end up splitting up any updates using - * split_symref_update() or split_head_update(), those - * functions will check that the new updates don't have the - * same refname as any existing ones.) Also fail if any of the - * updates use REF_IS_PRUNING without REF_NO_DEREF. - */ - for (i = 0; i < transaction->nr; i++) { - struct ref_update *update = transaction->updates[i]; - struct string_list_item *item = - string_list_append(&affected_refnames, update->refname); - - if ((update->flags & REF_IS_PRUNING) && - !(update->flags & REF_NO_DEREF)) - BUG("REF_IS_PRUNING set without REF_NO_DEREF"); - - /* - * We store a pointer to update in item->util, but at - * the moment we never use the value of this field - * except to check whether it is non-NULL. - */ - item->util = update; - } - string_list_sort(&affected_refnames); - if (ref_update_reject_duplicates(&affected_refnames, err)) { - ret = TRANSACTION_GENERIC_ERROR; - goto cleanup; - } - - /* - * Special hack: If a branch is updated directly and HEAD - * points to it (may happen on the remote side of a push - * for example) then logically the HEAD reflog should be - * updated too. - * - * A generic solution would require reverse symref lookups, - * but finding all symrefs pointing to a given branch would be - * rather costly for this rare event (the direct update of a - * branch) to be worth it. So let's cheat and check with HEAD - * only, which should cover 99% of all usage scenarios (even - * 100% of the default ones). - * - * So if HEAD is a symbolic reference, then record the name of - * the reference that it points to. If we see an update of - * head_ref within the transaction, then split_head_update() - * arranges for the reflog of HEAD to be updated, too. - */ - head_ref = refs_resolve_refdup(ref_store, "HEAD", - RESOLVE_REF_NO_RECURSE, - NULL, &head_type); - - if (head_ref && !(head_type & REF_ISSYMREF)) { - FREE_AND_NULL(head_ref); - } - - /* - * Acquire all locks, verify old values if provided, check - * that new values are valid, and write new values to the - * lockfiles, ready to be activated. Only keep one lockfile - * open at a time to avoid running out of file descriptors. - * Note that lock_ref_for_update() might append more updates - * to the transaction. - */ - for (i = 0; i < transaction->nr; i++) { - struct ref_update *update = transaction->updates[i]; - - ret = lock_ref_for_update(refs, update, transaction, - head_ref, &affected_refnames, err); - if (ret) - goto cleanup; - - if (update->flags & REF_DELETING && - !(update->flags & REF_LOG_ONLY) && - !(update->flags & REF_IS_PRUNING)) { - /* - * This reference has to be deleted from - * packed-refs if it exists there. - */ - if (!packed_transaction) { - packed_transaction = ref_store_transaction_begin( - refs->packed_ref_store, err); - if (!packed_transaction) { - ret = TRANSACTION_GENERIC_ERROR; - goto cleanup; - } - - backend_data->packed_transaction = - packed_transaction; - } - - ref_transaction_add_update( - packed_transaction, update->refname, - REF_HAVE_NEW | REF_NO_DEREF, - &update->new_oid, NULL, - NULL); - } - } - - if (packed_transaction) { - if (packed_refs_lock(refs->packed_ref_store, 0, err)) { - ret = TRANSACTION_GENERIC_ERROR; - goto cleanup; - } - backend_data->packed_refs_locked = 1; - - if (is_packed_transaction_needed(refs->packed_ref_store, - packed_transaction)) { - ret = ref_transaction_prepare(packed_transaction, err); - /* - * A failure during the prepare step will abort - * itself, but not free. Do that now, and disconnect - * from the files_transaction so it does not try to - * abort us when we hit the cleanup code below. - */ - if (ret) { - ref_transaction_free(packed_transaction); - backend_data->packed_transaction = NULL; - } - } else { - /* - * We can skip rewriting the `packed-refs` - * file. But we do need to leave it locked, so - * that somebody else doesn't pack a reference - * that we are trying to delete. - * - * We need to disconnect our transaction from - * backend_data, since the abort (whether successful or - * not) will free it. - */ - backend_data->packed_transaction = NULL; - if (ref_transaction_abort(packed_transaction, err)) { - ret = TRANSACTION_GENERIC_ERROR; - goto cleanup; - } - } - } - -cleanup: - free(head_ref); - string_list_clear(&affected_refnames, 0); - - if (ret) - files_transaction_cleanup(refs, transaction); - else - transaction->state = REF_TRANSACTION_PREPARED; - - return ret; -} - -static int files_transaction_finish(struct ref_store *ref_store, - struct ref_transaction *transaction, - struct strbuf *err) -{ - struct files_ref_store *refs = - files_downcast(ref_store, 0, "ref_transaction_finish"); - size_t i; - int ret = 0; - struct strbuf sb = STRBUF_INIT; - struct files_transaction_backend_data *backend_data; - struct ref_transaction *packed_transaction; - - - assert(err); - - if (!transaction->nr) { - transaction->state = REF_TRANSACTION_CLOSED; - return 0; - } - - backend_data = transaction->backend_data; - packed_transaction = backend_data->packed_transaction; - - /* 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->backend_data; - - if (update->flags & REF_NEEDS_COMMIT || - update->flags & REF_LOG_ONLY) { - if (files_log_ref_write(refs, - lock->ref_name, - &lock->old_oid, - &update->new_oid, - update->msg, update->flags, - err)) { - char *old_msg = strbuf_detach(err, NULL); - - strbuf_addf(err, "cannot update the ref '%s': %s", - lock->ref_name, old_msg); - free(old_msg); - unlock_ref(lock); - update->backend_data = NULL; - ret = TRANSACTION_GENERIC_ERROR; - goto cleanup; - } - } - if (update->flags & REF_NEEDS_COMMIT) { - clear_loose_ref_cache(refs); - if (commit_ref(lock)) { - strbuf_addf(err, "couldn't set '%s'", lock->ref_name); - unlock_ref(lock); - update->backend_data = NULL; - ret = TRANSACTION_GENERIC_ERROR; - goto cleanup; - } - } - } - - /* - * Now that updates are safely completed, we can perform - * deletes. First delete the reflogs of any references that - * will be deleted, since (in the unexpected event of an - * error) leaving a reference without a reflog is less bad - * than leaving a reflog without a reference (the latter is a - * mildly invalid repository state): - */ - for (i = 0; i < transaction->nr; i++) { - struct ref_update *update = transaction->updates[i]; - if (update->flags & REF_DELETING && - !(update->flags & REF_LOG_ONLY) && - !(update->flags & REF_IS_PRUNING)) { - strbuf_reset(&sb); - files_reflog_path(refs, &sb, update->refname); - if (!unlink_or_warn(sb.buf)) - try_remove_empty_parents(refs, update->refname, - REMOVE_EMPTY_PARENTS_REFLOG); - } - } - - /* - * Perform deletes now that updates are safely completed. - * - * First delete any packed versions of the references, while - * retaining the packed-refs lock: - */ - if (packed_transaction) { - ret = ref_transaction_commit(packed_transaction, err); - ref_transaction_free(packed_transaction); - packed_transaction = NULL; - backend_data->packed_transaction = NULL; - if (ret) - goto cleanup; - } - - /* Now delete the loose versions of the references: */ - 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 (!(update->type & REF_ISPACKED) || - update->type & REF_ISSYMREF) { - /* It is a loose reference. */ - strbuf_reset(&sb); - files_ref_path(refs, &sb, lock->ref_name); - if (unlink_or_msg(sb.buf, err)) { - ret = TRANSACTION_GENERIC_ERROR; - goto cleanup; - } - update->flags |= REF_DELETED_LOOSE; - } - } - } - - clear_loose_ref_cache(refs); - -cleanup: - files_transaction_cleanup(refs, transaction); - - for (i = 0; i < transaction->nr; i++) { - struct ref_update *update = transaction->updates[i]; - - if (update->flags & REF_DELETED_LOOSE) { - /* - * The loose reference was deleted. Delete any - * empty parent directories. (Note that this - * can only work because we have already - * removed the lockfile.) - */ - try_remove_empty_parents(refs, update->refname, - REMOVE_EMPTY_PARENTS_REF); - } - } - - strbuf_release(&sb); - return ret; -} - -static int files_transaction_abort(struct ref_store *ref_store, - struct ref_transaction *transaction, - struct strbuf *err) -{ - struct files_ref_store *refs = - files_downcast(ref_store, 0, "ref_transaction_abort"); - - files_transaction_cleanup(refs, transaction); - return 0; -} - -static int ref_present(const char *refname, - const struct object_id *oid, int flags, void *cb_data) -{ - struct string_list *affected_refnames = cb_data; - - return string_list_has_string(affected_refnames, refname); -} - -static int files_initial_transaction_commit(struct ref_store *ref_store, - struct ref_transaction *transaction, - struct strbuf *err) -{ - struct files_ref_store *refs = - files_downcast(ref_store, REF_STORE_WRITE, - "initial_ref_transaction_commit"); - size_t i; - int ret = 0; - struct string_list affected_refnames = STRING_LIST_INIT_NODUP; - struct ref_transaction *packed_transaction = NULL; - - assert(err); - - if (transaction->state != REF_TRANSACTION_OPEN) - BUG("commit called for transaction that is not open"); - - /* Fail if a refname appears more than once in the transaction: */ - for (i = 0; i < transaction->nr; i++) - string_list_append(&affected_refnames, - transaction->updates[i]->refname); - string_list_sort(&affected_refnames); - if (ref_update_reject_duplicates(&affected_refnames, err)) { - ret = TRANSACTION_GENERIC_ERROR; - goto cleanup; - } - - /* - * It's really undefined to call this function in an active - * repository or when there are existing references: we are - * only locking and changing packed-refs, so (1) any - * simultaneous processes might try to change a reference at - * the same time we do, and (2) any existing loose versions of - * the references that we are setting would have precedence - * over our values. But some remote helpers create the remote - * "HEAD" and "master" branches before calling this function, - * so here we really only check that none of the references - * that we are creating already exists. - */ - if (refs_for_each_rawref(&refs->base, ref_present, - &affected_refnames)) - BUG("initial ref transaction called with existing refs"); - - packed_transaction = ref_store_transaction_begin(refs->packed_ref_store, err); - if (!packed_transaction) { - ret = TRANSACTION_GENERIC_ERROR; - goto cleanup; - } - - for (i = 0; i < transaction->nr; i++) { - struct ref_update *update = transaction->updates[i]; - - if ((update->flags & REF_HAVE_OLD) && - !is_null_oid(&update->old_oid)) - BUG("initial ref transaction with old_sha1 set"); - if (refs_verify_refname_available(&refs->base, update->refname, - &affected_refnames, NULL, - err)) { - ret = TRANSACTION_NAME_CONFLICT; - goto cleanup; - } - - /* - * Add a reference creation for this reference to the - * packed-refs transaction: - */ - ref_transaction_add_update(packed_transaction, update->refname, - update->flags & ~REF_HAVE_OLD, - &update->new_oid, &update->old_oid, - NULL); - } - - if (packed_refs_lock(refs->packed_ref_store, 0, err)) { - ret = TRANSACTION_GENERIC_ERROR; - goto cleanup; - } - - if (initial_ref_transaction_commit(packed_transaction, err)) { - ret = TRANSACTION_GENERIC_ERROR; - } - - packed_refs_unlock(refs->packed_ref_store); -cleanup: - if (packed_transaction) - ref_transaction_free(packed_transaction); - transaction->state = REF_TRANSACTION_CLOSED; - string_list_clear(&affected_refnames, 0); - return ret; -} - -struct expire_reflog_cb { - unsigned int flags; - reflog_expiry_should_prune_fn *should_prune_fn; - void *policy_cb; - FILE *newlog; - struct object_id last_kept_oid; -}; - -static int expire_reflog_ent(struct object_id *ooid, struct object_id *noid, - const char *email, timestamp_t timestamp, int tz, - const char *message, void *cb_data) -{ - struct expire_reflog_cb *cb = cb_data; - struct expire_reflog_policy_cb *policy_cb = cb->policy_cb; - - if (cb->flags & EXPIRE_REFLOGS_REWRITE) - ooid = &cb->last_kept_oid; - - if ((*cb->should_prune_fn)(ooid, noid, email, timestamp, tz, - message, policy_cb)) { - if (!cb->newlog) - printf("would prune %s", message); - else if (cb->flags & EXPIRE_REFLOGS_VERBOSE) - printf("prune %s", message); - } else { - if (cb->newlog) { - fprintf(cb->newlog, "%s %s %s %"PRItime" %+05d\t%s", - oid_to_hex(ooid), oid_to_hex(noid), - email, timestamp, tz, message); - oidcpy(&cb->last_kept_oid, noid); - } - if (cb->flags & EXPIRE_REFLOGS_VERBOSE) - printf("keep %s", message); - } - return 0; -} - -static int files_reflog_expire(struct ref_store *ref_store, - const char *refname, const struct object_id *oid, - 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 = - files_downcast(ref_store, REF_STORE_WRITE, "reflog_expire"); - struct lock_file reflog_lock = LOCK_INIT; - struct expire_reflog_cb cb; - struct ref_lock *lock; - struct strbuf log_file_sb = STRBUF_INIT; - char *log_file; - int status = 0; - int type; - struct strbuf err = STRBUF_INIT; - - memset(&cb, 0, sizeof(cb)); - cb.flags = flags; - cb.policy_cb = policy_cb_data; - cb.should_prune_fn = should_prune_fn; - - /* - * The reflog file is locked by holding the lock on the - * reference itself, plus we might need to update the - * reference if --updateref was specified: - */ - lock = lock_ref_oid_basic(refs, refname, oid, - NULL, NULL, REF_NO_DEREF, - &type, &err); - if (!lock) { - error("cannot lock ref '%s': %s", refname, err.buf); - strbuf_release(&err); - return -1; - } - if (!refs_reflog_exists(ref_store, refname)) { - unlock_ref(lock); - return 0; - } - - files_reflog_path(refs, &log_file_sb, refname); - log_file = strbuf_detach(&log_file_sb, NULL); - if (!(flags & EXPIRE_REFLOGS_DRY_RUN)) { - /* - * Even though holding $GIT_DIR/logs/$reflog.lock has - * no locking implications, we use the lock_file - * machinery here anyway because it does a lot of the - * work we need, including cleaning up if the program - * exits unexpectedly. - */ - if (hold_lock_file_for_update(&reflog_lock, log_file, 0) < 0) { - struct strbuf err = STRBUF_INIT; - unable_to_lock_message(log_file, errno, &err); - error("%s", err.buf); - strbuf_release(&err); - goto failure; - } - cb.newlog = fdopen_lock_file(&reflog_lock, "w"); - if (!cb.newlog) { - error("cannot fdopen %s (%s)", - get_lock_file_path(&reflog_lock), strerror(errno)); - goto failure; - } - } - - (*prepare_fn)(refname, oid, cb.policy_cb); - refs_for_each_reflog_ent(ref_store, refname, expire_reflog_ent, &cb); - (*cleanup_fn)(cb.policy_cb); - - if (!(flags & EXPIRE_REFLOGS_DRY_RUN)) { - /* - * It doesn't make sense to adjust a reference pointed - * to by a symbolic ref based on expiring entries in - * the symbolic reference's reflog. Nor can we update - * a reference if there are no remaining reflog - * entries. - */ - int update = (flags & EXPIRE_REFLOGS_UPDATE_REF) && - !(type & REF_ISSYMREF) && - !is_null_oid(&cb.last_kept_oid); - - if (close_lock_file_gently(&reflog_lock)) { - status |= error("couldn't write %s: %s", log_file, - strerror(errno)); - rollback_lock_file(&reflog_lock); - } else if (update && - (write_in_full(get_lock_file_fd(&lock->lk), - oid_to_hex(&cb.last_kept_oid), the_hash_algo->hexsz) < 0 || - write_str_in_full(get_lock_file_fd(&lock->lk), "\n") < 0 || - close_ref_gently(lock) < 0)) { - status |= error("couldn't write %s", - get_lock_file_path(&lock->lk)); - rollback_lock_file(&reflog_lock); - } else if (commit_lock_file(&reflog_lock)) { - status |= error("unable to write reflog '%s' (%s)", - log_file, strerror(errno)); - } else if (update && commit_ref(lock)) { - status |= error("couldn't set %s", lock->ref_name); - } - } - free(log_file); - unlock_ref(lock); - return status; - - failure: - rollback_lock_file(&reflog_lock); - free(log_file); - unlock_ref(lock); - return -1; -} - -static int files_init_db(struct ref_store *ref_store, struct strbuf *err) -{ - struct files_ref_store *refs = - files_downcast(ref_store, REF_STORE_WRITE, "init_db"); - struct strbuf sb = STRBUF_INIT; - - /* - * Create .git/refs/{heads,tags} - */ - files_ref_path(refs, &sb, "refs/heads"); - safe_create_dir(sb.buf, 1); - - strbuf_reset(&sb); - files_ref_path(refs, &sb, "refs/tags"); - safe_create_dir(sb.buf, 1); - - strbuf_release(&sb); - return 0; -} - -struct ref_storage_be refs_be_files = { - NULL, - "files", - files_ref_store_create, - files_init_db, - files_transaction_prepare, - files_transaction_finish, - files_transaction_abort, - files_initial_transaction_commit, - - files_pack_refs, - files_create_symref, - files_delete_refs, - files_rename_ref, - files_copy_ref, - - files_ref_iterator_begin, - files_read_raw_ref, - - 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/third_party/git/refs/iterator.c b/third_party/git/refs/iterator.c deleted file mode 100644 index 629e00a122..0000000000 --- a/third_party/git/refs/iterator.c +++ /dev/null @@ -1,435 +0,0 @@ -/* - * Generic reference iterator infrastructure. See refs-internal.h for - * documentation about the design and use of reference iterators. - */ - -#include "cache.h" -#include "refs.h" -#include "refs/refs-internal.h" -#include "iterator.h" - -int ref_iterator_advance(struct ref_iterator *ref_iterator) -{ - return ref_iterator->vtable->advance(ref_iterator); -} - -int ref_iterator_peel(struct ref_iterator *ref_iterator, - struct object_id *peeled) -{ - return ref_iterator->vtable->peel(ref_iterator, peeled); -} - -int ref_iterator_abort(struct ref_iterator *ref_iterator) -{ - return ref_iterator->vtable->abort(ref_iterator); -} - -void base_ref_iterator_init(struct ref_iterator *iter, - struct ref_iterator_vtable *vtable, - int ordered) -{ - iter->vtable = vtable; - iter->ordered = !!ordered; - iter->refname = NULL; - iter->oid = NULL; - iter->flags = 0; -} - -void base_ref_iterator_free(struct ref_iterator *iter) -{ - /* Help make use-after-free bugs fail quickly: */ - iter->vtable = NULL; - free(iter); -} - -struct empty_ref_iterator { - struct ref_iterator base; -}; - -static int empty_ref_iterator_advance(struct ref_iterator *ref_iterator) -{ - return ref_iterator_abort(ref_iterator); -} - -static int empty_ref_iterator_peel(struct ref_iterator *ref_iterator, - struct object_id *peeled) -{ - BUG("peel called for empty iterator"); -} - -static int empty_ref_iterator_abort(struct ref_iterator *ref_iterator) -{ - base_ref_iterator_free(ref_iterator); - return ITER_DONE; -} - -static struct ref_iterator_vtable empty_ref_iterator_vtable = { - empty_ref_iterator_advance, - empty_ref_iterator_peel, - empty_ref_iterator_abort -}; - -struct ref_iterator *empty_ref_iterator_begin(void) -{ - struct empty_ref_iterator *iter = xcalloc(1, sizeof(*iter)); - struct ref_iterator *ref_iterator = &iter->base; - - base_ref_iterator_init(ref_iterator, &empty_ref_iterator_vtable, 1); - return ref_iterator; -} - -int is_empty_ref_iterator(struct ref_iterator *ref_iterator) -{ - return ref_iterator->vtable == &empty_ref_iterator_vtable; -} - -struct merge_ref_iterator { - struct ref_iterator base; - - struct ref_iterator *iter0, *iter1; - - ref_iterator_select_fn *select; - void *cb_data; - - /* - * A pointer to iter0 or iter1 (whichever is supplying the - * current value), or NULL if advance has not yet been called. - */ - struct ref_iterator **current; -}; - -static int merge_ref_iterator_advance(struct ref_iterator *ref_iterator) -{ - struct merge_ref_iterator *iter = - (struct merge_ref_iterator *)ref_iterator; - int ok; - - if (!iter->current) { - /* Initialize: advance both iterators to their first entries */ - if ((ok = ref_iterator_advance(iter->iter0)) != ITER_OK) { - iter->iter0 = NULL; - if (ok == ITER_ERROR) - goto error; - } - if ((ok = ref_iterator_advance(iter->iter1)) != ITER_OK) { - iter->iter1 = NULL; - if (ok == ITER_ERROR) - goto error; - } - } else { - /* - * Advance the current iterator past the just-used - * entry: - */ - if ((ok = ref_iterator_advance(*iter->current)) != ITER_OK) { - *iter->current = NULL; - if (ok == ITER_ERROR) - goto error; - } - } - - /* Loop until we find an entry that we can yield. */ - while (1) { - struct ref_iterator **secondary; - enum iterator_selection selection = - iter->select(iter->iter0, iter->iter1, iter->cb_data); - - if (selection == ITER_SELECT_DONE) { - return ref_iterator_abort(ref_iterator); - } else if (selection == ITER_SELECT_ERROR) { - ref_iterator_abort(ref_iterator); - return ITER_ERROR; - } - - if ((selection & ITER_CURRENT_SELECTION_MASK) == 0) { - iter->current = &iter->iter0; - secondary = &iter->iter1; - } else { - iter->current = &iter->iter1; - secondary = &iter->iter0; - } - - if (selection & ITER_SKIP_SECONDARY) { - if ((ok = ref_iterator_advance(*secondary)) != ITER_OK) { - *secondary = NULL; - if (ok == ITER_ERROR) - goto error; - } - } - - if (selection & ITER_YIELD_CURRENT) { - iter->base.refname = (*iter->current)->refname; - iter->base.oid = (*iter->current)->oid; - iter->base.flags = (*iter->current)->flags; - return ITER_OK; - } - } - -error: - ref_iterator_abort(ref_iterator); - return ITER_ERROR; -} - -static int merge_ref_iterator_peel(struct ref_iterator *ref_iterator, - struct object_id *peeled) -{ - struct merge_ref_iterator *iter = - (struct merge_ref_iterator *)ref_iterator; - - if (!iter->current) { - BUG("peel called before advance for merge iterator"); - } - return ref_iterator_peel(*iter->current, peeled); -} - -static int merge_ref_iterator_abort(struct ref_iterator *ref_iterator) -{ - struct merge_ref_iterator *iter = - (struct merge_ref_iterator *)ref_iterator; - int ok = ITER_DONE; - - if (iter->iter0) { - if (ref_iterator_abort(iter->iter0) != ITER_DONE) - ok = ITER_ERROR; - } - if (iter->iter1) { - if (ref_iterator_abort(iter->iter1) != ITER_DONE) - ok = ITER_ERROR; - } - base_ref_iterator_free(ref_iterator); - return ok; -} - -static struct ref_iterator_vtable merge_ref_iterator_vtable = { - merge_ref_iterator_advance, - merge_ref_iterator_peel, - merge_ref_iterator_abort -}; - -struct ref_iterator *merge_ref_iterator_begin( - int ordered, - struct ref_iterator *iter0, struct ref_iterator *iter1, - ref_iterator_select_fn *select, void *cb_data) -{ - struct merge_ref_iterator *iter = xcalloc(1, sizeof(*iter)); - struct ref_iterator *ref_iterator = &iter->base; - - /* - * We can't do the same kind of is_empty_ref_iterator()-style - * optimization here as overlay_ref_iterator_begin() does, - * because we don't know the semantics of the select function. - * It might, for example, implement "intersect" by passing - * references through only if they exist in both iterators. - */ - - base_ref_iterator_init(ref_iterator, &merge_ref_iterator_vtable, ordered); - iter->iter0 = iter0; - iter->iter1 = iter1; - iter->select = select; - iter->cb_data = cb_data; - iter->current = NULL; - return ref_iterator; -} - -/* - * A ref_iterator_select_fn that overlays the items from front on top - * of those from back (like loose refs over packed refs). See - * overlay_ref_iterator_begin(). - */ -static enum iterator_selection overlay_iterator_select( - struct ref_iterator *front, struct ref_iterator *back, - void *cb_data) -{ - int cmp; - - if (!back) - return front ? ITER_SELECT_0 : ITER_SELECT_DONE; - else if (!front) - return ITER_SELECT_1; - - cmp = strcmp(front->refname, back->refname); - - if (cmp < 0) - return ITER_SELECT_0; - else if (cmp > 0) - return ITER_SELECT_1; - else - return ITER_SELECT_0_SKIP_1; -} - -struct ref_iterator *overlay_ref_iterator_begin( - struct ref_iterator *front, struct ref_iterator *back) -{ - /* - * Optimization: if one of the iterators is empty, return the - * other one rather than incurring the overhead of wrapping - * them. - */ - if (is_empty_ref_iterator(front)) { - ref_iterator_abort(front); - return back; - } else if (is_empty_ref_iterator(back)) { - ref_iterator_abort(back); - return front; - } else if (!front->ordered || !back->ordered) { - BUG("overlay_ref_iterator requires ordered inputs"); - } - - return merge_ref_iterator_begin(1, front, back, - overlay_iterator_select, NULL); -} - -struct prefix_ref_iterator { - struct ref_iterator base; - - struct ref_iterator *iter0; - char *prefix; - int trim; -}; - -/* Return -1, 0, 1 if refname is before, inside, or after the prefix. */ -static int compare_prefix(const char *refname, const char *prefix) -{ - while (*prefix) { - if (*refname != *prefix) - return ((unsigned char)*refname < (unsigned char)*prefix) ? -1 : +1; - - refname++; - prefix++; - } - - return 0; -} - -static int prefix_ref_iterator_advance(struct ref_iterator *ref_iterator) -{ - struct prefix_ref_iterator *iter = - (struct prefix_ref_iterator *)ref_iterator; - int ok; - - while ((ok = ref_iterator_advance(iter->iter0)) == ITER_OK) { - int cmp = compare_prefix(iter->iter0->refname, iter->prefix); - - if (cmp < 0) - continue; - - if (cmp > 0) { - /* - * If the source iterator is ordered, then we - * can stop the iteration as soon as we see a - * refname that comes after the prefix: - */ - if (iter->iter0->ordered) { - ok = ref_iterator_abort(iter->iter0); - break; - } else { - continue; - } - } - - if (iter->trim) { - /* - * It is nonsense to trim off characters that - * you haven't already checked for via a - * prefix check, whether via this - * `prefix_ref_iterator` or upstream in - * `iter0`). So if there wouldn't be at least - * one character left in the refname after - * trimming, report it as a bug: - */ - if (strlen(iter->iter0->refname) <= iter->trim) - BUG("attempt to trim too many characters"); - iter->base.refname = iter->iter0->refname + iter->trim; - } else { - iter->base.refname = iter->iter0->refname; - } - - iter->base.oid = iter->iter0->oid; - iter->base.flags = iter->iter0->flags; - return ITER_OK; - } - - iter->iter0 = NULL; - if (ref_iterator_abort(ref_iterator) != ITER_DONE) - return ITER_ERROR; - return ok; -} - -static int prefix_ref_iterator_peel(struct ref_iterator *ref_iterator, - struct object_id *peeled) -{ - struct prefix_ref_iterator *iter = - (struct prefix_ref_iterator *)ref_iterator; - - return ref_iterator_peel(iter->iter0, peeled); -} - -static int prefix_ref_iterator_abort(struct ref_iterator *ref_iterator) -{ - struct prefix_ref_iterator *iter = - (struct prefix_ref_iterator *)ref_iterator; - int ok = ITER_DONE; - - if (iter->iter0) - ok = ref_iterator_abort(iter->iter0); - free(iter->prefix); - base_ref_iterator_free(ref_iterator); - return ok; -} - -static struct ref_iterator_vtable prefix_ref_iterator_vtable = { - prefix_ref_iterator_advance, - prefix_ref_iterator_peel, - prefix_ref_iterator_abort -}; - -struct ref_iterator *prefix_ref_iterator_begin(struct ref_iterator *iter0, - const char *prefix, - int trim) -{ - struct prefix_ref_iterator *iter; - struct ref_iterator *ref_iterator; - - if (!*prefix && !trim) - return iter0; /* optimization: no need to wrap iterator */ - - iter = xcalloc(1, sizeof(*iter)); - ref_iterator = &iter->base; - - base_ref_iterator_init(ref_iterator, &prefix_ref_iterator_vtable, iter0->ordered); - - iter->iter0 = iter0; - iter->prefix = xstrdup(prefix); - iter->trim = trim; - - return ref_iterator; -} - -struct ref_iterator *current_ref_iter = NULL; - -int do_for_each_repo_ref_iterator(struct repository *r, struct ref_iterator *iter, - each_repo_ref_fn fn, void *cb_data) -{ - int retval = 0, ok; - struct ref_iterator *old_ref_iter = current_ref_iter; - - current_ref_iter = iter; - while ((ok = ref_iterator_advance(iter)) == ITER_OK) { - retval = fn(r, iter->refname, iter->oid, iter->flags, cb_data); - if (retval) { - /* - * If ref_iterator_abort() returns ITER_ERROR, - * we ignore that error in deference to the - * callback function's return value. - */ - ref_iterator_abort(iter); - goto out; - } - } - -out: - current_ref_iter = old_ref_iter; - if (ok == ITER_ERROR) - return -1; - return retval; -} diff --git a/third_party/git/refs/packed-backend.c b/third_party/git/refs/packed-backend.c deleted file mode 100644 index c01c7f5901..0000000000 --- a/third_party/git/refs/packed-backend.c +++ /dev/null @@ -1,1660 +0,0 @@ -#include "../cache.h" -#include "../config.h" -#include "../refs.h" -#include "refs-internal.h" -#include "packed-backend.h" -#include "../iterator.h" -#include "../lockfile.h" -#include "../chdir-notify.h" - -enum mmap_strategy { - /* - * Don't use mmap() at all for reading `packed-refs`. - */ - MMAP_NONE, - - /* - * Can use mmap() for reading `packed-refs`, but the file must - * not remain mmapped. This is the usual option on Windows, - * where you cannot rename a new version of a file onto a file - * that is currently mmapped. - */ - MMAP_TEMPORARY, - - /* - * It is OK to leave the `packed-refs` file mmapped while - * arbitrary other code is running. - */ - MMAP_OK -}; - -#if defined(NO_MMAP) -static enum mmap_strategy mmap_strategy = MMAP_NONE; -#elif defined(MMAP_PREVENTS_DELETE) -static enum mmap_strategy mmap_strategy = MMAP_TEMPORARY; -#else -static enum mmap_strategy mmap_strategy = MMAP_OK; -#endif - -struct packed_ref_store; - -/* - * A `snapshot` represents one snapshot of a `packed-refs` file. - * - * Normally, this will be a mmapped view of the contents of the - * `packed-refs` file at the time the snapshot was created. However, - * if the `packed-refs` file was not sorted, this might point at heap - * memory holding the contents of the `packed-refs` file with its - * records sorted by refname. - * - * `snapshot` instances are reference counted (via - * `acquire_snapshot()` and `release_snapshot()`). This is to prevent - * an instance from disappearing while an iterator is still iterating - * over it. Instances are garbage collected when their `referrers` - * count goes to zero. - * - * The most recent `snapshot`, if available, is referenced by the - * `packed_ref_store`. Its freshness is checked whenever - * `get_snapshot()` is called; if the existing snapshot is obsolete, a - * new snapshot is taken. - */ -struct snapshot { - /* - * A back-pointer to the packed_ref_store with which this - * snapshot is associated: - */ - struct packed_ref_store *refs; - - /* Is the `packed-refs` file currently mmapped? */ - int mmapped; - - /* - * The contents of the `packed-refs` file: - * - * - buf -- a pointer to the start of the memory - * - start -- a pointer to the first byte of actual references - * (i.e., after the header line, if one is present) - * - eof -- a pointer just past the end of the reference - * contents - * - * If the `packed-refs` file was already sorted, `buf` points - * at the mmapped contents of the file. If not, it points at - * heap-allocated memory containing the contents, sorted. If - * there were no contents (e.g., because the file didn't - * exist), `buf`, `start`, and `eof` are all NULL. - */ - char *buf, *start, *eof; - - /* - * What is the peeled state of the `packed-refs` file that - * this snapshot represents? (This is usually determined from - * the file's header.) - */ - enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled; - - /* - * Count of references to this instance, including the pointer - * from `packed_ref_store::snapshot`, if any. The instance - * will not be freed as long as the reference count is - * nonzero. - */ - unsigned int referrers; - - /* - * The metadata of the `packed-refs` file from which this - * snapshot was created, used to tell if the file has been - * replaced since we read it. - */ - struct stat_validity validity; -}; - -/* - * A `ref_store` representing references stored in a `packed-refs` - * file. It implements the `ref_store` interface, though it has some - * limitations: - * - * - It cannot store symbolic references. - * - * - It cannot store reflogs. - * - * - It does not support reference renaming (though it could). - * - * On the other hand, it can be locked outside of a reference - * transaction. In that case, it remains locked even after the - * transaction is done and the new `packed-refs` file is activated. - */ -struct packed_ref_store { - struct ref_store base; - - unsigned int store_flags; - - /* The path of the "packed-refs" file: */ - char *path; - - /* - * A snapshot of the values read from the `packed-refs` file, - * if it might still be current; otherwise, NULL. - */ - struct snapshot *snapshot; - - /* - * Lock used for the "packed-refs" file. Note that this (and - * thus the enclosing `packed_ref_store`) must not be freed. - */ - struct lock_file lock; - - /* - * Temporary file used when rewriting new contents to the - * "packed-refs" file. Note that this (and thus the enclosing - * `packed_ref_store`) must not be freed. - */ - struct tempfile *tempfile; -}; - -/* - * Increment the reference count of `*snapshot`. - */ -static void acquire_snapshot(struct snapshot *snapshot) -{ - snapshot->referrers++; -} - -/* - * If the buffer in `snapshot` is active, then either munmap the - * memory and close the file, or free the memory. Then set the buffer - * pointers to NULL. - */ -static void clear_snapshot_buffer(struct snapshot *snapshot) -{ - if (snapshot->mmapped) { - if (munmap(snapshot->buf, snapshot->eof - snapshot->buf)) - die_errno("error ummapping packed-refs file %s", - snapshot->refs->path); - snapshot->mmapped = 0; - } else { - free(snapshot->buf); - } - snapshot->buf = snapshot->start = snapshot->eof = NULL; -} - -/* - * Decrease the reference count of `*snapshot`. If it goes to zero, - * free `*snapshot` and return true; otherwise return false. - */ -static int release_snapshot(struct snapshot *snapshot) -{ - if (!--snapshot->referrers) { - stat_validity_clear(&snapshot->validity); - clear_snapshot_buffer(snapshot); - free(snapshot); - return 1; - } else { - return 0; - } -} - -struct ref_store *packed_ref_store_create(const char *path, - unsigned int store_flags) -{ - struct packed_ref_store *refs = xcalloc(1, sizeof(*refs)); - struct ref_store *ref_store = (struct ref_store *)refs; - - base_ref_store_init(ref_store, &refs_be_packed); - refs->store_flags = store_flags; - - refs->path = xstrdup(path); - chdir_notify_reparent("packed-refs", &refs->path); - - return ref_store; -} - -/* - * Downcast `ref_store` to `packed_ref_store`. Die if `ref_store` is - * not a `packed_ref_store`. Also die if `packed_ref_store` doesn't - * support at least the flags specified in `required_flags`. `caller` - * is used in any necessary error messages. - */ -static struct packed_ref_store *packed_downcast(struct ref_store *ref_store, - unsigned int required_flags, - const char *caller) -{ - struct packed_ref_store *refs; - - if (ref_store->be != &refs_be_packed) - BUG("ref_store is type \"%s\" not \"packed\" in %s", - ref_store->be->name, caller); - - refs = (struct packed_ref_store *)ref_store; - - if ((refs->store_flags & required_flags) != required_flags) - BUG("unallowed operation (%s), requires %x, has %x\n", - caller, required_flags, refs->store_flags); - - return refs; -} - -static void clear_snapshot(struct packed_ref_store *refs) -{ - if (refs->snapshot) { - struct snapshot *snapshot = refs->snapshot; - - refs->snapshot = NULL; - release_snapshot(snapshot); - } -} - -static NORETURN void die_unterminated_line(const char *path, - const char *p, size_t len) -{ - if (len < 80) - die("unterminated line in %s: %.*s", path, (int)len, p); - else - die("unterminated line in %s: %.75s...", path, p); -} - -static NORETURN void die_invalid_line(const char *path, - const char *p, size_t len) -{ - const char *eol = memchr(p, '\n', len); - - if (!eol) - die_unterminated_line(path, p, len); - else if (eol - p < 80) - die("unexpected line in %s: %.*s", path, (int)(eol - p), p); - else - die("unexpected line in %s: %.75s...", path, p); - -} - -struct snapshot_record { - const char *start; - size_t len; -}; - -static int cmp_packed_ref_records(const void *v1, const void *v2) -{ - const struct snapshot_record *e1 = v1, *e2 = v2; - const char *r1 = e1->start + the_hash_algo->hexsz + 1; - const char *r2 = e2->start + the_hash_algo->hexsz + 1; - - while (1) { - if (*r1 == '\n') - return *r2 == '\n' ? 0 : -1; - if (*r1 != *r2) { - if (*r2 == '\n') - return 1; - else - return (unsigned char)*r1 < (unsigned char)*r2 ? -1 : +1; - } - r1++; - r2++; - } -} - -/* - * Compare a snapshot record at `rec` to the specified NUL-terminated - * refname. - */ -static int cmp_record_to_refname(const char *rec, const char *refname) -{ - const char *r1 = rec + the_hash_algo->hexsz + 1; - const char *r2 = refname; - - while (1) { - if (*r1 == '\n') - return *r2 ? -1 : 0; - if (!*r2) - return 1; - if (*r1 != *r2) - return (unsigned char)*r1 < (unsigned char)*r2 ? -1 : +1; - r1++; - r2++; - } -} - -/* - * `snapshot->buf` is not known to be sorted. Check whether it is, and - * if not, sort it into new memory and munmap/free the old storage. - */ -static void sort_snapshot(struct snapshot *snapshot) -{ - struct snapshot_record *records = NULL; - size_t alloc = 0, nr = 0; - int sorted = 1; - const char *pos, *eof, *eol; - size_t len, i; - char *new_buffer, *dst; - - pos = snapshot->start; - eof = snapshot->eof; - - if (pos == eof) - return; - - len = eof - pos; - - /* - * Initialize records based on a crude estimate of the number - * of references in the file (we'll grow it below if needed): - */ - ALLOC_GROW(records, len / 80 + 20, alloc); - - while (pos < eof) { - eol = memchr(pos, '\n', eof - pos); - if (!eol) - /* The safety check should prevent this. */ - BUG("unterminated line found in packed-refs"); - if (eol - pos < the_hash_algo->hexsz + 2) - die_invalid_line(snapshot->refs->path, - pos, eof - pos); - eol++; - if (eol < eof && *eol == '^') { - /* - * Keep any peeled line together with its - * reference: - */ - const char *peeled_start = eol; - - eol = memchr(peeled_start, '\n', eof - peeled_start); - if (!eol) - /* The safety check should prevent this. */ - BUG("unterminated peeled line found in packed-refs"); - eol++; - } - - ALLOC_GROW(records, nr + 1, alloc); - records[nr].start = pos; - records[nr].len = eol - pos; - nr++; - - if (sorted && - nr > 1 && - cmp_packed_ref_records(&records[nr - 2], - &records[nr - 1]) >= 0) - sorted = 0; - - pos = eol; - } - - if (sorted) - goto cleanup; - - /* We need to sort the memory. First we sort the records array: */ - QSORT(records, nr, cmp_packed_ref_records); - - /* - * Allocate a new chunk of memory, and copy the old memory to - * the new in the order indicated by `records` (not bothering - * with the header line): - */ - new_buffer = xmalloc(len); - for (dst = new_buffer, i = 0; i < nr; i++) { - memcpy(dst, records[i].start, records[i].len); - dst += records[i].len; - } - - /* - * Now munmap the old buffer and use the sorted buffer in its - * place: - */ - clear_snapshot_buffer(snapshot); - snapshot->buf = snapshot->start = new_buffer; - snapshot->eof = new_buffer + len; - -cleanup: - free(records); -} - -/* - * Return a pointer to the start of the record that contains the - * character `*p` (which must be within the buffer). If no other - * record start is found, return `buf`. - */ -static const char *find_start_of_record(const char *buf, const char *p) -{ - while (p > buf && (p[-1] != '\n' || p[0] == '^')) - p--; - return p; -} - -/* - * Return a pointer to the start of the record following the record - * that contains `*p`. If none is found before `end`, return `end`. - */ -static const char *find_end_of_record(const char *p, const char *end) -{ - while (++p < end && (p[-1] != '\n' || p[0] == '^')) - ; - return p; -} - -/* - * We want to be able to compare mmapped reference records quickly, - * without totally parsing them. We can do so because the records are - * LF-terminated, and the refname should start exactly (GIT_SHA1_HEXSZ - * + 1) bytes past the beginning of the record. - * - * But what if the `packed-refs` file contains garbage? We're willing - * to tolerate not detecting the problem, as long as we don't produce - * totally garbled output (we can't afford to check the integrity of - * the whole file during every Git invocation). But we do want to be - * sure that we never read past the end of the buffer in memory and - * perform an illegal memory access. - * - * Guarantee that minimum level of safety by verifying that the last - * record in the file is LF-terminated, and that it has at least - * (GIT_SHA1_HEXSZ + 1) characters before the LF. Die if either of - * these checks fails. - */ -static void verify_buffer_safe(struct snapshot *snapshot) -{ - const char *start = snapshot->start; - const char *eof = snapshot->eof; - const char *last_line; - - if (start == eof) - return; - - last_line = find_start_of_record(start, eof - 1); - if (*(eof - 1) != '\n' || eof - last_line < the_hash_algo->hexsz + 2) - die_invalid_line(snapshot->refs->path, - last_line, eof - last_line); -} - -#define SMALL_FILE_SIZE (32*1024) - -/* - * Depending on `mmap_strategy`, either mmap or read the contents of - * the `packed-refs` file into the snapshot. Return 1 if the file - * existed and was read, or 0 if the file was absent or empty. Die on - * errors. - */ -static int load_contents(struct snapshot *snapshot) -{ - int fd; - struct stat st; - size_t size; - ssize_t bytes_read; - - fd = open(snapshot->refs->path, O_RDONLY); - if (fd < 0) { - if (errno == ENOENT) { - /* - * This is OK; it just means that no - * "packed-refs" file has been written yet, - * which is equivalent to it being empty, - * which is its state when initialized with - * zeros. - */ - return 0; - } else { - die_errno("couldn't read %s", snapshot->refs->path); - } - } - - stat_validity_update(&snapshot->validity, fd); - - if (fstat(fd, &st) < 0) - die_errno("couldn't stat %s", snapshot->refs->path); - size = xsize_t(st.st_size); - - if (!size) { - close(fd); - return 0; - } else if (mmap_strategy == MMAP_NONE || size <= SMALL_FILE_SIZE) { - snapshot->buf = xmalloc(size); - bytes_read = read_in_full(fd, snapshot->buf, size); - if (bytes_read < 0 || bytes_read != size) - die_errno("couldn't read %s", snapshot->refs->path); - snapshot->mmapped = 0; - } else { - snapshot->buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); - snapshot->mmapped = 1; - } - close(fd); - - snapshot->start = snapshot->buf; - snapshot->eof = snapshot->buf + size; - - return 1; -} - -/* - * Find the place in `snapshot->buf` where the start of the record for - * `refname` starts. If `mustexist` is true and the reference doesn't - * exist, then return NULL. If `mustexist` is false and the reference - * doesn't exist, then return the point where that reference would be - * inserted, or `snapshot->eof` (which might be NULL) if it would be - * inserted at the end of the file. In the latter mode, `refname` - * doesn't have to be a proper reference name; for example, one could - * search for "refs/replace/" to find the start of any replace - * references. - * - * The record is sought using a binary search, so `snapshot->buf` must - * be sorted. - */ -static const char *find_reference_location(struct snapshot *snapshot, - const char *refname, int mustexist) -{ - /* - * This is not *quite* a garden-variety binary search, because - * the data we're searching is made up of records, and we - * always need to find the beginning of a record to do a - * comparison. A "record" here is one line for the reference - * itself and zero or one peel lines that start with '^'. Our - * loop invariant is described in the next two comments. - */ - - /* - * A pointer to the character at the start of a record whose - * preceding records all have reference names that come - * *before* `refname`. - */ - const char *lo = snapshot->start; - - /* - * A pointer to a the first character of a record whose - * reference name comes *after* `refname`. - */ - const char *hi = snapshot->eof; - - while (lo != hi) { - const char *mid, *rec; - int cmp; - - mid = lo + (hi - lo) / 2; - rec = find_start_of_record(lo, mid); - cmp = cmp_record_to_refname(rec, refname); - if (cmp < 0) { - lo = find_end_of_record(mid, hi); - } else if (cmp > 0) { - hi = rec; - } else { - return rec; - } - } - - if (mustexist) - return NULL; - else - return lo; -} - -/* - * Create a newly-allocated `snapshot` of the `packed-refs` file in - * its current state and return it. The return value will already have - * its reference count incremented. - * - * A comment line of the form "# pack-refs with: " may contain zero or - * more traits. We interpret the traits as follows: - * - * Neither `peeled` nor `fully-peeled`: - * - * Probably no references are peeled. But if the file contains a - * peeled value for a reference, we will use it. - * - * `peeled`: - * - * References under "refs/tags/", if they *can* be peeled, *are* - * peeled in this file. References outside of "refs/tags/" are - * probably not peeled even if they could have been, but if we find - * a peeled value for such a reference we will use it. - * - * `fully-peeled`: - * - * All references in the file that can be peeled are peeled. - * Inversely (and this is more important), any references in the - * file for which no peeled value is recorded is not peelable. This - * trait should typically be written alongside "peeled" for - * compatibility with older clients, but we do not require it - * (i.e., "peeled" is a no-op if "fully-peeled" is set). - * - * `sorted`: - * - * The references in this file are known to be sorted by refname. - */ -static struct snapshot *create_snapshot(struct packed_ref_store *refs) -{ - struct snapshot *snapshot = xcalloc(1, sizeof(*snapshot)); - int sorted = 0; - - snapshot->refs = refs; - acquire_snapshot(snapshot); - snapshot->peeled = PEELED_NONE; - - if (!load_contents(snapshot)) - return snapshot; - - /* If the file has a header line, process it: */ - if (snapshot->buf < snapshot->eof && *snapshot->buf == '#') { - char *tmp, *p, *eol; - struct string_list traits = STRING_LIST_INIT_NODUP; - - eol = memchr(snapshot->buf, '\n', - snapshot->eof - snapshot->buf); - if (!eol) - die_unterminated_line(refs->path, - snapshot->buf, - snapshot->eof - snapshot->buf); - - tmp = xmemdupz(snapshot->buf, eol - snapshot->buf); - - if (!skip_prefix(tmp, "# pack-refs with:", (const char **)&p)) - die_invalid_line(refs->path, - snapshot->buf, - snapshot->eof - snapshot->buf); - - string_list_split_in_place(&traits, p, ' ', -1); - - if (unsorted_string_list_has_string(&traits, "fully-peeled")) - snapshot->peeled = PEELED_FULLY; - else if (unsorted_string_list_has_string(&traits, "peeled")) - snapshot->peeled = PEELED_TAGS; - - sorted = unsorted_string_list_has_string(&traits, "sorted"); - - /* perhaps other traits later as well */ - - /* The "+ 1" is for the LF character. */ - snapshot->start = eol + 1; - - string_list_clear(&traits, 0); - free(tmp); - } - - verify_buffer_safe(snapshot); - - if (!sorted) { - sort_snapshot(snapshot); - - /* - * Reordering the records might have moved a short one - * to the end of the buffer, so verify the buffer's - * safety again: - */ - verify_buffer_safe(snapshot); - } - - if (mmap_strategy != MMAP_OK && snapshot->mmapped) { - /* - * We don't want to leave the file mmapped, so we are - * forced to make a copy now: - */ - size_t size = snapshot->eof - snapshot->start; - char *buf_copy = xmalloc(size); - - memcpy(buf_copy, snapshot->start, size); - clear_snapshot_buffer(snapshot); - snapshot->buf = snapshot->start = buf_copy; - snapshot->eof = buf_copy + size; - } - - return snapshot; -} - -/* - * Check that `refs->snapshot` (if present) still reflects the - * contents of the `packed-refs` file. If not, clear the snapshot. - */ -static void validate_snapshot(struct packed_ref_store *refs) -{ - if (refs->snapshot && - !stat_validity_check(&refs->snapshot->validity, refs->path)) - clear_snapshot(refs); -} - -/* - * Get the `snapshot` for the specified packed_ref_store, creating and - * populating it if it hasn't been read before or if the file has been - * changed (according to its `validity` field) since it was last read. - * On the other hand, if we hold the lock, then assume that the file - * hasn't been changed out from under us, so skip the extra `stat()` - * call in `stat_validity_check()`. This function does *not* increase - * the snapshot's reference count on behalf of the caller. - */ -static struct snapshot *get_snapshot(struct packed_ref_store *refs) -{ - if (!is_lock_file_locked(&refs->lock)) - validate_snapshot(refs); - - if (!refs->snapshot) - refs->snapshot = create_snapshot(refs); - - return refs->snapshot; -} - -static int packed_read_raw_ref(struct ref_store *ref_store, - const char *refname, struct object_id *oid, - struct strbuf *referent, unsigned int *type) -{ - struct packed_ref_store *refs = - packed_downcast(ref_store, REF_STORE_READ, "read_raw_ref"); - struct snapshot *snapshot = get_snapshot(refs); - const char *rec; - - *type = 0; - - rec = find_reference_location(snapshot, refname, 1); - - if (!rec) { - /* refname is not a packed reference. */ - errno = ENOENT; - return -1; - } - - if (get_oid_hex(rec, oid)) - die_invalid_line(refs->path, rec, snapshot->eof - rec); - - *type = REF_ISPACKED; - return 0; -} - -/* - * This value is set in `base.flags` if the peeled value of the - * current reference is known. In that case, `peeled` contains the - * correct peeled value for the reference, which might be `null_oid` - * if the reference is not a tag or if it is broken. - */ -#define REF_KNOWS_PEELED 0x40 - -/* - * An iterator over a snapshot of a `packed-refs` file. - */ -struct packed_ref_iterator { - struct ref_iterator base; - - struct snapshot *snapshot; - - /* The current position in the snapshot's buffer: */ - const char *pos; - - /* The end of the part of the buffer that will be iterated over: */ - const char *eof; - - /* Scratch space for current values: */ - struct object_id oid, peeled; - struct strbuf refname_buf; - - unsigned int flags; -}; - -/* - * Move the iterator to the next record in the snapshot, without - * respect for whether the record is actually required by the current - * iteration. Adjust the fields in `iter` and return `ITER_OK` or - * `ITER_DONE`. This function does not free the iterator in the case - * of `ITER_DONE`. - */ -static int next_record(struct packed_ref_iterator *iter) -{ - const char *p = iter->pos, *eol; - - strbuf_reset(&iter->refname_buf); - - if (iter->pos == iter->eof) - return ITER_DONE; - - iter->base.flags = REF_ISPACKED; - - if (iter->eof - p < the_hash_algo->hexsz + 2 || - parse_oid_hex(p, &iter->oid, &p) || - !isspace(*p++)) - die_invalid_line(iter->snapshot->refs->path, - iter->pos, iter->eof - iter->pos); - - eol = memchr(p, '\n', iter->eof - p); - if (!eol) - die_unterminated_line(iter->snapshot->refs->path, - iter->pos, iter->eof - iter->pos); - - strbuf_add(&iter->refname_buf, p, eol - p); - iter->base.refname = iter->refname_buf.buf; - - if (check_refname_format(iter->base.refname, REFNAME_ALLOW_ONELEVEL)) { - if (!refname_is_safe(iter->base.refname)) - die("packed refname is dangerous: %s", - iter->base.refname); - oidclr(&iter->oid); - iter->base.flags |= REF_BAD_NAME | REF_ISBROKEN; - } - if (iter->snapshot->peeled == PEELED_FULLY || - (iter->snapshot->peeled == PEELED_TAGS && - starts_with(iter->base.refname, "refs/tags/"))) - iter->base.flags |= REF_KNOWS_PEELED; - - iter->pos = eol + 1; - - if (iter->pos < iter->eof && *iter->pos == '^') { - p = iter->pos + 1; - if (iter->eof - p < the_hash_algo->hexsz + 1 || - parse_oid_hex(p, &iter->peeled, &p) || - *p++ != '\n') - die_invalid_line(iter->snapshot->refs->path, - iter->pos, iter->eof - iter->pos); - iter->pos = p; - - /* - * Regardless of what the file header said, we - * definitely know the value of *this* reference. But - * we suppress it if the reference is broken: - */ - if ((iter->base.flags & REF_ISBROKEN)) { - oidclr(&iter->peeled); - iter->base.flags &= ~REF_KNOWS_PEELED; - } else { - iter->base.flags |= REF_KNOWS_PEELED; - } - } else { - oidclr(&iter->peeled); - } - - return ITER_OK; -} - -static int packed_ref_iterator_advance(struct ref_iterator *ref_iterator) -{ - struct packed_ref_iterator *iter = - (struct packed_ref_iterator *)ref_iterator; - int ok; - - while ((ok = next_record(iter)) == ITER_OK) { - if (iter->flags & DO_FOR_EACH_PER_WORKTREE_ONLY && - ref_type(iter->base.refname) != REF_TYPE_PER_WORKTREE) - continue; - - if (!(iter->flags & DO_FOR_EACH_INCLUDE_BROKEN) && - !ref_resolves_to_object(iter->base.refname, &iter->oid, - iter->flags)) - continue; - - return ITER_OK; - } - - if (ref_iterator_abort(ref_iterator) != ITER_DONE) - ok = ITER_ERROR; - - return ok; -} - -static int packed_ref_iterator_peel(struct ref_iterator *ref_iterator, - struct object_id *peeled) -{ - struct packed_ref_iterator *iter = - (struct packed_ref_iterator *)ref_iterator; - - if ((iter->base.flags & REF_KNOWS_PEELED)) { - oidcpy(peeled, &iter->peeled); - return is_null_oid(&iter->peeled) ? -1 : 0; - } else if ((iter->base.flags & (REF_ISBROKEN | REF_ISSYMREF))) { - return -1; - } else { - return !!peel_object(&iter->oid, peeled); - } -} - -static int packed_ref_iterator_abort(struct ref_iterator *ref_iterator) -{ - struct packed_ref_iterator *iter = - (struct packed_ref_iterator *)ref_iterator; - int ok = ITER_DONE; - - strbuf_release(&iter->refname_buf); - release_snapshot(iter->snapshot); - base_ref_iterator_free(ref_iterator); - return ok; -} - -static struct ref_iterator_vtable packed_ref_iterator_vtable = { - packed_ref_iterator_advance, - packed_ref_iterator_peel, - packed_ref_iterator_abort -}; - -static struct ref_iterator *packed_ref_iterator_begin( - struct ref_store *ref_store, - const char *prefix, unsigned int flags) -{ - struct packed_ref_store *refs; - struct snapshot *snapshot; - const char *start; - struct packed_ref_iterator *iter; - struct ref_iterator *ref_iterator; - unsigned int required_flags = REF_STORE_READ; - - if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN)) - required_flags |= REF_STORE_ODB; - refs = packed_downcast(ref_store, required_flags, "ref_iterator_begin"); - - /* - * Note that `get_snapshot()` internally checks whether the - * snapshot is up to date with what is on disk, and re-reads - * it if not. - */ - snapshot = get_snapshot(refs); - - if (prefix && *prefix) - start = find_reference_location(snapshot, prefix, 0); - else - start = snapshot->start; - - if (start == snapshot->eof) - return empty_ref_iterator_begin(); - - iter = xcalloc(1, sizeof(*iter)); - ref_iterator = &iter->base; - base_ref_iterator_init(ref_iterator, &packed_ref_iterator_vtable, 1); - - iter->snapshot = snapshot; - acquire_snapshot(snapshot); - - iter->pos = start; - iter->eof = snapshot->eof; - strbuf_init(&iter->refname_buf, 0); - - iter->base.oid = &iter->oid; - - iter->flags = flags; - - if (prefix && *prefix) - /* Stop iteration after we've gone *past* prefix: */ - ref_iterator = prefix_ref_iterator_begin(ref_iterator, prefix, 0); - - return ref_iterator; -} - -/* - * Write an entry to the packed-refs file for the specified refname. - * If peeled is non-NULL, write it as the entry's peeled value. On - * error, return a nonzero value and leave errno set at the value left - * by the failing call to `fprintf()`. - */ -static int write_packed_entry(FILE *fh, const char *refname, - const struct object_id *oid, - const struct object_id *peeled) -{ - if (fprintf(fh, "%s %s\n", oid_to_hex(oid), refname) < 0 || - (peeled && fprintf(fh, "^%s\n", oid_to_hex(peeled)) < 0)) - return -1; - - return 0; -} - -int packed_refs_lock(struct ref_store *ref_store, int flags, struct strbuf *err) -{ - struct packed_ref_store *refs = - packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN, - "packed_refs_lock"); - static int timeout_configured = 0; - static int timeout_value = 1000; - - if (!timeout_configured) { - git_config_get_int("core.packedrefstimeout", &timeout_value); - timeout_configured = 1; - } - - /* - * Note that we close the lockfile immediately because we - * don't write new content to it, but rather to a separate - * tempfile. - */ - if (hold_lock_file_for_update_timeout( - &refs->lock, - refs->path, - flags, timeout_value) < 0) { - unable_to_lock_message(refs->path, errno, err); - return -1; - } - - if (close_lock_file_gently(&refs->lock)) { - strbuf_addf(err, "unable to close %s: %s", refs->path, strerror(errno)); - rollback_lock_file(&refs->lock); - return -1; - } - - /* - * Now that we hold the `packed-refs` lock, make sure that our - * snapshot matches the current version of the file. Normally - * `get_snapshot()` does that for us, but that function - * assumes that when the file is locked, any existing snapshot - * is still valid. We've just locked the file, but it might - * have changed the moment *before* we locked it. - */ - validate_snapshot(refs); - - /* - * Now make sure that the packed-refs file as it exists in the - * locked state is loaded into the snapshot: - */ - get_snapshot(refs); - return 0; -} - -void packed_refs_unlock(struct ref_store *ref_store) -{ - struct packed_ref_store *refs = packed_downcast( - ref_store, - REF_STORE_READ | REF_STORE_WRITE, - "packed_refs_unlock"); - - if (!is_lock_file_locked(&refs->lock)) - BUG("packed_refs_unlock() called when not locked"); - rollback_lock_file(&refs->lock); -} - -int packed_refs_is_locked(struct ref_store *ref_store) -{ - struct packed_ref_store *refs = packed_downcast( - ref_store, - REF_STORE_READ | REF_STORE_WRITE, - "packed_refs_is_locked"); - - return is_lock_file_locked(&refs->lock); -} - -/* - * The packed-refs header line that we write out. Perhaps other traits - * will be added later. - * - * Note that earlier versions of Git used to parse these traits by - * looking for " trait " in the line. For this reason, the space after - * the colon and the trailing space are required. - */ -static const char PACKED_REFS_HEADER[] = - "# pack-refs with: peeled fully-peeled sorted \n"; - -static int packed_init_db(struct ref_store *ref_store, struct strbuf *err) -{ - /* Nothing to do. */ - return 0; -} - -/* - * Write the packed refs from the current snapshot to the packed-refs - * tempfile, incorporating any changes from `updates`. `updates` must - * be a sorted string list whose keys are the refnames and whose util - * values are `struct ref_update *`. On error, rollback the tempfile, - * write an error message to `err`, and return a nonzero value. - * - * The packfile must be locked before calling this function and will - * remain locked when it is done. - */ -static int write_with_updates(struct packed_ref_store *refs, - struct string_list *updates, - struct strbuf *err) -{ - struct ref_iterator *iter = NULL; - size_t i; - int ok; - FILE *out; - struct strbuf sb = STRBUF_INIT; - char *packed_refs_path; - - if (!is_lock_file_locked(&refs->lock)) - BUG("write_with_updates() called while unlocked"); - - /* - * If packed-refs is a symlink, we want to overwrite the - * symlinked-to file, not the symlink itself. Also, put the - * staging file next to it: - */ - packed_refs_path = get_locked_file_path(&refs->lock); - strbuf_addf(&sb, "%s.new", packed_refs_path); - free(packed_refs_path); - refs->tempfile = create_tempfile(sb.buf); - if (!refs->tempfile) { - strbuf_addf(err, "unable to create file %s: %s", - sb.buf, strerror(errno)); - strbuf_release(&sb); - return -1; - } - strbuf_release(&sb); - - out = fdopen_tempfile(refs->tempfile, "w"); - if (!out) { - strbuf_addf(err, "unable to fdopen packed-refs tempfile: %s", - strerror(errno)); - goto error; - } - - if (fprintf(out, "%s", PACKED_REFS_HEADER) < 0) - goto write_error; - - /* - * We iterate in parallel through the current list of refs and - * the list of updates, processing an entry from at least one - * of the lists each time through the loop. When the current - * list of refs is exhausted, set iter to NULL. When the list - * of updates is exhausted, leave i set to updates->nr. - */ - iter = packed_ref_iterator_begin(&refs->base, "", - DO_FOR_EACH_INCLUDE_BROKEN); - if ((ok = ref_iterator_advance(iter)) != ITER_OK) - iter = NULL; - - i = 0; - - while (iter || i < updates->nr) { - struct ref_update *update = NULL; - int cmp; - - if (i >= updates->nr) { - cmp = -1; - } else { - update = updates->items[i].util; - - if (!iter) - cmp = +1; - else - cmp = strcmp(iter->refname, update->refname); - } - - if (!cmp) { - /* - * There is both an old value and an update - * for this reference. Check the old value if - * necessary: - */ - if ((update->flags & REF_HAVE_OLD)) { - if (is_null_oid(&update->old_oid)) { - strbuf_addf(err, "cannot update ref '%s': " - "reference already exists", - update->refname); - goto error; - } else if (!oideq(&update->old_oid, iter->oid)) { - strbuf_addf(err, "cannot update ref '%s': " - "is at %s but expected %s", - update->refname, - oid_to_hex(iter->oid), - oid_to_hex(&update->old_oid)); - goto error; - } - } - - /* Now figure out what to use for the new value: */ - if ((update->flags & REF_HAVE_NEW)) { - /* - * The update takes precedence. Skip - * the iterator over the unneeded - * value. - */ - if ((ok = ref_iterator_advance(iter)) != ITER_OK) - iter = NULL; - cmp = +1; - } else { - /* - * The update doesn't actually want to - * change anything. We're done with it. - */ - i++; - cmp = -1; - } - } else if (cmp > 0) { - /* - * There is no old value but there is an - * update for this reference. Make sure that - * the update didn't expect an existing value: - */ - if ((update->flags & REF_HAVE_OLD) && - !is_null_oid(&update->old_oid)) { - strbuf_addf(err, "cannot update ref '%s': " - "reference is missing but expected %s", - update->refname, - oid_to_hex(&update->old_oid)); - goto error; - } - } - - if (cmp < 0) { - /* Pass the old reference through. */ - - struct object_id peeled; - int peel_error = ref_iterator_peel(iter, &peeled); - - if (write_packed_entry(out, iter->refname, - iter->oid, - peel_error ? NULL : &peeled)) - goto write_error; - - if ((ok = ref_iterator_advance(iter)) != ITER_OK) - iter = NULL; - } else if (is_null_oid(&update->new_oid)) { - /* - * The update wants to delete the reference, - * and the reference either didn't exist or we - * have already skipped it. So we're done with - * the update (and don't have to write - * anything). - */ - i++; - } else { - struct object_id peeled; - int peel_error = peel_object(&update->new_oid, - &peeled); - - if (write_packed_entry(out, update->refname, - &update->new_oid, - peel_error ? NULL : &peeled)) - goto write_error; - - i++; - } - } - - if (ok != ITER_DONE) { - strbuf_addstr(err, "unable to write packed-refs file: " - "error iterating over old contents"); - goto error; - } - - if (close_tempfile_gently(refs->tempfile)) { - strbuf_addf(err, "error closing file %s: %s", - get_tempfile_path(refs->tempfile), - strerror(errno)); - strbuf_release(&sb); - delete_tempfile(&refs->tempfile); - return -1; - } - - return 0; - -write_error: - strbuf_addf(err, "error writing to %s: %s", - get_tempfile_path(refs->tempfile), strerror(errno)); - -error: - if (iter) - ref_iterator_abort(iter); - - delete_tempfile(&refs->tempfile); - return -1; -} - -int is_packed_transaction_needed(struct ref_store *ref_store, - struct ref_transaction *transaction) -{ - struct packed_ref_store *refs = packed_downcast( - ref_store, - REF_STORE_READ, - "is_packed_transaction_needed"); - struct strbuf referent = STRBUF_INIT; - size_t i; - int ret; - - if (!is_lock_file_locked(&refs->lock)) - BUG("is_packed_transaction_needed() called while unlocked"); - - /* - * We're only going to bother returning false for the common, - * trivial case that references are only being deleted, their - * old values are not being checked, and the old `packed-refs` - * file doesn't contain any of those reference(s). This gives - * false positives for some other cases that could - * theoretically be optimized away: - * - * 1. It could be that the old value is being verified without - * setting a new value. In this case, we could verify the - * old value here and skip the update if it agrees. If it - * disagrees, we could either let the update go through - * (the actual commit would re-detect and report the - * problem), or come up with a way of reporting such an - * error to *our* caller. - * - * 2. It could be that a new value is being set, but that it - * is identical to the current packed value of the - * reference. - * - * Neither of these cases will come up in the current code, - * because the only caller of this function passes to it a - * transaction that only includes `delete` updates with no - * `old_id`. Even if that ever changes, false positives only - * cause an optimization to be missed; they do not affect - * correctness. - */ - - /* - * Start with the cheap checks that don't require old - * reference values to be read: - */ - for (i = 0; i < transaction->nr; i++) { - struct ref_update *update = transaction->updates[i]; - - if (update->flags & REF_HAVE_OLD) - /* Have to check the old value -> needed. */ - return 1; - - if ((update->flags & REF_HAVE_NEW) && !is_null_oid(&update->new_oid)) - /* Have to set a new value -> needed. */ - return 1; - } - - /* - * The transaction isn't checking any old values nor is it - * setting any nonzero new values, so it still might be able - * to be skipped. Now do the more expensive check: the update - * is needed if any of the updates is a delete, and the old - * `packed-refs` file contains a value for that reference. - */ - ret = 0; - for (i = 0; i < transaction->nr; i++) { - struct ref_update *update = transaction->updates[i]; - unsigned int type; - struct object_id oid; - - if (!(update->flags & REF_HAVE_NEW)) - /* - * This reference isn't being deleted -> not - * needed. - */ - continue; - - if (!refs_read_raw_ref(ref_store, update->refname, - &oid, &referent, &type) || - errno != ENOENT) { - /* - * We have to actually delete that reference - * -> this transaction is needed. - */ - ret = 1; - break; - } - } - - strbuf_release(&referent); - return ret; -} - -struct packed_transaction_backend_data { - /* True iff the transaction owns the packed-refs lock. */ - int own_lock; - - struct string_list updates; -}; - -static void packed_transaction_cleanup(struct packed_ref_store *refs, - struct ref_transaction *transaction) -{ - struct packed_transaction_backend_data *data = transaction->backend_data; - - if (data) { - string_list_clear(&data->updates, 0); - - if (is_tempfile_active(refs->tempfile)) - delete_tempfile(&refs->tempfile); - - if (data->own_lock && is_lock_file_locked(&refs->lock)) { - packed_refs_unlock(&refs->base); - data->own_lock = 0; - } - - free(data); - transaction->backend_data = NULL; - } - - transaction->state = REF_TRANSACTION_CLOSED; -} - -static int packed_transaction_prepare(struct ref_store *ref_store, - struct ref_transaction *transaction, - struct strbuf *err) -{ - struct packed_ref_store *refs = packed_downcast( - ref_store, - REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB, - "ref_transaction_prepare"); - struct packed_transaction_backend_data *data; - size_t i; - int ret = TRANSACTION_GENERIC_ERROR; - - /* - * Note that we *don't* skip transactions with zero updates, - * because such a transaction might be executed for the side - * effect of ensuring that all of the references are peeled or - * ensuring that the `packed-refs` file is sorted. If the - * caller wants to optimize away empty transactions, it should - * do so itself. - */ - - data = xcalloc(1, sizeof(*data)); - string_list_init(&data->updates, 0); - - transaction->backend_data = data; - - /* - * Stick the updates in a string list by refname so that we - * can sort them: - */ - for (i = 0; i < transaction->nr; i++) { - struct ref_update *update = transaction->updates[i]; - struct string_list_item *item = - string_list_append(&data->updates, update->refname); - - /* Store a pointer to update in item->util: */ - item->util = update; - } - string_list_sort(&data->updates); - - if (ref_update_reject_duplicates(&data->updates, err)) - goto failure; - - if (!is_lock_file_locked(&refs->lock)) { - if (packed_refs_lock(ref_store, 0, err)) - goto failure; - data->own_lock = 1; - } - - if (write_with_updates(refs, &data->updates, err)) - goto failure; - - transaction->state = REF_TRANSACTION_PREPARED; - return 0; - -failure: - packed_transaction_cleanup(refs, transaction); - return ret; -} - -static int packed_transaction_abort(struct ref_store *ref_store, - struct ref_transaction *transaction, - struct strbuf *err) -{ - struct packed_ref_store *refs = packed_downcast( - ref_store, - REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB, - "ref_transaction_abort"); - - packed_transaction_cleanup(refs, transaction); - return 0; -} - -static int packed_transaction_finish(struct ref_store *ref_store, - struct ref_transaction *transaction, - struct strbuf *err) -{ - struct packed_ref_store *refs = packed_downcast( - ref_store, - REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB, - "ref_transaction_finish"); - int ret = TRANSACTION_GENERIC_ERROR; - char *packed_refs_path; - - clear_snapshot(refs); - - packed_refs_path = get_locked_file_path(&refs->lock); - if (rename_tempfile(&refs->tempfile, packed_refs_path)) { - strbuf_addf(err, "error replacing %s: %s", - refs->path, strerror(errno)); - goto cleanup; - } - - ret = 0; - -cleanup: - free(packed_refs_path); - packed_transaction_cleanup(refs, transaction); - return ret; -} - -static int packed_initial_transaction_commit(struct ref_store *ref_store, - struct ref_transaction *transaction, - struct strbuf *err) -{ - return ref_transaction_commit(transaction, err); -} - -static int packed_delete_refs(struct ref_store *ref_store, const char *msg, - struct string_list *refnames, unsigned int flags) -{ - struct packed_ref_store *refs = - packed_downcast(ref_store, REF_STORE_WRITE, "delete_refs"); - struct strbuf err = STRBUF_INIT; - struct ref_transaction *transaction; - struct string_list_item *item; - int ret; - - (void)refs; /* We need the check above, but don't use the variable */ - - if (!refnames->nr) - return 0; - - /* - * Since we don't check the references' old_oids, the - * individual updates can't fail, so we can pack all of the - * updates into a single transaction. - */ - - transaction = ref_store_transaction_begin(ref_store, &err); - if (!transaction) - return -1; - - for_each_string_list_item(item, refnames) { - if (ref_transaction_delete(transaction, item->string, NULL, - flags, msg, &err)) { - warning(_("could not delete reference %s: %s"), - item->string, err.buf); - strbuf_reset(&err); - } - } - - ret = ref_transaction_commit(transaction, &err); - - if (ret) { - if (refnames->nr == 1) - error(_("could not delete reference %s: %s"), - refnames->items[0].string, err.buf); - else - error(_("could not delete references: %s"), err.buf); - } - - ref_transaction_free(transaction); - strbuf_release(&err); - return ret; -} - -static int packed_pack_refs(struct ref_store *ref_store, unsigned int flags) -{ - /* - * Packed refs are already packed. It might be that loose refs - * are packed *into* a packed refs store, but that is done by - * updating the packed references via a transaction. - */ - return 0; -} - -static int packed_create_symref(struct ref_store *ref_store, - const char *refname, const char *target, - const char *logmsg) -{ - BUG("packed reference store does not support symrefs"); -} - -static int packed_rename_ref(struct ref_store *ref_store, - const char *oldrefname, const char *newrefname, - const char *logmsg) -{ - BUG("packed reference store does not support renaming references"); -} - -static int packed_copy_ref(struct ref_store *ref_store, - const char *oldrefname, const char *newrefname, - const char *logmsg) -{ - BUG("packed reference store does not support copying references"); -} - -static struct ref_iterator *packed_reflog_iterator_begin(struct ref_store *ref_store) -{ - return empty_ref_iterator_begin(); -} - -static int packed_for_each_reflog_ent(struct ref_store *ref_store, - const char *refname, - each_reflog_ent_fn fn, void *cb_data) -{ - return 0; -} - -static int packed_for_each_reflog_ent_reverse(struct ref_store *ref_store, - const char *refname, - each_reflog_ent_fn fn, - void *cb_data) -{ - return 0; -} - -static int packed_reflog_exists(struct ref_store *ref_store, - const char *refname) -{ - return 0; -} - -static int packed_create_reflog(struct ref_store *ref_store, - const char *refname, int force_create, - struct strbuf *err) -{ - BUG("packed reference store does not support reflogs"); -} - -static int packed_delete_reflog(struct ref_store *ref_store, - const char *refname) -{ - return 0; -} - -static int packed_reflog_expire(struct ref_store *ref_store, - const char *refname, const struct object_id *oid, - 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) -{ - return 0; -} - -struct ref_storage_be refs_be_packed = { - NULL, - "packed", - packed_ref_store_create, - packed_init_db, - packed_transaction_prepare, - packed_transaction_finish, - packed_transaction_abort, - packed_initial_transaction_commit, - - packed_pack_refs, - packed_create_symref, - packed_delete_refs, - packed_rename_ref, - packed_copy_ref, - - packed_ref_iterator_begin, - packed_read_raw_ref, - - packed_reflog_iterator_begin, - packed_for_each_reflog_ent, - packed_for_each_reflog_ent_reverse, - packed_reflog_exists, - packed_create_reflog, - packed_delete_reflog, - packed_reflog_expire -}; diff --git a/third_party/git/refs/packed-backend.h b/third_party/git/refs/packed-backend.h deleted file mode 100644 index a01a0aff9c..0000000000 --- a/third_party/git/refs/packed-backend.h +++ /dev/null @@ -1,37 +0,0 @@ -#ifndef REFS_PACKED_BACKEND_H -#define REFS_PACKED_BACKEND_H - -struct ref_transaction; - -/* - * Support for storing references in a `packed-refs` file. - * - * Note that this backend doesn't check for D/F conflicts, because it - * doesn't care about them. But usually it should be wrapped in a - * `files_ref_store` that prevents D/F conflicts from being created, - * even among packed refs. - */ - -struct ref_store *packed_ref_store_create(const char *path, - unsigned int store_flags); - -/* - * Lock the packed-refs file for writing. Flags is passed to - * hold_lock_file_for_update(). Return 0 on success. On errors, write - * an error message to `err` and return a nonzero value. - */ -int packed_refs_lock(struct ref_store *ref_store, int flags, struct strbuf *err); - -void packed_refs_unlock(struct ref_store *ref_store); -int packed_refs_is_locked(struct ref_store *ref_store); - -/* - * Return true if `transaction` really needs to be carried out against - * the specified packed_ref_store, or false if it can be skipped - * (i.e., because it is an obvious NOOP). `ref_store` must be locked - * before calling this function. - */ -int is_packed_transaction_needed(struct ref_store *ref_store, - struct ref_transaction *transaction); - -#endif /* REFS_PACKED_BACKEND_H */ diff --git a/third_party/git/refs/ref-cache.c b/third_party/git/refs/ref-cache.c deleted file mode 100644 index b7052f72e2..0000000000 --- a/third_party/git/refs/ref-cache.c +++ /dev/null @@ -1,551 +0,0 @@ -#include "../cache.h" -#include "../refs.h" -#include "refs-internal.h" -#include "ref-cache.h" -#include "../iterator.h" - -void add_entry_to_dir(struct ref_dir *dir, struct ref_entry *entry) -{ - ALLOC_GROW(dir->entries, dir->nr + 1, dir->alloc); - dir->entries[dir->nr++] = entry; - /* optimize for the case that entries are added in order */ - if (dir->nr == 1 || - (dir->nr == dir->sorted + 1 && - strcmp(dir->entries[dir->nr - 2]->name, - dir->entries[dir->nr - 1]->name) < 0)) - dir->sorted = dir->nr; -} - -struct ref_dir *get_ref_dir(struct ref_entry *entry) -{ - struct ref_dir *dir; - assert(entry->flag & REF_DIR); - dir = &entry->u.subdir; - if (entry->flag & REF_INCOMPLETE) { - if (!dir->cache->fill_ref_dir) - BUG("incomplete ref_store without fill_ref_dir function"); - - dir->cache->fill_ref_dir(dir->cache->ref_store, dir, entry->name); - entry->flag &= ~REF_INCOMPLETE; - } - return dir; -} - -struct ref_entry *create_ref_entry(const char *refname, - const struct object_id *oid, int flag) -{ - struct ref_entry *ref; - - FLEX_ALLOC_STR(ref, name, refname); - oidcpy(&ref->u.value.oid, oid); - ref->flag = flag; - return ref; -} - -struct ref_cache *create_ref_cache(struct ref_store *refs, - fill_ref_dir_fn *fill_ref_dir) -{ - struct ref_cache *ret = xcalloc(1, sizeof(*ret)); - - ret->ref_store = refs; - ret->fill_ref_dir = fill_ref_dir; - ret->root = create_dir_entry(ret, "", 0, 1); - return ret; -} - -static void clear_ref_dir(struct ref_dir *dir); - -static void free_ref_entry(struct ref_entry *entry) -{ - if (entry->flag & REF_DIR) { - /* - * Do not use get_ref_dir() here, as that might - * trigger the reading of loose refs. - */ - clear_ref_dir(&entry->u.subdir); - } - free(entry); -} - -void free_ref_cache(struct ref_cache *cache) -{ - free_ref_entry(cache->root); - free(cache); -} - -/* - * Clear and free all entries in dir, recursively. - */ -static void clear_ref_dir(struct ref_dir *dir) -{ - int i; - for (i = 0; i < dir->nr; i++) - free_ref_entry(dir->entries[i]); - FREE_AND_NULL(dir->entries); - dir->sorted = dir->nr = dir->alloc = 0; -} - -struct ref_entry *create_dir_entry(struct ref_cache *cache, - const char *dirname, size_t len, - int incomplete) -{ - struct ref_entry *direntry; - - FLEX_ALLOC_MEM(direntry, name, dirname, len); - direntry->u.subdir.cache = cache; - direntry->flag = REF_DIR | (incomplete ? REF_INCOMPLETE : 0); - return direntry; -} - -static int ref_entry_cmp(const void *a, const void *b) -{ - struct ref_entry *one = *(struct ref_entry **)a; - struct ref_entry *two = *(struct ref_entry **)b; - return strcmp(one->name, two->name); -} - -static void sort_ref_dir(struct ref_dir *dir); - -struct string_slice { - size_t len; - const char *str; -}; - -static int ref_entry_cmp_sslice(const void *key_, const void *ent_) -{ - const struct string_slice *key = key_; - const struct ref_entry *ent = *(const struct ref_entry * const *)ent_; - int cmp = strncmp(key->str, ent->name, key->len); - if (cmp) - return cmp; - return '\0' - (unsigned char)ent->name[key->len]; -} - -int search_ref_dir(struct ref_dir *dir, const char *refname, size_t len) -{ - struct ref_entry **r; - struct string_slice key; - - if (refname == NULL || !dir->nr) - return -1; - - sort_ref_dir(dir); - key.len = len; - key.str = refname; - r = bsearch(&key, dir->entries, dir->nr, sizeof(*dir->entries), - ref_entry_cmp_sslice); - - if (r == NULL) - return -1; - - return r - dir->entries; -} - -/* - * Search for a directory entry directly within dir (without - * recursing). Sort dir if necessary. subdirname must be a directory - * name (i.e., end in '/'). If mkdir is set, then create the - * directory if it is missing; otherwise, return NULL if the desired - * directory cannot be found. dir must already be complete. - */ -static struct ref_dir *search_for_subdir(struct ref_dir *dir, - const char *subdirname, size_t len, - int mkdir) -{ - int entry_index = search_ref_dir(dir, subdirname, len); - struct ref_entry *entry; - if (entry_index == -1) { - if (!mkdir) - return NULL; - /* - * Since dir is complete, the absence of a subdir - * means that the subdir really doesn't exist; - * therefore, create an empty record for it but mark - * the record complete. - */ - entry = create_dir_entry(dir->cache, subdirname, len, 0); - add_entry_to_dir(dir, entry); - } else { - entry = dir->entries[entry_index]; - } - return get_ref_dir(entry); -} - -/* - * If refname is a reference name, find the ref_dir within the dir - * tree that should hold refname. If refname is a directory name - * (i.e., it ends in '/'), then return that ref_dir itself. dir must - * represent the top-level directory and must already be complete. - * Sort ref_dirs and recurse into subdirectories as necessary. If - * mkdir is set, then create any missing directories; otherwise, - * return NULL if the desired directory cannot be found. - */ -static struct ref_dir *find_containing_dir(struct ref_dir *dir, - const char *refname, int mkdir) -{ - const char *slash; - for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) { - size_t dirnamelen = slash - refname + 1; - struct ref_dir *subdir; - subdir = search_for_subdir(dir, refname, dirnamelen, mkdir); - if (!subdir) { - dir = NULL; - break; - } - dir = subdir; - } - - return dir; -} - -struct ref_entry *find_ref_entry(struct ref_dir *dir, const char *refname) -{ - int entry_index; - struct ref_entry *entry; - dir = find_containing_dir(dir, refname, 0); - if (!dir) - return NULL; - entry_index = search_ref_dir(dir, refname, strlen(refname)); - if (entry_index == -1) - return NULL; - entry = dir->entries[entry_index]; - return (entry->flag & REF_DIR) ? NULL : entry; -} - -int remove_entry_from_dir(struct ref_dir *dir, const char *refname) -{ - int refname_len = strlen(refname); - int entry_index; - struct ref_entry *entry; - int is_dir = refname[refname_len - 1] == '/'; - if (is_dir) { - /* - * refname represents a reference directory. Remove - * the trailing slash; otherwise we will get the - * directory *representing* refname rather than the - * one *containing* it. - */ - char *dirname = xmemdupz(refname, refname_len - 1); - dir = find_containing_dir(dir, dirname, 0); - free(dirname); - } else { - dir = find_containing_dir(dir, refname, 0); - } - if (!dir) - return -1; - entry_index = search_ref_dir(dir, refname, refname_len); - if (entry_index == -1) - return -1; - entry = dir->entries[entry_index]; - - MOVE_ARRAY(&dir->entries[entry_index], - &dir->entries[entry_index + 1], dir->nr - entry_index - 1); - dir->nr--; - if (dir->sorted > entry_index) - dir->sorted--; - free_ref_entry(entry); - return dir->nr; -} - -int add_ref_entry(struct ref_dir *dir, struct ref_entry *ref) -{ - dir = find_containing_dir(dir, ref->name, 1); - if (!dir) - return -1; - add_entry_to_dir(dir, ref); - return 0; -} - -/* - * Emit a warning and return true iff ref1 and ref2 have the same name - * and the same oid. Die if they have the same name but different - * oids. - */ -static int is_dup_ref(const struct ref_entry *ref1, const struct ref_entry *ref2) -{ - if (strcmp(ref1->name, ref2->name)) - return 0; - - /* Duplicate name; make sure that they don't conflict: */ - - if ((ref1->flag & REF_DIR) || (ref2->flag & REF_DIR)) - /* This is impossible by construction */ - die("Reference directory conflict: %s", ref1->name); - - if (!oideq(&ref1->u.value.oid, &ref2->u.value.oid)) - die("Duplicated ref, and SHA1s don't match: %s", ref1->name); - - warning("Duplicated ref: %s", ref1->name); - return 1; -} - -/* - * Sort the entries in dir non-recursively (if they are not already - * sorted) and remove any duplicate entries. - */ -static void sort_ref_dir(struct ref_dir *dir) -{ - int i, j; - struct ref_entry *last = NULL; - - /* - * This check also prevents passing a zero-length array to qsort(), - * which is a problem on some platforms. - */ - if (dir->sorted == dir->nr) - return; - - QSORT(dir->entries, dir->nr, ref_entry_cmp); - - /* Remove any duplicates: */ - for (i = 0, j = 0; j < dir->nr; j++) { - struct ref_entry *entry = dir->entries[j]; - if (last && is_dup_ref(last, entry)) - free_ref_entry(entry); - else - last = dir->entries[i++] = entry; - } - dir->sorted = dir->nr = i; -} - -enum prefix_state { - /* All refs within the directory would match prefix: */ - PREFIX_CONTAINS_DIR, - - /* Some, but not all, refs within the directory might match prefix: */ - PREFIX_WITHIN_DIR, - - /* No refs within the directory could possibly match prefix: */ - PREFIX_EXCLUDES_DIR -}; - -/* - * Return a `prefix_state` constant describing the relationship - * between the directory with the specified `dirname` and `prefix`. - */ -static enum prefix_state overlaps_prefix(const char *dirname, - const char *prefix) -{ - while (*prefix && *dirname == *prefix) { - dirname++; - prefix++; - } - if (!*prefix) - return PREFIX_CONTAINS_DIR; - else if (!*dirname) - return PREFIX_WITHIN_DIR; - else - return PREFIX_EXCLUDES_DIR; -} - -/* - * Load all of the refs from `dir` (recursively) that could possibly - * contain references matching `prefix` into our in-memory cache. If - * `prefix` is NULL, prime unconditionally. - */ -static void prime_ref_dir(struct ref_dir *dir, const char *prefix) -{ - /* - * The hard work of loading loose refs is done by get_ref_dir(), so we - * just need to recurse through all of the sub-directories. We do not - * even need to care about sorting, as traversal order does not matter - * to us. - */ - int i; - for (i = 0; i < dir->nr; i++) { - struct ref_entry *entry = dir->entries[i]; - if (!(entry->flag & REF_DIR)) { - /* Not a directory; no need to recurse. */ - } else if (!prefix) { - /* Recurse in any case: */ - prime_ref_dir(get_ref_dir(entry), NULL); - } else { - switch (overlaps_prefix(entry->name, prefix)) { - case PREFIX_CONTAINS_DIR: - /* - * Recurse, and from here down we - * don't have to check the prefix - * anymore: - */ - prime_ref_dir(get_ref_dir(entry), NULL); - break; - case PREFIX_WITHIN_DIR: - prime_ref_dir(get_ref_dir(entry), prefix); - break; - case PREFIX_EXCLUDES_DIR: - /* No need to prime this directory. */ - break; - } - } - } -} - -/* - * A level in the reference hierarchy that is currently being iterated - * through. - */ -struct cache_ref_iterator_level { - /* - * The ref_dir being iterated over at this level. The ref_dir - * is sorted before being stored here. - */ - struct ref_dir *dir; - - enum prefix_state prefix_state; - - /* - * The index of the current entry within dir (which might - * itself be a directory). If index == -1, then the iteration - * hasn't yet begun. If index == dir->nr, then the iteration - * through this level is over. - */ - int index; -}; - -/* - * Represent an iteration through a ref_dir in the memory cache. The - * iteration recurses through subdirectories. - */ -struct cache_ref_iterator { - struct ref_iterator base; - - /* - * The number of levels currently on the stack. This is always - * at least 1, because when it becomes zero the iteration is - * ended and this struct is freed. - */ - size_t levels_nr; - - /* The number of levels that have been allocated on the stack */ - size_t levels_alloc; - - /* - * Only include references with this prefix in the iteration. - * The prefix is matched textually, without regard for path - * component boundaries. - */ - const char *prefix; - - /* - * A stack of levels. levels[0] is the uppermost level that is - * being iterated over in this iteration. (This is not - * necessary the top level in the references hierarchy. If we - * are iterating through a subtree, then levels[0] will hold - * the ref_dir for that subtree, and subsequent levels will go - * on from there.) - */ - struct cache_ref_iterator_level *levels; -}; - -static int cache_ref_iterator_advance(struct ref_iterator *ref_iterator) -{ - struct cache_ref_iterator *iter = - (struct cache_ref_iterator *)ref_iterator; - - while (1) { - struct cache_ref_iterator_level *level = - &iter->levels[iter->levels_nr - 1]; - struct ref_dir *dir = level->dir; - struct ref_entry *entry; - enum prefix_state entry_prefix_state; - - if (level->index == -1) - sort_ref_dir(dir); - - if (++level->index == level->dir->nr) { - /* This level is exhausted; pop up a level */ - if (--iter->levels_nr == 0) - return ref_iterator_abort(ref_iterator); - - continue; - } - - entry = dir->entries[level->index]; - - if (level->prefix_state == PREFIX_WITHIN_DIR) { - entry_prefix_state = overlaps_prefix(entry->name, iter->prefix); - if (entry_prefix_state == PREFIX_EXCLUDES_DIR) - continue; - } else { - entry_prefix_state = level->prefix_state; - } - - if (entry->flag & REF_DIR) { - /* push down a level */ - ALLOC_GROW(iter->levels, iter->levels_nr + 1, - iter->levels_alloc); - - level = &iter->levels[iter->levels_nr++]; - level->dir = get_ref_dir(entry); - level->prefix_state = entry_prefix_state; - level->index = -1; - } else { - iter->base.refname = entry->name; - iter->base.oid = &entry->u.value.oid; - iter->base.flags = entry->flag; - return ITER_OK; - } - } -} - -static int cache_ref_iterator_peel(struct ref_iterator *ref_iterator, - struct object_id *peeled) -{ - return peel_object(ref_iterator->oid, peeled); -} - -static int cache_ref_iterator_abort(struct ref_iterator *ref_iterator) -{ - struct cache_ref_iterator *iter = - (struct cache_ref_iterator *)ref_iterator; - - free((char *)iter->prefix); - free(iter->levels); - base_ref_iterator_free(ref_iterator); - return ITER_DONE; -} - -static struct ref_iterator_vtable cache_ref_iterator_vtable = { - cache_ref_iterator_advance, - cache_ref_iterator_peel, - cache_ref_iterator_abort -}; - -struct ref_iterator *cache_ref_iterator_begin(struct ref_cache *cache, - const char *prefix, - int prime_dir) -{ - struct ref_dir *dir; - struct cache_ref_iterator *iter; - struct ref_iterator *ref_iterator; - struct cache_ref_iterator_level *level; - - dir = get_ref_dir(cache->root); - if (prefix && *prefix) - dir = find_containing_dir(dir, prefix, 0); - if (!dir) - /* There's nothing to iterate over. */ - return empty_ref_iterator_begin(); - - if (prime_dir) - prime_ref_dir(dir, prefix); - - iter = xcalloc(1, sizeof(*iter)); - ref_iterator = &iter->base; - base_ref_iterator_init(ref_iterator, &cache_ref_iterator_vtable, 1); - ALLOC_GROW(iter->levels, 10, iter->levels_alloc); - - iter->levels_nr = 1; - level = &iter->levels[0]; - level->index = -1; - level->dir = dir; - - if (prefix && *prefix) { - iter->prefix = xstrdup(prefix); - level->prefix_state = PREFIX_WITHIN_DIR; - } else { - level->prefix_state = PREFIX_CONTAINS_DIR; - } - - return ref_iterator; -} diff --git a/third_party/git/refs/ref-cache.h b/third_party/git/refs/ref-cache.h deleted file mode 100644 index 3bfb89d2b3..0000000000 --- a/third_party/git/refs/ref-cache.h +++ /dev/null @@ -1,243 +0,0 @@ -#ifndef REFS_REF_CACHE_H -#define REFS_REF_CACHE_H - -#include "cache.h" - -struct ref_dir; -struct ref_store; - -/* - * If this ref_cache is filled lazily, this function is used to load - * information into the specified ref_dir (shallow or deep, at the - * option of the ref_store). dirname includes a trailing slash. - */ -typedef void fill_ref_dir_fn(struct ref_store *ref_store, - struct ref_dir *dir, const char *dirname); - -struct ref_cache { - struct ref_entry *root; - - /* A pointer to the ref_store whose cache this is: */ - struct ref_store *ref_store; - - /* - * Function used (if necessary) to lazily-fill cache. May be - * NULL. - */ - fill_ref_dir_fn *fill_ref_dir; -}; - -/* - * Information used (along with the information in ref_entry) to - * describe a single cached reference. This data structure only - * occurs embedded in a union in struct ref_entry, and only when - * (ref_entry->flag & REF_DIR) is zero. - */ -struct ref_value { - /* - * The name of the object to which this reference resolves - * (which may be a tag object). If REF_ISBROKEN, this is - * null. If REF_ISSYMREF, then this is the name of the object - * referred to by the last reference in the symlink chain. - */ - struct object_id oid; -}; - -/* - * Information used (along with the information in ref_entry) to - * describe a level in the hierarchy of references. This data - * structure only occurs embedded in a union in struct ref_entry, and - * only when (ref_entry.flag & REF_DIR) is set. In that case, - * (ref_entry.flag & REF_INCOMPLETE) determines whether the references - * in the directory have already been read: - * - * (ref_entry.flag & REF_INCOMPLETE) unset -- a directory of loose - * or packed references, already read. - * - * (ref_entry.flag & REF_INCOMPLETE) set -- a directory of loose - * references that hasn't been read yet (nor has any of its - * subdirectories). - * - * Entries within a directory are stored within a growable array of - * pointers to ref_entries (entries, nr, alloc). Entries 0 <= i < - * sorted are sorted by their component name in strcmp() order and the - * remaining entries are unsorted. - * - * Loose references are read lazily, one directory at a time. When a - * directory of loose references is read, then all of the references - * in that directory are stored, and REF_INCOMPLETE stubs are created - * for any subdirectories, but the subdirectories themselves are not - * read. The reading is triggered by get_ref_dir(). - */ -struct ref_dir { - int nr, alloc; - - /* - * Entries with index 0 <= i < sorted are sorted by name. New - * entries are appended to the list unsorted, and are sorted - * only when required; thus we avoid the need to sort the list - * after the addition of every reference. - */ - int sorted; - - /* The ref_cache containing this entry: */ - struct ref_cache *cache; - - struct ref_entry **entries; -}; - -/* - * Bit values for ref_entry::flag. REF_ISSYMREF=0x01, - * REF_ISPACKED=0x02, REF_ISBROKEN=0x04 and REF_BAD_NAME=0x08 are - * public values; see refs.h. - */ - -/* ref_entry represents a directory of references */ -#define REF_DIR 0x10 - -/* - * Entry has not yet been read from disk (used only for REF_DIR - * entries representing loose references) - */ -#define REF_INCOMPLETE 0x20 - -/* - * A ref_entry represents either a reference or a "subdirectory" of - * references. - * - * Each directory in the reference namespace is represented by a - * ref_entry with (flags & REF_DIR) set and containing a subdir member - * that holds the entries in that directory that have been read so - * far. If (flags & REF_INCOMPLETE) is set, then the directory and - * its subdirectories haven't been read yet. REF_INCOMPLETE is only - * used for loose reference directories. - * - * References are represented by a ref_entry with (flags & REF_DIR) - * unset and a value member that describes the reference's value. The - * flag member is at the ref_entry level, but it is also needed to - * interpret the contents of the value field (in other words, a - * ref_value object is not very much use without the enclosing - * ref_entry). - * - * Reference names cannot end with slash and directories' names are - * always stored with a trailing slash (except for the top-level - * directory, which is always denoted by ""). This has two nice - * consequences: (1) when the entries in each subdir are sorted - * lexicographically by name (as they usually are), the references in - * a whole tree can be generated in lexicographic order by traversing - * the tree in left-to-right, depth-first order; (2) the names of - * references and subdirectories cannot conflict, and therefore the - * presence of an empty subdirectory does not block the creation of a - * similarly-named reference. (The fact that reference names with the - * same leading components can conflict *with each other* is a - * separate issue that is regulated by refs_verify_refname_available().) - * - * Please note that the name field contains the fully-qualified - * reference (or subdirectory) name. Space could be saved by only - * storing the relative names. But that would require the full names - * to be generated on the fly when iterating in do_for_each_ref(), and - * would break callback functions, who have always been able to assume - * that the name strings that they are passed will not be freed during - * the iteration. - */ -struct ref_entry { - unsigned char flag; /* ISSYMREF? ISPACKED? */ - union { - struct ref_value value; /* if not (flags&REF_DIR) */ - struct ref_dir subdir; /* if (flags&REF_DIR) */ - } u; - /* - * The full name of the reference (e.g., "refs/heads/master") - * or the full name of the directory with a trailing slash - * (e.g., "refs/heads/"): - */ - char name[FLEX_ARRAY]; -}; - -/* - * Return the index of the entry with the given refname from the - * ref_dir (non-recursively), sorting dir if necessary. Return -1 if - * no such entry is found. dir must already be complete. - */ -int search_ref_dir(struct ref_dir *dir, const char *refname, size_t len); - -struct ref_dir *get_ref_dir(struct ref_entry *entry); - -/* - * Create a struct ref_entry object for the specified dirname. - * dirname is the name of the directory with a trailing slash (e.g., - * "refs/heads/") or "" for the top-level directory. - */ -struct ref_entry *create_dir_entry(struct ref_cache *cache, - const char *dirname, size_t len, - int incomplete); - -struct ref_entry *create_ref_entry(const char *refname, - const struct object_id *oid, int flag); - -/* - * Return a pointer to a new `ref_cache`. Its top-level starts out - * marked incomplete. If `fill_ref_dir` is non-NULL, it is the - * function called to fill in incomplete directories in the - * `ref_cache` when they are accessed. If it is NULL, then the whole - * `ref_cache` must be filled (including clearing its directories' - * `REF_INCOMPLETE` bits) before it is used, and `refs` can be NULL, - * too. - */ -struct ref_cache *create_ref_cache(struct ref_store *refs, - fill_ref_dir_fn *fill_ref_dir); - -/* - * Free the `ref_cache` and all of its associated data. - */ -void free_ref_cache(struct ref_cache *cache); - -/* - * Add a ref_entry to the end of dir (unsorted). Entry is always - * stored directly in dir; no recursion into subdirectories is - * done. - */ -void add_entry_to_dir(struct ref_dir *dir, struct ref_entry *entry); - -/* - * Remove the entry with the given name from dir, recursing into - * subdirectories as necessary. If refname is the name of a directory - * (i.e., ends with '/'), then remove the directory and its contents. - * If the removal was successful, return the number of entries - * remaining in the directory entry that contained the deleted entry. - * If the name was not found, return -1. Please note that this - * function only deletes the entry from the cache; it does not delete - * it from the filesystem or ensure that other cache entries (which - * might be symbolic references to the removed entry) are updated. - * Nor does it remove any containing dir entries that might be made - * empty by the removal. dir must represent the top-level directory - * and must already be complete. - */ -int remove_entry_from_dir(struct ref_dir *dir, const char *refname); - -/* - * Add a ref_entry to the ref_dir (unsorted), recursing into - * subdirectories as necessary. dir must represent the top-level - * directory. Return 0 on success. - */ -int add_ref_entry(struct ref_dir *dir, struct ref_entry *ref); - -/* - * Find the value entry with the given name in dir, sorting ref_dirs - * and recursing into subdirectories as necessary. If the name is not - * found or it corresponds to a directory entry, return NULL. - */ -struct ref_entry *find_ref_entry(struct ref_dir *dir, const char *refname); - -/* - * Start iterating over references in `cache`. If `prefix` is - * specified, only include references whose names start with that - * prefix. If `prime_dir` is true, then fill any incomplete - * directories before beginning the iteration. The output is ordered - * by refname. - */ -struct ref_iterator *cache_ref_iterator_begin(struct ref_cache *cache, - const char *prefix, - int prime_dir); - -#endif /* REFS_REF_CACHE_H */ diff --git a/third_party/git/refs/refs-internal.h b/third_party/git/refs/refs-internal.h deleted file mode 100644 index f2d8c0123a..0000000000 --- a/third_party/git/refs/refs-internal.h +++ /dev/null @@ -1,678 +0,0 @@ -#ifndef REFS_REFS_INTERNAL_H -#define REFS_REFS_INTERNAL_H - -#include "cache.h" -#include "refs.h" -#include "iterator.h" - -struct ref_transaction; - -/* - * Data structures and functions for the internal use of the refs - * module. Code outside of the refs module should use only the public - * functions defined in "refs.h", and should *not* include this file. - */ - -/* - * The following flags can appear in `ref_update::flags`. Their - * numerical values must not conflict with those of REF_NO_DEREF and - * REF_FORCE_CREATE_REFLOG, which are also stored in - * `ref_update::flags`. - */ - -/* - * The reference should be updated to new_oid. - */ -#define REF_HAVE_NEW (1 << 2) - -/* - * The current reference's value should be checked to make sure that - * it agrees with old_oid. - */ -#define REF_HAVE_OLD (1 << 3) - -/* - * Return the length of time to retry acquiring a loose reference lock - * before giving up, in milliseconds: - */ -long get_files_ref_lock_timeout_ms(void); - -/* - * Return true iff refname is minimally safe. "Safe" here means that - * deleting a loose reference by this name will not do any damage, for - * example by causing a file that is not a reference to be deleted. - * This function does not check that the reference name is legal; for - * that, use check_refname_format(). - * - * A refname that starts with "refs/" is considered safe iff it - * doesn't contain any "." or ".." components or consecutive '/' - * characters, end with '/', or (on Windows) contain any '\' - * characters. Names that do not start with "refs/" are considered - * safe iff they consist entirely of upper case characters and '_' - * (like "HEAD" and "MERGE_HEAD" but not "config" or "FOO/BAR"). - */ -int refname_is_safe(const char *refname); - -/* - * Helper function: return true if refname, which has the specified - * oid and flags, can be resolved to an object in the database. If the - * referred-to object does not exist, emit a warning and return false. - */ -int ref_resolves_to_object(const char *refname, - const struct object_id *oid, - unsigned int flags); - -enum peel_status { - /* object was peeled successfully: */ - PEEL_PEELED = 0, - - /* - * object cannot be peeled because the named object (or an - * object referred to by a tag in the peel chain), does not - * exist. - */ - PEEL_INVALID = -1, - - /* object cannot be peeled because it is not a tag: */ - PEEL_NON_TAG = -2, - - /* ref_entry contains no peeled value because it is a symref: */ - PEEL_IS_SYMREF = -3, - - /* - * ref_entry cannot be peeled because it is broken (i.e., the - * symbolic reference cannot even be resolved to an object - * name): - */ - PEEL_BROKEN = -4 -}; - -/* - * Peel the named object; i.e., if the object is a tag, resolve the - * tag recursively until a non-tag is found. If successful, store the - * result to oid and return PEEL_PEELED. If the object is not a tag - * or is not valid, return PEEL_NON_TAG or PEEL_INVALID, respectively, - * and leave oid unchanged. - */ -enum peel_status peel_object(const struct object_id *name, struct object_id *oid); - -/* - * Copy the reflog message msg to sb while cleaning up the whitespaces. - * Especially, convert LF to space, because reflog file is one line per entry. - */ -void copy_reflog_msg(struct strbuf *sb, const char *msg); - -/** - * Information needed for a single ref update. Set new_oid to the new - * value or to null_oid to delete the ref. To check the old value - * while the ref is locked, set (flags & REF_HAVE_OLD) and set old_oid - * to the old value, or to null_oid to ensure the ref does not exist - * before update. - */ -struct ref_update { - /* - * If (flags & REF_HAVE_NEW), set the reference to this value - * (or delete it, if `new_oid` is `null_oid`). - */ - struct object_id new_oid; - - /* - * If (flags & REF_HAVE_OLD), check that the reference - * previously had this value (or didn't previously exist, if - * `old_oid` is `null_oid`). - */ - struct object_id old_oid; - - /* - * One or more of REF_NO_DEREF, REF_FORCE_CREATE_REFLOG, - * REF_HAVE_NEW, REF_HAVE_OLD, or backend-specific flags. - */ - unsigned int flags; - - void *backend_data; - unsigned int type; - char *msg; - - /* - * If this ref_update was split off of a symref update via - * split_symref_update(), then this member points at that - * update. This is used for two purposes: - * 1. When reporting errors, we report the refname under which - * the update was originally requested. - * 2. When we read the old value of this reference, we - * propagate it back to its parent update for recording in - * the latter's reflog. - */ - struct ref_update *parent_update; - - const char refname[FLEX_ARRAY]; -}; - -int refs_read_raw_ref(struct ref_store *ref_store, - const char *refname, struct object_id *oid, - struct strbuf *referent, unsigned int *type); - -/* - * Write an error to `err` and return a nonzero value iff the same - * refname appears multiple times in `refnames`. `refnames` must be - * sorted on entry to this function. - */ -int ref_update_reject_duplicates(struct string_list *refnames, - struct strbuf *err); - -/* - * Add a ref_update with the specified properties to transaction, and - * return a pointer to the new object. This function does not verify - * that refname is well-formed. new_oid and old_oid are only - * dereferenced if the REF_HAVE_NEW and REF_HAVE_OLD bits, - * respectively, are set in flags. - */ -struct ref_update *ref_transaction_add_update( - struct ref_transaction *transaction, - const char *refname, unsigned int flags, - const struct object_id *new_oid, - const struct object_id *old_oid, - const char *msg); - -/* - * Transaction states. - * - * OPEN: The transaction is initialized and new updates can still be - * added to it. An OPEN transaction can be prepared, - * committed, freed, or aborted (freeing and aborting an open - * transaction are equivalent). - * - * PREPARED: ref_transaction_prepare(), which locks all of the - * references involved in the update and checks that the - * update has no errors, has been called successfully for the - * transaction. A PREPARED transaction can be committed or - * aborted. - * - * CLOSED: The transaction is no longer active. A transaction becomes - * CLOSED if there is a failure while building the transaction - * or if a transaction is committed or aborted. A CLOSED - * transaction can only be freed. - */ -enum ref_transaction_state { - REF_TRANSACTION_OPEN = 0, - REF_TRANSACTION_PREPARED = 1, - REF_TRANSACTION_CLOSED = 2 -}; - -/* - * Data structure for holding a reference transaction, which can - * consist of checks and updates to multiple references, carried out - * as atomically as possible. This structure is opaque to callers. - */ -struct ref_transaction { - struct ref_store *ref_store; - struct ref_update **updates; - size_t alloc; - size_t nr; - enum ref_transaction_state state; - void *backend_data; -}; - -/* - * Check for entries in extras that are within the specified - * directory, where dirname is a reference directory name including - * the trailing slash (e.g., "refs/heads/foo/"). Ignore any - * conflicting references that are found in skip. If there is a - * conflicting reference, return its name. - * - * extras and skip must be sorted lists of reference names. Either one - * can be NULL, signifying the empty list. - */ -const char *find_descendant_ref(const char *dirname, - const struct string_list *extras, - const struct string_list *skip); - -/* - * 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 refs_rename_ref_available(struct ref_store *refs, - const char *old_refname, - const char *new_refname); - -/* We allow "recursive" symbolic refs. Only within reason, though */ -#define SYMREF_MAXDEPTH 5 - -/* Include broken references in a do_for_each_ref*() iteration: */ -#define DO_FOR_EACH_INCLUDE_BROKEN 0x01 - -/* - * Reference iterators - * - * A reference iterator encapsulates the state of an in-progress - * iteration over references. Create an instance of `struct - * ref_iterator` via one of the functions in this module. - * - * A freshly-created ref_iterator doesn't yet point at a reference. To - * advance the iterator, call ref_iterator_advance(). If successful, - * this sets the iterator's refname, oid, and flags fields to describe - * the next reference and returns ITER_OK. The data pointed at by - * refname and oid belong to the iterator; if you want to retain them - * after calling ref_iterator_advance() again or calling - * ref_iterator_abort(), you must make a copy. When the iteration has - * been exhausted, ref_iterator_advance() releases any resources - * assocated with the iteration, frees the ref_iterator object, and - * returns ITER_DONE. If you want to abort the iteration early, call - * ref_iterator_abort(), which also frees the ref_iterator object and - * any associated resources. If there was an internal error advancing - * to the next entry, ref_iterator_advance() aborts the iteration, - * frees the ref_iterator, and returns ITER_ERROR. - * - * The reference currently being looked at can be peeled by calling - * ref_iterator_peel(). This function is often faster than peel_ref(), - * so it should be preferred when iterating over references. - * - * Putting it all together, a typical iteration looks like this: - * - * int ok; - * struct ref_iterator *iter = ...; - * - * while ((ok = ref_iterator_advance(iter)) == ITER_OK) { - * if (want_to_stop_iteration()) { - * ok = ref_iterator_abort(iter); - * break; - * } - * - * // Access information about the current reference: - * if (!(iter->flags & REF_ISSYMREF)) - * printf("%s is %s\n", iter->refname, oid_to_hex(iter->oid)); - * - * // If you need to peel the reference: - * ref_iterator_peel(iter, &oid); - * } - * - * if (ok != ITER_DONE) - * handle_error(); - */ -struct ref_iterator { - struct ref_iterator_vtable *vtable; - - /* - * Does this `ref_iterator` iterate over references in order - * by refname? - */ - unsigned int ordered : 1; - - const char *refname; - const struct object_id *oid; - unsigned int flags; -}; - -/* - * Advance the iterator to the first or next item and return ITER_OK. - * If the iteration is exhausted, free the resources associated with - * the ref_iterator and return ITER_DONE. On errors, free the iterator - * resources and return ITER_ERROR. It is a bug to use ref_iterator or - * call this function again after it has returned ITER_DONE or - * ITER_ERROR. - */ -int ref_iterator_advance(struct ref_iterator *ref_iterator); - -/* - * If possible, peel the reference currently being viewed by the - * iterator. Return 0 on success. - */ -int ref_iterator_peel(struct ref_iterator *ref_iterator, - struct object_id *peeled); - -/* - * End the iteration before it has been exhausted, freeing the - * reference iterator and any associated resources and returning - * ITER_DONE. If the abort itself failed, return ITER_ERROR. - */ -int ref_iterator_abort(struct ref_iterator *ref_iterator); - -/* - * An iterator over nothing (its first ref_iterator_advance() call - * returns ITER_DONE). - */ -struct ref_iterator *empty_ref_iterator_begin(void); - -/* - * Return true iff ref_iterator is an empty_ref_iterator. - */ -int is_empty_ref_iterator(struct ref_iterator *ref_iterator); - -/* - * Return an iterator that goes over each reference in `refs` for - * which the refname begins with prefix. If trim is non-zero, then - * trim that many characters off the beginning of each refname. flags - * can be DO_FOR_EACH_INCLUDE_BROKEN to include broken references in - * the iteration. The output is ordered by refname. - */ -struct ref_iterator *refs_ref_iterator_begin( - struct ref_store *refs, - const char *prefix, int trim, int flags); - -/* - * A callback function used to instruct merge_ref_iterator how to - * interleave the entries from iter0 and iter1. The function should - * return one of the constants defined in enum iterator_selection. It - * must not advance either of the iterators itself. - * - * The function must be prepared to handle the case that iter0 and/or - * iter1 is NULL, which indicates that the corresponding sub-iterator - * has been exhausted. Its return value must be consistent with the - * current states of the iterators; e.g., it must not return - * ITER_SKIP_1 if iter1 has already been exhausted. - */ -typedef enum iterator_selection ref_iterator_select_fn( - struct ref_iterator *iter0, struct ref_iterator *iter1, - void *cb_data); - -/* - * Iterate over the entries from iter0 and iter1, with the values - * interleaved as directed by the select function. The iterator takes - * ownership of iter0 and iter1 and frees them when the iteration is - * over. A derived class should set `ordered` to 1 or 0 based on - * whether it generates its output in order by reference name. - */ -struct ref_iterator *merge_ref_iterator_begin( - int ordered, - struct ref_iterator *iter0, struct ref_iterator *iter1, - ref_iterator_select_fn *select, void *cb_data); - -/* - * An iterator consisting of the union of the entries from front and - * back. If there are entries common to the two sub-iterators, use the - * one from front. Each iterator must iterate over its entries in - * strcmp() order by refname for this to work. - * - * The new iterator takes ownership of its arguments and frees them - * when the iteration is over. As a convenience to callers, if front - * or back is an empty_ref_iterator, then abort that one immediately - * and return the other iterator directly, without wrapping it. - */ -struct ref_iterator *overlay_ref_iterator_begin( - struct ref_iterator *front, struct ref_iterator *back); - -/* - * Wrap iter0, only letting through the references whose names start - * with prefix. If trim is set, set iter->refname to the name of the - * reference with that many characters trimmed off the front; - * otherwise set it to the full refname. The new iterator takes over - * ownership of iter0 and frees it when iteration is over. It makes - * its own copy of prefix. - * - * As an convenience to callers, if prefix is the empty string and - * trim is zero, this function returns iter0 directly, without - * wrapping it. - * - * The resulting ref_iterator is ordered if iter0 is. - */ -struct ref_iterator *prefix_ref_iterator_begin(struct ref_iterator *iter0, - const char *prefix, - int trim); - -/* Internal implementation of reference iteration: */ - -/* - * Base class constructor for ref_iterators. Initialize the - * ref_iterator part of iter, setting its vtable pointer as specified. - * `ordered` should be set to 1 if the iterator will iterate over - * references in order by refname; otherwise it should be set to 0. - * This is meant to be called only by the initializers of derived - * classes. - */ -void base_ref_iterator_init(struct ref_iterator *iter, - struct ref_iterator_vtable *vtable, - int ordered); - -/* - * Base class destructor for ref_iterators. Destroy the ref_iterator - * part of iter and shallow-free the object. This is meant to be - * called only by the destructors of derived classes. - */ -void base_ref_iterator_free(struct ref_iterator *iter); - -/* Virtual function declarations for ref_iterators: */ - -typedef int ref_iterator_advance_fn(struct ref_iterator *ref_iterator); - -typedef int ref_iterator_peel_fn(struct ref_iterator *ref_iterator, - struct object_id *peeled); - -/* - * Implementations of this function should free any resources specific - * to the derived class, then call base_ref_iterator_free() to clean - * up and free the ref_iterator object. - */ -typedef int ref_iterator_abort_fn(struct ref_iterator *ref_iterator); - -struct ref_iterator_vtable { - ref_iterator_advance_fn *advance; - ref_iterator_peel_fn *peel; - ref_iterator_abort_fn *abort; -}; - -/* - * current_ref_iter is a performance hack: when iterating over - * references using the for_each_ref*() functions, current_ref_iter is - * set to the reference iterator before calling the callback function. - * If the callback function calls peel_ref(), then peel_ref() first - * checks whether the reference to be peeled is the one referred to by - * the iterator (it usually is) and if so, asks the iterator for the - * peeled version of the reference if it is available. This avoids a - * refname lookup in a common case. current_ref_iter is set to NULL - * when the iteration is over. - */ -extern struct ref_iterator *current_ref_iter; - -/* - * The common backend for the for_each_*ref* functions. Call fn for - * each reference in iter. If the iterator itself ever returns - * ITER_ERROR, return -1. If fn ever returns a non-zero value, stop - * the iteration and return that value. Otherwise, return 0. In any - * case, free the iterator when done. This function is basically an - * adapter between the callback style of reference iteration and the - * iterator style. - */ -int do_for_each_repo_ref_iterator(struct repository *r, - struct ref_iterator *iter, - each_repo_ref_fn fn, void *cb_data); - -/* - * 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 */ - -/* ref_store_init flags */ -#define REF_STORE_READ (1 << 0) -#define REF_STORE_WRITE (1 << 1) /* can perform update operations */ -#define REF_STORE_ODB (1 << 2) /* has access to object database */ -#define REF_STORE_MAIN (1 << 3) -#define REF_STORE_ALL_CAPS (REF_STORE_READ | \ - REF_STORE_WRITE | \ - REF_STORE_ODB | \ - REF_STORE_MAIN) - -/* - * Initialize the ref_store for the specified gitdir. 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 *gitdir, - unsigned int flags); - -typedef int ref_init_db_fn(struct ref_store *refs, struct strbuf *err); - -typedef int ref_transaction_prepare_fn(struct ref_store *refs, - struct ref_transaction *transaction, - struct strbuf *err); - -typedef int ref_transaction_finish_fn(struct ref_store *refs, - struct ref_transaction *transaction, - struct strbuf *err); - -typedef int ref_transaction_abort_fn(struct ref_store *refs, - struct ref_transaction *transaction, - struct strbuf *err); - -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); -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, const char *msg, - 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); -typedef int copy_ref_fn(struct ref_store *ref_store, - const char *oldref, const char *newref, - const char *logmsg); - -/* - * Iterate over the references in `ref_store` whose names start with - * `prefix`. `prefix` is matched as a literal string, without regard - * for path separators. If prefix is NULL or the empty string, iterate - * over all references in `ref_store`. The output is ordered by - * refname. - */ -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 struct object_id *oid, - 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: - * - * - If refname is the name of a normal reference, fill in oid - * (leaving referent unchanged). - * - * - If refname is the name of a symbolic reference, write the full - * name of the reference to which it refers (e.g. - * "refs/heads/master") to referent and set the REF_ISSYMREF bit in - * type (leaving oid unchanged). The caller is responsible for - * validating that referent is a valid reference name. - * - * WARNING: refname might be used as part of a filename, so it is - * important from a security standpoint that it be safe in the sense - * of refname_is_safe(). Moreover, for symrefs this function sets - * referent to whatever the repository says, which might not be a - * properly-formatted or even safe reference name. NEITHER INPUT NOR - * OUTPUT REFERENCE NAMES ARE VALIDATED WITHIN THIS FUNCTION. - * - * Return 0 on success. If the ref doesn't exist, set errno to ENOENT - * and return -1. If the ref exists but is neither a symbolic ref nor - * an object ID, it is broken; set REF_ISBROKEN in type, set errno to - * EINVAL, and return -1. If there is another error reading the ref, - * set errno appropriately and return -1. - * - * Backend-specific flags might be set in type as well, regardless of - * outcome. - * - * It is OK for refname to point into referent. If so: - * - * - if the function succeeds with REF_ISSYMREF, referent will be - * overwritten and the memory formerly pointed to by it might be - * changed or even freed. - * - * - in all other cases, referent will be untouched, and therefore - * refname will still be valid and unchanged. - */ -typedef int read_raw_ref_fn(struct ref_store *ref_store, - const char *refname, struct object_id *oid, - struct strbuf *referent, unsigned int *type); - -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_prepare_fn *transaction_prepare; - ref_transaction_finish_fn *transaction_finish; - ref_transaction_abort_fn *transaction_abort; - ref_transaction_commit_fn *initial_transaction_commit; - - pack_refs_fn *pack_refs; - create_symref_fn *create_symref; - delete_refs_fn *delete_refs; - rename_ref_fn *rename_ref; - copy_ref_fn *copy_ref; - - ref_iterator_begin_fn *iterator_begin; - read_raw_ref_fn *read_raw_ref; - - 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; -extern struct ref_storage_be refs_be_packed; - -/* - * 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; -}; - -/* - * Fill in the generic part of refs and add it to our collection of - * reference stores. - */ -void base_ref_store_init(struct ref_store *refs, - const struct ref_storage_be *be); - -#endif /* REFS_REFS_INTERNAL_H */ |