2015-11-09 13:34:01 +00:00
|
|
|
#include "../cache.h"
|
|
|
|
|
#include "../refs.h"
|
|
|
|
|
#include "refs-internal.h"
|
2017-04-16 06:41:31 +00:00
|
|
|
#include "ref-cache.h"
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
#include "../iterator.h"
|
2016-06-18 04:15:19 +00:00
|
|
|
#include "../dir-iterator.h"
|
2015-11-09 13:34:01 +00:00
|
|
|
#include "../lockfile.h"
|
|
|
|
|
#include "../object.h"
|
|
|
|
|
#include "../dir.h"
|
|
|
|
|
|
|
|
|
|
struct ref_lock {
|
|
|
|
|
char *ref_name;
|
|
|
|
|
struct lock_file *lk;
|
|
|
|
|
struct object_id old_oid;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*
|
2016-06-18 04:15:14 +00:00
|
|
|
* 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.
|
2015-11-09 13:34:01 +00:00
|
|
|
*/
|
2016-06-18 04:15:14 +00:00
|
|
|
static int ref_resolves_to_object(const char *refname,
|
|
|
|
|
const struct object_id *oid,
|
|
|
|
|
unsigned int flags)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2016-06-18 04:15:14 +00:00
|
|
|
if (flags & REF_ISBROKEN)
|
2015-11-09 13:34:01 +00:00
|
|
|
return 0;
|
2016-06-18 04:15:14 +00:00
|
|
|
if (!has_sha1_file(oid->hash)) {
|
|
|
|
|
error("%s does not point to a valid object!", refname);
|
2015-11-09 13:34:01 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct packed_ref_cache {
|
2017-04-16 06:41:32 +00:00
|
|
|
struct ref_cache *cache;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Count of references to the data structure in this instance,
|
refs: rename struct ref_cache to files_ref_store
The greater goal of this patch series is to develop the concept of a
reference store, which is a place that references, their values, and
their reflogs are stored, and to virtualize the reference interface so
that different types of ref_stores can be implemented. We will then, for
example, use ref_store instances to access submodule references and
worktree references.
Currently, we keep a ref_cache for each submodule that has had its
references iterated over. It is a far cry from a ref_store, but they are
stored the way we will want to store ref_stores, and ref_stores will
eventually have to hold the reference caches. So let's treat ref_caches
as embryo ref_stores, and build them out from there.
As the first step, simply rename `ref_cache` to `files_ref_store`, and
rename some functions and attributes correspondingly.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-09-04 16:08:09 +00:00
|
|
|
* including the pointer from files_ref_store::packed if any.
|
|
|
|
|
* The data will not be freed as long as the reference count
|
|
|
|
|
* is nonzero.
|
2015-11-09 13:34:01 +00:00
|
|
|
*/
|
|
|
|
|
unsigned int referrers;
|
|
|
|
|
|
|
|
|
|
/* The metadata from when this packed-refs cache was read */
|
|
|
|
|
struct stat_validity validity;
|
|
|
|
|
};
|
|
|
|
|
|
2017-06-23 07:01:21 +00:00
|
|
|
/*
|
|
|
|
|
* A container for `packed-refs`-related data. It is not (yet) a
|
|
|
|
|
* `ref_store`.
|
|
|
|
|
*/
|
|
|
|
|
struct packed_ref_store {
|
|
|
|
|
unsigned int store_flags;
|
|
|
|
|
|
2017-06-23 07:01:22 +00:00
|
|
|
/* The path of the "packed-refs" file: */
|
|
|
|
|
char *path;
|
|
|
|
|
|
2017-06-23 07:01:21 +00:00
|
|
|
/*
|
|
|
|
|
* A cache of the values read from the `packed-refs` file, if
|
|
|
|
|
* it might still be current; otherwise, NULL.
|
|
|
|
|
*/
|
|
|
|
|
struct packed_ref_cache *cache;
|
2017-06-23 07:01:23 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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;
|
2017-06-23 07:01:21 +00:00
|
|
|
};
|
|
|
|
|
|
2017-06-23 07:01:22 +00:00
|
|
|
static struct packed_ref_store *packed_ref_store_create(
|
|
|
|
|
const char *path, unsigned int store_flags)
|
2017-06-23 07:01:21 +00:00
|
|
|
{
|
|
|
|
|
struct packed_ref_store *refs = xcalloc(1, sizeof(*refs));
|
|
|
|
|
|
|
|
|
|
refs->store_flags = store_flags;
|
2017-06-23 07:01:22 +00:00
|
|
|
refs->path = xstrdup(path);
|
2017-06-23 07:01:21 +00:00
|
|
|
return refs;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-23 07:01:29 +00:00
|
|
|
/*
|
|
|
|
|
* Die if refs is not the main ref store. caller is used in any
|
|
|
|
|
* necessary error messages.
|
|
|
|
|
*/
|
|
|
|
|
static void packed_assert_main_repository(struct packed_ref_store *refs,
|
|
|
|
|
const char *caller)
|
|
|
|
|
{
|
|
|
|
|
if (refs->store_flags & REF_STORE_MAIN)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
die("BUG: operation %s only allowed for main ref store", caller);
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-09 13:34:01 +00:00
|
|
|
/*
|
|
|
|
|
* Future: need to be in "struct repository"
|
|
|
|
|
* when doing a full libification.
|
|
|
|
|
*/
|
2016-09-04 16:08:11 +00:00
|
|
|
struct files_ref_store {
|
|
|
|
|
struct ref_store base;
|
2017-03-26 02:42:32 +00:00
|
|
|
unsigned int store_flags;
|
2017-02-10 11:16:16 +00:00
|
|
|
|
2017-03-26 02:42:24 +00:00
|
|
|
char *gitdir;
|
|
|
|
|
char *gitcommondir;
|
2017-03-26 02:42:18 +00:00
|
|
|
|
2017-04-16 06:41:32 +00:00
|
|
|
struct ref_cache *loose;
|
2017-05-22 14:17:40 +00:00
|
|
|
|
2017-06-23 07:01:21 +00:00
|
|
|
struct packed_ref_store *packed_ref_store;
|
2016-09-04 16:08:11 +00:00
|
|
|
};
|
2015-11-09 13:34:01 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Increment the reference count of *packed_refs.
|
|
|
|
|
*/
|
|
|
|
|
static void acquire_packed_ref_cache(struct packed_ref_cache *packed_refs)
|
|
|
|
|
{
|
|
|
|
|
packed_refs->referrers++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Decrease the reference count of *packed_refs. If it goes to zero,
|
|
|
|
|
* free *packed_refs and return true; otherwise return false.
|
|
|
|
|
*/
|
|
|
|
|
static int release_packed_ref_cache(struct packed_ref_cache *packed_refs)
|
|
|
|
|
{
|
|
|
|
|
if (!--packed_refs->referrers) {
|
2017-04-16 06:41:32 +00:00
|
|
|
free_ref_cache(packed_refs->cache);
|
2015-11-09 13:34:01 +00:00
|
|
|
stat_validity_clear(&packed_refs->validity);
|
|
|
|
|
free(packed_refs);
|
|
|
|
|
return 1;
|
|
|
|
|
} else {
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-23 07:01:24 +00:00
|
|
|
static void clear_packed_ref_cache(struct packed_ref_store *refs)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-06-23 07:01:24 +00:00
|
|
|
if (refs->cache) {
|
|
|
|
|
struct packed_ref_cache *cache = refs->cache;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-06-23 07:01:24 +00:00
|
|
|
if (is_lock_file_locked(&refs->lock))
|
2017-05-22 14:17:34 +00:00
|
|
|
die("BUG: packed-ref cache cleared while locked");
|
2017-06-23 07:01:24 +00:00
|
|
|
refs->cache = NULL;
|
|
|
|
|
release_packed_ref_cache(cache);
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
refs: rename struct ref_cache to files_ref_store
The greater goal of this patch series is to develop the concept of a
reference store, which is a place that references, their values, and
their reflogs are stored, and to virtualize the reference interface so
that different types of ref_stores can be implemented. We will then, for
example, use ref_store instances to access submodule references and
worktree references.
Currently, we keep a ref_cache for each submodule that has had its
references iterated over. It is a far cry from a ref_store, but they are
stored the way we will want to store ref_stores, and ref_stores will
eventually have to hold the reference caches. So let's treat ref_caches
as embryo ref_stores, and build them out from there.
As the first step, simply rename `ref_cache` to `files_ref_store`, and
rename some functions and attributes correspondingly.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-09-04 16:08:09 +00:00
|
|
|
static void clear_loose_ref_cache(struct files_ref_store *refs)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
|
|
|
|
if (refs->loose) {
|
2017-04-16 06:41:32 +00:00
|
|
|
free_ref_cache(refs->loose);
|
2015-11-09 13:34:01 +00:00
|
|
|
refs->loose = NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-01-22 22:29:30 +00:00
|
|
|
/*
|
|
|
|
|
* Create a new submodule ref cache and add it to the internal
|
|
|
|
|
* set of caches.
|
|
|
|
|
*/
|
2017-03-26 02:42:32 +00:00
|
|
|
static struct ref_store *files_ref_store_create(const char *gitdir,
|
|
|
|
|
unsigned int flags)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2016-09-04 16:08:11 +00:00
|
|
|
struct files_ref_store *refs = xcalloc(1, sizeof(*refs));
|
|
|
|
|
struct ref_store *ref_store = (struct ref_store *)refs;
|
2017-03-26 02:42:24 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-02-10 11:16:17 +00:00
|
|
|
base_ref_store_init(ref_store, &refs_be_files);
|
2017-03-26 02:42:32 +00:00
|
|
|
refs->store_flags = flags;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-03-26 02:42:24 +00:00
|
|
|
refs->gitdir = xstrdup(gitdir);
|
|
|
|
|
get_common_dir_noenv(&sb, gitdir);
|
|
|
|
|
refs->gitcommondir = strbuf_detach(&sb, NULL);
|
|
|
|
|
strbuf_addf(&sb, "%s/packed-refs", refs->gitcommondir);
|
2017-06-23 07:01:22 +00:00
|
|
|
refs->packed_ref_store = packed_ref_store_create(sb.buf, flags);
|
|
|
|
|
strbuf_release(&sb);
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2016-09-04 16:08:11 +00:00
|
|
|
return ref_store;
|
2016-01-22 22:29:30 +00:00
|
|
|
}
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-02-10 11:16:16 +00:00
|
|
|
/*
|
2017-03-26 02:42:32 +00:00
|
|
|
* Die if refs is not the main ref store. caller is used in any
|
|
|
|
|
* necessary error messages.
|
2017-02-10 11:16:16 +00:00
|
|
|
*/
|
|
|
|
|
static void files_assert_main_repository(struct files_ref_store *refs,
|
|
|
|
|
const char *caller)
|
|
|
|
|
{
|
2017-03-26 02:42:32 +00:00
|
|
|
if (refs->store_flags & REF_STORE_MAIN)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
die("BUG: operation %s only allowed for main ref store", caller);
|
2017-02-10 11:16:16 +00:00
|
|
|
}
|
|
|
|
|
|
2016-01-22 22:29:30 +00:00
|
|
|
/*
|
2016-09-04 16:08:11 +00:00
|
|
|
* Downcast ref_store to files_ref_store. Die if ref_store is not a
|
2017-03-26 02:42:32 +00:00
|
|
|
* 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.
|
2016-01-22 22:29:30 +00:00
|
|
|
*/
|
2017-03-26 02:42:32 +00:00
|
|
|
static struct files_ref_store *files_downcast(struct ref_store *ref_store,
|
|
|
|
|
unsigned int required_flags,
|
|
|
|
|
const char *caller)
|
2016-01-22 22:29:30 +00:00
|
|
|
{
|
2017-02-10 11:16:16 +00:00
|
|
|
struct files_ref_store *refs;
|
|
|
|
|
|
2016-09-04 16:08:11 +00:00
|
|
|
if (ref_store->be != &refs_be_files)
|
|
|
|
|
die("BUG: ref_store is type \"%s\" not \"files\" in %s",
|
|
|
|
|
ref_store->be->name, caller);
|
2016-06-18 04:15:12 +00:00
|
|
|
|
2017-02-10 11:16:16 +00:00
|
|
|
refs = (struct files_ref_store *)ref_store;
|
|
|
|
|
|
2017-03-26 02:42:32 +00:00
|
|
|
if ((refs->store_flags & required_flags) != required_flags)
|
|
|
|
|
die("BUG: operation %s requires abilities 0x%x, but only have 0x%x",
|
|
|
|
|
caller, required_flags, refs->store_flags);
|
2016-06-18 04:15:12 +00:00
|
|
|
|
2017-02-10 11:16:16 +00:00
|
|
|
return refs;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* The length of a peeled reference line in packed-refs, including EOL: */
|
|
|
|
|
#define PEELED_LINE_LENGTH 42
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The packed-refs header line that we write out. Perhaps other
|
|
|
|
|
* traits will be added later. The trailing space is required.
|
|
|
|
|
*/
|
|
|
|
|
static const char PACKED_REFS_HEADER[] =
|
|
|
|
|
"# pack-refs with: peeled fully-peeled \n";
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Parse one line from a packed-refs file. Write the SHA1 to sha1.
|
|
|
|
|
* Return a pointer to the refname within the line (null-terminated),
|
|
|
|
|
* or NULL if there was a problem.
|
|
|
|
|
*/
|
2017-05-06 22:10:24 +00:00
|
|
|
static const char *parse_ref_line(struct strbuf *line, struct object_id *oid)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
|
|
|
|
const char *ref;
|
|
|
|
|
|
2017-05-06 22:10:24 +00:00
|
|
|
if (parse_oid_hex(line->buf, oid, &ref) < 0)
|
2015-11-09 13:34:01 +00:00
|
|
|
return NULL;
|
2017-05-06 22:10:24 +00:00
|
|
|
if (!isspace(*ref++))
|
2015-11-09 13:34:01 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
if (isspace(*ref))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
if (line->buf[line->len - 1] != '\n')
|
|
|
|
|
return NULL;
|
|
|
|
|
line->buf[--line->len] = 0;
|
|
|
|
|
|
|
|
|
|
return ref;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2017-05-22 14:17:50 +00:00
|
|
|
* Read from `packed_refs_file` into a newly-allocated
|
|
|
|
|
* `packed_ref_cache` and return it. The return value will already
|
|
|
|
|
* have its reference count incremented.
|
2015-11-09 13:34:01 +00:00
|
|
|
*
|
|
|
|
|
* A comment line of the form "# pack-refs with: " may contain zero or
|
|
|
|
|
* more traits. We interpret the traits as follows:
|
|
|
|
|
*
|
|
|
|
|
* No traits:
|
|
|
|
|
*
|
|
|
|
|
* 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).
|
|
|
|
|
*/
|
2017-05-22 14:17:50 +00:00
|
|
|
static struct packed_ref_cache *read_packed_refs(const char *packed_refs_file)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-05-22 14:17:50 +00:00
|
|
|
FILE *f;
|
|
|
|
|
struct packed_ref_cache *packed_refs = xcalloc(1, sizeof(*packed_refs));
|
2015-11-09 13:34:01 +00:00
|
|
|
struct ref_entry *last = NULL;
|
|
|
|
|
struct strbuf line = STRBUF_INIT;
|
|
|
|
|
enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled = PEELED_NONE;
|
2017-05-22 14:17:50 +00:00
|
|
|
struct ref_dir *dir;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-05-22 14:17:50 +00:00
|
|
|
acquire_packed_ref_cache(packed_refs);
|
|
|
|
|
packed_refs->cache = create_ref_cache(NULL, NULL);
|
|
|
|
|
packed_refs->cache->root->flag &= ~REF_INCOMPLETE;
|
|
|
|
|
|
|
|
|
|
f = fopen(packed_refs_file, "r");
|
2017-05-22 14:17:51 +00:00
|
|
|
if (!f) {
|
|
|
|
|
if (errno == ENOENT) {
|
|
|
|
|
/*
|
|
|
|
|
* This is OK; it just means that no
|
|
|
|
|
* "packed-refs" file has been written yet,
|
|
|
|
|
* which is equivalent to it being empty.
|
|
|
|
|
*/
|
|
|
|
|
return packed_refs;
|
|
|
|
|
} else {
|
|
|
|
|
die_errno("couldn't read %s", packed_refs_file);
|
|
|
|
|
}
|
|
|
|
|
}
|
2017-05-22 14:17:50 +00:00
|
|
|
|
|
|
|
|
stat_validity_update(&packed_refs->validity, fileno(f));
|
|
|
|
|
|
|
|
|
|
dir = get_ref_dir(packed_refs->cache->root);
|
2015-11-09 13:34:01 +00:00
|
|
|
while (strbuf_getwholeline(&line, f, '\n') != EOF) {
|
2017-05-06 22:10:24 +00:00
|
|
|
struct object_id oid;
|
2015-11-09 13:34:01 +00:00
|
|
|
const char *refname;
|
|
|
|
|
const char *traits;
|
|
|
|
|
|
|
|
|
|
if (skip_prefix(line.buf, "# pack-refs with:", &traits)) {
|
|
|
|
|
if (strstr(traits, " fully-peeled "))
|
|
|
|
|
peeled = PEELED_FULLY;
|
|
|
|
|
else if (strstr(traits, " peeled "))
|
|
|
|
|
peeled = PEELED_TAGS;
|
|
|
|
|
/* perhaps other traits later as well */
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-06 22:10:24 +00:00
|
|
|
refname = parse_ref_line(&line, &oid);
|
2015-11-09 13:34:01 +00:00
|
|
|
if (refname) {
|
|
|
|
|
int flag = REF_ISPACKED;
|
|
|
|
|
|
|
|
|
|
if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
|
|
|
|
|
if (!refname_is_safe(refname))
|
|
|
|
|
die("packed refname is dangerous: %s", refname);
|
2017-05-06 22:10:24 +00:00
|
|
|
oidclr(&oid);
|
2015-11-09 13:34:01 +00:00
|
|
|
flag |= REF_BAD_NAME | REF_ISBROKEN;
|
|
|
|
|
}
|
2017-05-22 14:17:53 +00:00
|
|
|
last = create_ref_entry(refname, &oid, flag);
|
2015-11-09 13:34:01 +00:00
|
|
|
if (peeled == PEELED_FULLY ||
|
|
|
|
|
(peeled == PEELED_TAGS && starts_with(refname, "refs/tags/")))
|
|
|
|
|
last->flag |= REF_KNOWS_PEELED;
|
2017-04-16 06:41:28 +00:00
|
|
|
add_ref_entry(dir, last);
|
2015-11-09 13:34:01 +00:00
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (last &&
|
|
|
|
|
line.buf[0] == '^' &&
|
|
|
|
|
line.len == PEELED_LINE_LENGTH &&
|
|
|
|
|
line.buf[PEELED_LINE_LENGTH - 1] == '\n' &&
|
2017-05-06 22:10:24 +00:00
|
|
|
!get_oid_hex(line.buf + 1, &oid)) {
|
|
|
|
|
oidcpy(&last->u.value.peeled, &oid);
|
2015-11-09 13:34:01 +00:00
|
|
|
/*
|
|
|
|
|
* Regardless of what the file header said,
|
|
|
|
|
* we definitely know the value of *this*
|
|
|
|
|
* reference:
|
|
|
|
|
*/
|
|
|
|
|
last->flag |= REF_KNOWS_PEELED;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-22 14:17:50 +00:00
|
|
|
fclose(f);
|
2015-11-09 13:34:01 +00:00
|
|
|
strbuf_release(&line);
|
2017-05-22 14:17:50 +00:00
|
|
|
|
|
|
|
|
return packed_refs;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
static void files_reflog_path(struct files_ref_store *refs,
|
|
|
|
|
struct strbuf *sb,
|
|
|
|
|
const char *refname)
|
|
|
|
|
{
|
|
|
|
|
if (!refname) {
|
2017-03-26 02:42:24 +00:00
|
|
|
/*
|
|
|
|
|
* FIXME: of course this is wrong in multi worktree
|
|
|
|
|
* setting. To be fixed real soon.
|
|
|
|
|
*/
|
|
|
|
|
strbuf_addf(sb, "%s/logs", refs->gitcommondir);
|
2017-03-26 02:42:22 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-26 02:42:24 +00:00
|
|
|
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_NORMAL:
|
|
|
|
|
strbuf_addf(sb, "%s/logs/%s", refs->gitcommondir, refname);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
die("BUG: unknown ref type %d of ref %s",
|
|
|
|
|
ref_type(refname), refname);
|
|
|
|
|
}
|
2017-03-26 02:42:22 +00:00
|
|
|
}
|
|
|
|
|
|
2017-03-26 02:42:23 +00:00
|
|
|
static void files_ref_path(struct files_ref_store *refs,
|
|
|
|
|
struct strbuf *sb,
|
|
|
|
|
const char *refname)
|
|
|
|
|
{
|
2017-03-26 02:42:24 +00:00
|
|
|
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_NORMAL:
|
|
|
|
|
strbuf_addf(sb, "%s/%s", refs->gitcommondir, refname);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
die("BUG: unknown ref type %d of ref %s",
|
|
|
|
|
ref_type(refname), refname);
|
|
|
|
|
}
|
2017-03-26 02:42:23 +00:00
|
|
|
}
|
|
|
|
|
|
2017-06-12 08:06:13 +00:00
|
|
|
/*
|
|
|
|
|
* Check that the packed refs cache (if any) still reflects the
|
|
|
|
|
* contents of the file. If not, clear the cache.
|
|
|
|
|
*/
|
2017-06-23 07:01:25 +00:00
|
|
|
static void validate_packed_ref_cache(struct packed_ref_store *refs)
|
2017-06-12 08:06:13 +00:00
|
|
|
{
|
2017-06-23 07:01:25 +00:00
|
|
|
if (refs->cache &&
|
|
|
|
|
!stat_validity_check(&refs->cache->validity, refs->path))
|
|
|
|
|
clear_packed_ref_cache(refs);
|
2017-06-12 08:06:13 +00:00
|
|
|
}
|
|
|
|
|
|
2015-11-09 13:34:01 +00:00
|
|
|
/*
|
2017-06-23 07:01:26 +00:00
|
|
|
* Get the packed_ref_cache for the specified packed_ref_store,
|
2017-05-22 14:17:49 +00:00
|
|
|
* 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()`.
|
2015-11-09 13:34:01 +00:00
|
|
|
*/
|
2017-06-23 07:01:26 +00:00
|
|
|
static struct packed_ref_cache *get_packed_ref_cache(struct packed_ref_store *refs)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-06-23 07:01:26 +00:00
|
|
|
if (!is_lock_file_locked(&refs->lock))
|
|
|
|
|
validate_packed_ref_cache(refs);
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-06-23 07:01:26 +00:00
|
|
|
if (!refs->cache)
|
|
|
|
|
refs->cache = read_packed_refs(refs->path);
|
2017-05-22 14:17:50 +00:00
|
|
|
|
2017-06-23 07:01:26 +00:00
|
|
|
return refs->cache;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct ref_dir *get_packed_ref_dir(struct packed_ref_cache *packed_ref_cache)
|
|
|
|
|
{
|
2017-04-16 06:41:32 +00:00
|
|
|
return get_ref_dir(packed_ref_cache->cache->root);
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
2017-06-23 07:01:27 +00:00
|
|
|
static struct ref_dir *get_packed_refs(struct packed_ref_store *refs)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-06-23 07:01:27 +00:00
|
|
|
return get_packed_ref_dir(get_packed_ref_cache(refs));
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2017-06-23 07:01:20 +00:00
|
|
|
* Add or overwrite a reference in the in-memory packed reference
|
|
|
|
|
* cache. This may only be called while the packed-refs file is locked
|
|
|
|
|
* (see lock_packed_refs()). To actually write the packed-refs file,
|
|
|
|
|
* call commit_packed_refs().
|
2015-11-09 13:34:01 +00:00
|
|
|
*/
|
2017-06-23 07:01:28 +00:00
|
|
|
static void add_packed_ref(struct packed_ref_store *refs,
|
2017-05-06 22:10:24 +00:00
|
|
|
const char *refname, const struct object_id *oid)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-06-23 07:01:20 +00:00
|
|
|
struct ref_dir *packed_refs;
|
|
|
|
|
struct ref_entry *packed_entry;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-06-23 07:01:28 +00:00
|
|
|
if (!is_lock_file_locked(&refs->lock))
|
2017-05-22 14:17:34 +00:00
|
|
|
die("BUG: packed refs not locked");
|
2017-05-22 14:17:53 +00:00
|
|
|
|
|
|
|
|
if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))
|
|
|
|
|
die("Reference has invalid format: '%s'", refname);
|
|
|
|
|
|
2017-06-23 07:01:28 +00:00
|
|
|
packed_refs = get_packed_refs(refs);
|
2017-06-23 07:01:20 +00:00
|
|
|
packed_entry = find_ref_entry(packed_refs, refname);
|
|
|
|
|
if (packed_entry) {
|
|
|
|
|
/* Overwrite the existing entry: */
|
|
|
|
|
oidcpy(&packed_entry->u.value.oid, oid);
|
|
|
|
|
packed_entry->flag = REF_ISPACKED;
|
|
|
|
|
oidclr(&packed_entry->u.value.peeled);
|
|
|
|
|
} else {
|
|
|
|
|
packed_entry = create_ref_entry(refname, oid, REF_ISPACKED);
|
|
|
|
|
add_ref_entry(packed_refs, packed_entry);
|
|
|
|
|
}
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
2017-04-16 06:41:34 +00:00
|
|
|
static void loose_fill_ref_dir(struct ref_store *ref_store,
|
|
|
|
|
struct ref_dir *dir, const char *dirname)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-04-16 06:41:34 +00:00
|
|
|
struct files_ref_store *refs =
|
|
|
|
|
files_downcast(ref_store, REF_STORE_READ, "fill_ref_dir");
|
2015-11-09 13:34:01 +00:00
|
|
|
DIR *d;
|
|
|
|
|
struct dirent *de;
|
|
|
|
|
int dirnamelen = strlen(dirname);
|
|
|
|
|
struct strbuf refname;
|
|
|
|
|
struct strbuf path = STRBUF_INIT;
|
|
|
|
|
size_t path_baselen;
|
|
|
|
|
|
2017-03-26 02:42:23 +00:00
|
|
|
files_ref_path(refs, &path, dirname);
|
2015-11-09 13:34:01 +00:00
|
|
|
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) {
|
2017-05-06 22:10:24 +00:00
|
|
|
struct object_id oid;
|
2015-11-09 13:34:01 +00:00
|
|
|
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,
|
2017-04-16 06:41:33 +00:00
|
|
|
create_dir_entry(dir->cache, refname.buf,
|
2015-11-09 13:34:01 +00:00
|
|
|
refname.len, 1));
|
|
|
|
|
} else {
|
2017-03-26 02:42:34 +00:00
|
|
|
if (!refs_resolve_ref_unsafe(&refs->base,
|
2017-02-09 20:53:52 +00:00
|
|
|
refname.buf,
|
|
|
|
|
RESOLVE_REF_READING,
|
2017-05-06 22:10:24 +00:00
|
|
|
oid.hash, &flag)) {
|
|
|
|
|
oidclr(&oid);
|
2015-11-09 13:34:01 +00:00
|
|
|
flag |= REF_ISBROKEN;
|
2017-05-06 22:10:24 +00:00
|
|
|
} else if (is_null_oid(&oid)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
/*
|
|
|
|
|
* It is so astronomically unlikely
|
|
|
|
|
* that NULL_SHA1 is the SHA-1 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);
|
2017-05-06 22:10:24 +00:00
|
|
|
oidclr(&oid);
|
2015-11-09 13:34:01 +00:00
|
|
|
flag |= REF_BAD_NAME | REF_ISBROKEN;
|
|
|
|
|
}
|
|
|
|
|
add_entry_to_dir(dir,
|
2017-05-22 14:17:53 +00:00
|
|
|
create_ref_entry(refname.buf, &oid, flag));
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
strbuf_setlen(&refname, dirnamelen);
|
|
|
|
|
strbuf_setlen(&path, path_baselen);
|
|
|
|
|
}
|
|
|
|
|
strbuf_release(&refname);
|
|
|
|
|
strbuf_release(&path);
|
|
|
|
|
closedir(d);
|
2017-04-16 06:41:35 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Manually add refs/bisect, which, being per-worktree, might
|
|
|
|
|
* not appear in the directory listing for refs/ in the main
|
|
|
|
|
* repo.
|
|
|
|
|
*/
|
|
|
|
|
if (!strcmp(dirname, "refs/")) {
|
|
|
|
|
int pos = search_ref_dir(dir, "refs/bisect/", 12);
|
|
|
|
|
|
|
|
|
|
if (pos < 0) {
|
|
|
|
|
struct ref_entry *child_entry = create_dir_entry(
|
|
|
|
|
dir->cache, "refs/bisect/", 12, 1);
|
|
|
|
|
add_entry_to_dir(dir, child_entry);
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
2017-04-16 06:41:38 +00:00
|
|
|
static struct ref_cache *get_loose_ref_cache(struct files_ref_store *refs)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
|
|
|
|
if (!refs->loose) {
|
|
|
|
|
/*
|
|
|
|
|
* Mark the top-level directory complete because we
|
|
|
|
|
* are about to read the only subdirectory that can
|
|
|
|
|
* hold references:
|
|
|
|
|
*/
|
2017-04-16 06:41:34 +00:00
|
|
|
refs->loose = create_ref_cache(&refs->base, loose_fill_ref_dir);
|
2017-04-16 06:41:32 +00:00
|
|
|
|
|
|
|
|
/* We're going to fill the top level ourselves: */
|
|
|
|
|
refs->loose->root->flag &= ~REF_INCOMPLETE;
|
|
|
|
|
|
2015-11-09 13:34:01 +00:00
|
|
|
/*
|
2017-04-16 06:41:32 +00:00
|
|
|
* Add an incomplete entry for "refs/" (to be filled
|
|
|
|
|
* lazily):
|
2015-11-09 13:34:01 +00:00
|
|
|
*/
|
2017-04-16 06:41:32 +00:00
|
|
|
add_entry_to_dir(get_ref_dir(refs->loose->root),
|
2017-04-16 06:41:33 +00:00
|
|
|
create_dir_entry(refs->loose, "refs/", 5, 1));
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
2017-04-16 06:41:38 +00:00
|
|
|
return refs->loose;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Return the ref_entry for the given refname from the packed
|
|
|
|
|
* references. If it does not exist, return NULL.
|
|
|
|
|
*/
|
2016-09-04 16:08:13 +00:00
|
|
|
static struct ref_entry *get_packed_ref(struct files_ref_store *refs,
|
|
|
|
|
const char *refname)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-06-23 07:01:27 +00:00
|
|
|
return find_ref_entry(get_packed_refs(refs->packed_ref_store), refname);
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2016-04-07 19:02:55 +00:00
|
|
|
* A loose ref file doesn't exist; check for a packed ref.
|
2015-11-09 13:34:01 +00:00
|
|
|
*/
|
2016-09-04 16:08:18 +00:00
|
|
|
static int resolve_packed_ref(struct files_ref_store *refs,
|
|
|
|
|
const char *refname,
|
|
|
|
|
unsigned char *sha1, unsigned int *flags)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
|
|
|
|
struct ref_entry *entry;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The loose reference file does not exist; check for a packed
|
|
|
|
|
* reference.
|
|
|
|
|
*/
|
2016-09-04 16:08:13 +00:00
|
|
|
entry = get_packed_ref(refs, refname);
|
2015-11-09 13:34:01 +00:00
|
|
|
if (entry) {
|
|
|
|
|
hashcpy(sha1, entry->u.value.oid.hash);
|
2016-04-07 19:02:57 +00:00
|
|
|
*flags |= REF_ISPACKED;
|
2015-11-09 13:34:01 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
2016-04-07 19:02:55 +00:00
|
|
|
/* refname is not a packed reference. */
|
|
|
|
|
return -1;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
2016-09-04 16:08:25 +00:00
|
|
|
static int files_read_raw_ref(struct ref_store *ref_store,
|
|
|
|
|
const char *refname, unsigned char *sha1,
|
|
|
|
|
struct strbuf *referent, unsigned int *type)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2016-09-04 16:08:14 +00:00
|
|
|
struct files_ref_store *refs =
|
2017-03-26 02:42:32 +00:00
|
|
|
files_downcast(ref_store, REF_STORE_READ, "read_raw_ref");
|
2016-04-07 19:03:02 +00:00
|
|
|
struct strbuf sb_contents = STRBUF_INIT;
|
|
|
|
|
struct strbuf sb_path = STRBUF_INIT;
|
2016-04-07 19:03:01 +00:00
|
|
|
const char *path;
|
|
|
|
|
const char *buf;
|
|
|
|
|
struct stat st;
|
|
|
|
|
int fd;
|
2016-04-07 19:03:02 +00:00
|
|
|
int ret = -1;
|
|
|
|
|
int save_errno;
|
2016-10-06 16:48:42 +00:00
|
|
|
int remaining_retries = 3;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2016-04-21 23:11:17 +00:00
|
|
|
*type = 0;
|
2016-04-07 19:03:02 +00:00
|
|
|
strbuf_reset(&sb_path);
|
2016-09-04 16:08:20 +00:00
|
|
|
|
2017-03-26 02:42:23 +00:00
|
|
|
files_ref_path(refs, &sb_path, refname);
|
2016-09-04 16:08:20 +00:00
|
|
|
|
2016-04-07 19:03:02 +00:00
|
|
|
path = sb_path.buf;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2016-04-07 19:03:01 +00:00
|
|
|
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().
|
2016-10-06 16:48:42 +00:00
|
|
|
*
|
|
|
|
|
* We'll keep a count of the retries, though, just to avoid
|
|
|
|
|
* any confusing situation sending us into an infinite loop.
|
2016-04-07 19:03:01 +00:00
|
|
|
*/
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2016-10-06 16:48:42 +00:00
|
|
|
if (remaining_retries-- <= 0)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2016-04-07 19:03:01 +00:00
|
|
|
if (lstat(path, &st) < 0) {
|
|
|
|
|
if (errno != ENOENT)
|
2016-04-07 19:03:02 +00:00
|
|
|
goto out;
|
2016-09-04 16:08:18 +00:00
|
|
|
if (resolve_packed_ref(refs, refname, sha1, type)) {
|
2016-04-07 19:03:01 +00:00
|
|
|
errno = ENOENT;
|
2016-04-07 19:03:02 +00:00
|
|
|
goto out;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
2016-04-07 19:03:02 +00:00
|
|
|
ret = 0;
|
|
|
|
|
goto out;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
2016-04-07 19:03:01 +00:00
|
|
|
/* Follow "normalized" - ie "refs/.." symlinks by hand */
|
|
|
|
|
if (S_ISLNK(st.st_mode)) {
|
2016-04-07 19:03:02 +00:00
|
|
|
strbuf_reset(&sb_contents);
|
|
|
|
|
if (strbuf_readlink(&sb_contents, path, 0) < 0) {
|
2016-04-07 19:03:01 +00:00
|
|
|
if (errno == ENOENT || errno == EINVAL)
|
2015-11-09 13:34:01 +00:00
|
|
|
/* inconsistent with lstat; retry */
|
|
|
|
|
goto stat_ref;
|
|
|
|
|
else
|
2016-04-07 19:03:02 +00:00
|
|
|
goto out;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
2016-04-07 19:03:02 +00:00
|
|
|
if (starts_with(sb_contents.buf, "refs/") &&
|
|
|
|
|
!check_refname_format(sb_contents.buf, 0)) {
|
2016-04-21 23:11:17 +00:00
|
|
|
strbuf_swap(&sb_contents, referent);
|
2016-04-26 01:06:23 +00:00
|
|
|
*type |= REF_ISSYMREF;
|
2016-04-07 19:03:02 +00:00
|
|
|
ret = 0;
|
|
|
|
|
goto out;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
files_read_raw_ref: avoid infinite loop on broken symlinks
Our ref resolution first runs lstat() on any path we try to
look up, because we want to treat symlinks specially (by
resolving them manually and considering them symrefs). But
if the results of `readlink` do _not_ look like a ref, we
fall through to treating it like a normal file, and just
read the contents of the linked path.
Since fcb7c76 (resolve_ref_unsafe(): close race condition
reading loose refs, 2013-06-19), that "normal file" code
path will stat() the file and if we see ENOENT, will jump
back to the lstat(), thinking we've seen inconsistent
results between the two calls. But for a symbolic ref, this
isn't a race: the lstat() found the symlink, and the stat()
is looking at the path it points to. We end up in an
infinite loop calling lstat() and stat().
We can fix this by avoiding the retry-on-inconsistent jump
when we know that we found a symlink. While we're at it,
let's add a comment explaining why the symlink case gets to
this code in the first place; without that, it is not
obvious that the correct solution isn't to avoid the stat()
code path entirely.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-06 19:41:08 +00:00
|
|
|
/*
|
|
|
|
|
* It doesn't look like a refname; fall through to just
|
|
|
|
|
* treating it like a non-symlink, and reading whatever it
|
|
|
|
|
* points to.
|
|
|
|
|
*/
|
2016-04-07 19:03:01 +00:00
|
|
|
}
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2016-04-07 19:03:01 +00:00
|
|
|
/* Is it a directory? */
|
|
|
|
|
if (S_ISDIR(st.st_mode)) {
|
2016-05-05 12:09:41 +00:00
|
|
|
/*
|
|
|
|
|
* Even though there is a directory where the loose
|
|
|
|
|
* ref is supposed to be, there could still be a
|
|
|
|
|
* packed ref:
|
|
|
|
|
*/
|
2016-09-04 16:08:18 +00:00
|
|
|
if (resolve_packed_ref(refs, refname, sha1, type)) {
|
2016-05-05 12:09:41 +00:00
|
|
|
errno = EISDIR;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
ret = 0;
|
2016-04-07 19:03:02 +00:00
|
|
|
goto out;
|
2016-04-07 19:03:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Anything else, just open it and try to use it as
|
|
|
|
|
* a ref
|
|
|
|
|
*/
|
|
|
|
|
fd = open(path, O_RDONLY);
|
|
|
|
|
if (fd < 0) {
|
files_read_raw_ref: avoid infinite loop on broken symlinks
Our ref resolution first runs lstat() on any path we try to
look up, because we want to treat symlinks specially (by
resolving them manually and considering them symrefs). But
if the results of `readlink` do _not_ look like a ref, we
fall through to treating it like a normal file, and just
read the contents of the linked path.
Since fcb7c76 (resolve_ref_unsafe(): close race condition
reading loose refs, 2013-06-19), that "normal file" code
path will stat() the file and if we see ENOENT, will jump
back to the lstat(), thinking we've seen inconsistent
results between the two calls. But for a symbolic ref, this
isn't a race: the lstat() found the symlink, and the stat()
is looking at the path it points to. We end up in an
infinite loop calling lstat() and stat().
We can fix this by avoiding the retry-on-inconsistent jump
when we know that we found a symlink. While we're at it,
let's add a comment explaining why the symlink case gets to
this code in the first place; without that, it is not
obvious that the correct solution isn't to avoid the stat()
code path entirely.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-06 19:41:08 +00:00
|
|
|
if (errno == ENOENT && !S_ISLNK(st.st_mode))
|
2016-04-07 19:03:01 +00:00
|
|
|
/* inconsistent with lstat; retry */
|
|
|
|
|
goto stat_ref;
|
|
|
|
|
else
|
2016-04-07 19:03:02 +00:00
|
|
|
goto out;
|
2016-04-07 19:03:01 +00:00
|
|
|
}
|
2016-04-07 19:03:02 +00:00
|
|
|
strbuf_reset(&sb_contents);
|
|
|
|
|
if (strbuf_read(&sb_contents, fd, 256) < 0) {
|
2016-04-07 19:03:01 +00:00
|
|
|
int save_errno = errno;
|
|
|
|
|
close(fd);
|
|
|
|
|
errno = save_errno;
|
2016-04-07 19:03:02 +00:00
|
|
|
goto out;
|
2016-04-07 19:03:01 +00:00
|
|
|
}
|
|
|
|
|
close(fd);
|
2016-04-07 19:03:02 +00:00
|
|
|
strbuf_rtrim(&sb_contents);
|
|
|
|
|
buf = sb_contents.buf;
|
2016-04-07 19:03:01 +00:00
|
|
|
if (starts_with(buf, "ref:")) {
|
|
|
|
|
buf += 4;
|
2015-11-09 13:34:01 +00:00
|
|
|
while (isspace(*buf))
|
|
|
|
|
buf++;
|
2016-04-07 19:03:01 +00:00
|
|
|
|
2016-04-21 23:11:17 +00:00
|
|
|
strbuf_reset(referent);
|
|
|
|
|
strbuf_addstr(referent, buf);
|
2016-04-26 01:06:23 +00:00
|
|
|
*type |= REF_ISSYMREF;
|
2016-04-07 19:03:02 +00:00
|
|
|
ret = 0;
|
|
|
|
|
goto out;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
2016-04-07 19:03:01 +00:00
|
|
|
/*
|
|
|
|
|
* Please note that FETCH_HEAD has additional
|
|
|
|
|
* data after the sha.
|
|
|
|
|
*/
|
|
|
|
|
if (get_sha1_hex(buf, sha1) ||
|
|
|
|
|
(buf[40] != '\0' && !isspace(buf[40]))) {
|
2016-04-26 01:06:23 +00:00
|
|
|
*type |= REF_ISBROKEN;
|
2016-04-07 19:03:01 +00:00
|
|
|
errno = EINVAL;
|
2016-04-07 19:03:02 +00:00
|
|
|
goto out;
|
2016-04-07 19:03:01 +00:00
|
|
|
}
|
|
|
|
|
|
2016-04-07 19:03:02 +00:00
|
|
|
ret = 0;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2016-04-07 19:03:02 +00:00
|
|
|
out:
|
|
|
|
|
save_errno = errno;
|
2015-11-09 13:34:01 +00:00
|
|
|
strbuf_release(&sb_path);
|
|
|
|
|
strbuf_release(&sb_contents);
|
2016-04-07 19:03:02 +00:00
|
|
|
errno = save_errno;
|
2015-11-09 13:34:01 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-24 06:11:37 +00:00
|
|
|
static void unlock_ref(struct ref_lock *lock)
|
|
|
|
|
{
|
|
|
|
|
/* Do not free lock->lk -- atexit() still looks at them */
|
|
|
|
|
if (lock->lk)
|
|
|
|
|
rollback_lock_file(lock->lk);
|
|
|
|
|
free(lock->ref_name);
|
|
|
|
|
free(lock);
|
|
|
|
|
}
|
|
|
|
|
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
/*
|
|
|
|
|
* 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
|
2017-04-16 06:41:27 +00:00
|
|
|
* are passed to refs_verify_refname_available() for this check.
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
*
|
|
|
|
|
* If mustexist is not set and the reference is not found or is
|
|
|
|
|
* broken, lock the reference anyway but clear sha1.
|
|
|
|
|
*
|
|
|
|
|
* 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
|
2017-04-16 06:41:27 +00:00
|
|
|
* - Avoid calling refs_verify_refname_available() when it can be
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
* avoided, namely if we were successfully able to read the ref
|
|
|
|
|
* - Generate informative error messages in the case of failure
|
|
|
|
|
*/
|
2016-09-04 16:08:31 +00:00
|
|
|
static int lock_raw_ref(struct files_ref_store *refs,
|
|
|
|
|
const char *refname, int mustexist,
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
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);
|
2017-02-10 11:16:16 +00:00
|
|
|
files_assert_main_repository(refs, "lock_raw_ref");
|
2016-09-04 16:08:31 +00:00
|
|
|
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
*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);
|
2017-03-26 02:42:23 +00:00
|
|
|
files_ref_path(refs, &ref_file, refname);
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
|
|
|
|
|
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.
|
|
|
|
|
*/
|
2017-03-26 02:42:34 +00:00
|
|
|
if (refs_verify_refname_available(&refs->base, refname,
|
|
|
|
|
extras, skip, err)) {
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
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
|
2017-04-16 06:41:27 +00:00
|
|
|
* refs_verify_refname_available() is
|
|
|
|
|
* OK.
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
*/
|
|
|
|
|
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 (!lock->lk)
|
|
|
|
|
lock->lk = xcalloc(1, sizeof(struct lock_file));
|
|
|
|
|
|
|
|
|
|
if (hold_lock_file_for_update(lock->lk, ref_file.buf, LOCK_NO_DEREF) < 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.
|
|
|
|
|
*/
|
|
|
|
|
|
2016-09-04 16:08:31 +00:00
|
|
|
if (files_read_raw_ref(&refs->base, refname,
|
2016-09-04 16:08:25 +00:00
|
|
|
lock->old_oid.hash, referent, type)) {
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
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)) {
|
2017-04-16 06:41:26 +00:00
|
|
|
if (refs_verify_refname_available(
|
|
|
|
|
&refs->base, refname,
|
|
|
|
|
extras, skip, err)) {
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
/*
|
|
|
|
|
* 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,
|
2017-04-16 06:41:27 +00:00
|
|
|
* make sure there is no existing ref that conflicts
|
|
|
|
|
* with refname:
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
*/
|
2017-04-16 06:41:27 +00:00
|
|
|
if (refs_verify_refname_available(
|
|
|
|
|
&refs->base, refname,
|
|
|
|
|
extras, skip, err))
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
goto error_return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
error_return:
|
|
|
|
|
unlock_ref(lock);
|
|
|
|
|
*lock_p = NULL;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
strbuf_release(&ref_file);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-04 16:08:29 +00:00
|
|
|
static int files_peel_ref(struct ref_store *ref_store,
|
|
|
|
|
const char *refname, unsigned char *sha1)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-03-26 02:42:32 +00:00
|
|
|
struct files_ref_store *refs =
|
|
|
|
|
files_downcast(ref_store, REF_STORE_READ | REF_STORE_ODB,
|
|
|
|
|
"peel_ref");
|
2015-11-09 13:34:01 +00:00
|
|
|
int flag;
|
|
|
|
|
unsigned char base[20];
|
|
|
|
|
|
do_for_each_ref(): reimplement using reference iteration
Use the reference iterator interface to implement do_for_each_ref().
Delete a bunch of code supporting the old for_each_ref() implementation.
And now that do_for_each_ref() is generic code (it is no longer tied to
the files backend), move it to refs.c.
The implementation is via a new function, do_for_each_ref_iterator(),
which takes a reference iterator as argument and calls a callback
function for each of the references in the iterator.
This change requires the current_ref performance hack for peel_ref() to
be implemented via ref_iterator_peel() rather than peel_entry() because
we don't have a ref_entry handy (it is hidden under three layers:
file_ref_iterator, merge_ref_iterator, and cache_ref_iterator). So:
* do_for_each_ref_iterator() records the active iterator in
current_ref_iter while it is running.
* peel_ref() checks whether current_ref_iter is pointing at the
requested reference. If so, it asks the iterator to peel the
reference (which it can do efficiently via its "peel" virtual
function). For extra safety, we do the optimization only if the
refname *addresses* are the same, not only if the refname *strings*
are the same, to forestall possible mixups between refnames that come
from different ref_iterators.
Please note that this optimization of peel_ref() is only available when
iterating via do_for_each_ref_iterator() (including all of the
for_each_ref() functions, which call it indirectly). It would be
complicated to implement a similar optimization when iterating directly
using a reference iterator, because multiple reference iterators can be
in use at the same time, with interleaved calls to
ref_iterator_advance(). (In fact we do exactly that in
merge_ref_iterator.)
But that is not necessary. peel_ref() is only called while iterating
over references. Callers who iterate using the for_each_ref() functions
benefit from the optimization described above. Callers who iterate using
reference iterators directly have access to the ref_iterator, so they
can call ref_iterator_peel() themselves to get an analogous optimization
in a more straightforward manner.
If we rewrite all callers to use the reference iteration API, then we
can remove the current_ref_iter hack permanently.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:16 +00:00
|
|
|
if (current_ref_iter && current_ref_iter->refname == refname) {
|
|
|
|
|
struct object_id peeled;
|
|
|
|
|
|
|
|
|
|
if (ref_iterator_peel(current_ref_iter, &peeled))
|
2015-11-09 13:34:01 +00:00
|
|
|
return -1;
|
do_for_each_ref(): reimplement using reference iteration
Use the reference iterator interface to implement do_for_each_ref().
Delete a bunch of code supporting the old for_each_ref() implementation.
And now that do_for_each_ref() is generic code (it is no longer tied to
the files backend), move it to refs.c.
The implementation is via a new function, do_for_each_ref_iterator(),
which takes a reference iterator as argument and calls a callback
function for each of the references in the iterator.
This change requires the current_ref performance hack for peel_ref() to
be implemented via ref_iterator_peel() rather than peel_entry() because
we don't have a ref_entry handy (it is hidden under three layers:
file_ref_iterator, merge_ref_iterator, and cache_ref_iterator). So:
* do_for_each_ref_iterator() records the active iterator in
current_ref_iter while it is running.
* peel_ref() checks whether current_ref_iter is pointing at the
requested reference. If so, it asks the iterator to peel the
reference (which it can do efficiently via its "peel" virtual
function). For extra safety, we do the optimization only if the
refname *addresses* are the same, not only if the refname *strings*
are the same, to forestall possible mixups between refnames that come
from different ref_iterators.
Please note that this optimization of peel_ref() is only available when
iterating via do_for_each_ref_iterator() (including all of the
for_each_ref() functions, which call it indirectly). It would be
complicated to implement a similar optimization when iterating directly
using a reference iterator, because multiple reference iterators can be
in use at the same time, with interleaved calls to
ref_iterator_advance(). (In fact we do exactly that in
merge_ref_iterator.)
But that is not necessary. peel_ref() is only called while iterating
over references. Callers who iterate using the for_each_ref() functions
benefit from the optimization described above. Callers who iterate using
reference iterators directly have access to the ref_iterator, so they
can call ref_iterator_peel() themselves to get an analogous optimization
in a more straightforward manner.
If we rewrite all callers to use the reference iteration API, then we
can remove the current_ref_iter hack permanently.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:16 +00:00
|
|
|
hashcpy(sha1, peeled.hash);
|
2015-11-09 13:34:01 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-26 02:42:36 +00:00
|
|
|
if (refs_read_ref_full(ref_store, refname,
|
|
|
|
|
RESOLVE_REF_READING, base, &flag))
|
2015-11-09 13:34:01 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If the reference is packed, read its ref_entry from the
|
|
|
|
|
* cache in the hope that we already know its peeled value.
|
|
|
|
|
* We only try this optimization on packed references because
|
|
|
|
|
* (a) forcing the filling of the loose reference cache could
|
|
|
|
|
* be expensive and (b) loose references anyway usually do not
|
|
|
|
|
* have REF_KNOWS_PEELED.
|
|
|
|
|
*/
|
|
|
|
|
if (flag & REF_ISPACKED) {
|
2016-09-04 16:08:13 +00:00
|
|
|
struct ref_entry *r = get_packed_ref(refs, refname);
|
2015-11-09 13:34:01 +00:00
|
|
|
if (r) {
|
|
|
|
|
if (peel_entry(r, 0))
|
|
|
|
|
return -1;
|
|
|
|
|
hashcpy(sha1, r->u.value.peeled.hash);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return peel_object(base, sha1);
|
|
|
|
|
}
|
|
|
|
|
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
struct files_ref_iterator {
|
|
|
|
|
struct ref_iterator base;
|
|
|
|
|
|
2015-11-09 13:34:01 +00:00
|
|
|
struct packed_ref_cache *packed_ref_cache;
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
struct ref_iterator *iter0;
|
|
|
|
|
unsigned int flags;
|
|
|
|
|
};
|
2015-11-09 13:34:01 +00:00
|
|
|
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
static int files_ref_iterator_advance(struct ref_iterator *ref_iterator)
|
|
|
|
|
{
|
|
|
|
|
struct files_ref_iterator *iter =
|
|
|
|
|
(struct files_ref_iterator *)ref_iterator;
|
|
|
|
|
int ok;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
while ((ok = ref_iterator_advance(iter->iter0)) == ITER_OK) {
|
2016-09-04 16:08:44 +00:00
|
|
|
if (iter->flags & DO_FOR_EACH_PER_WORKTREE_ONLY &&
|
|
|
|
|
ref_type(iter->iter0->refname) != REF_TYPE_PER_WORKTREE)
|
|
|
|
|
continue;
|
|
|
|
|
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
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;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
iter->iter0 = NULL;
|
|
|
|
|
if (ref_iterator_abort(ref_iterator) != ITER_DONE)
|
|
|
|
|
ok = ITER_ERROR;
|
|
|
|
|
|
|
|
|
|
return ok;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
static int files_ref_iterator_peel(struct ref_iterator *ref_iterator,
|
|
|
|
|
struct object_id *peeled)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
struct files_ref_iterator *iter =
|
|
|
|
|
(struct files_ref_iterator *)ref_iterator;
|
2016-04-07 19:02:49 +00:00
|
|
|
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
release_packed_ref_cache(iter->packed_ref_cache);
|
|
|
|
|
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
|
|
|
|
|
};
|
|
|
|
|
|
2016-09-04 16:08:37 +00:00
|
|
|
static struct ref_iterator *files_ref_iterator_begin(
|
2016-09-04 16:08:36 +00:00
|
|
|
struct ref_store *ref_store,
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
const char *prefix, unsigned int flags)
|
|
|
|
|
{
|
2017-03-26 02:42:32 +00:00
|
|
|
struct files_ref_store *refs;
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
struct ref_iterator *loose_iter, *packed_iter;
|
|
|
|
|
struct files_ref_iterator *iter;
|
|
|
|
|
struct ref_iterator *ref_iterator;
|
2017-05-22 14:17:52 +00:00
|
|
|
unsigned int required_flags = REF_STORE_READ;
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
|
2017-05-22 14:17:52 +00:00
|
|
|
if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN))
|
|
|
|
|
required_flags |= REF_STORE_ODB;
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
|
2017-05-22 14:17:52 +00:00
|
|
|
refs = files_downcast(ref_store, required_flags, "ref_iterator_begin");
|
2017-03-26 02:42:32 +00:00
|
|
|
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
iter = xcalloc(1, sizeof(*iter));
|
|
|
|
|
ref_iterator = &iter->base;
|
|
|
|
|
base_ref_iterator_init(ref_iterator, &files_ref_iterator_vtable);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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:
|
2017-04-16 06:41:39 +00:00
|
|
|
* 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
|
|
|
|
|
* get_packed_ref_cache(), which internally checks whether the
|
|
|
|
|
* packed-ref cache is up to date with what is on disk, and
|
|
|
|
|
* re-reads it if not.
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
*/
|
|
|
|
|
|
2017-04-16 06:41:39 +00:00
|
|
|
loose_iter = cache_ref_iterator_begin(get_loose_ref_cache(refs),
|
|
|
|
|
prefix, 1);
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
|
2017-06-23 07:01:26 +00:00
|
|
|
iter->packed_ref_cache = get_packed_ref_cache(refs->packed_ref_store);
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
acquire_packed_ref_cache(iter->packed_ref_cache);
|
2017-04-16 06:41:39 +00:00
|
|
|
packed_iter = cache_ref_iterator_begin(iter->packed_ref_cache->cache,
|
|
|
|
|
prefix, 0);
|
refs: introduce an iterator interface
Currently, the API for iterating over references is via a family of
for_each_ref()-type functions that invoke a callback function for each
selected reference. All of these eventually call do_for_each_ref(),
which knows how to do one thing: iterate in parallel through two
ref_caches, one for loose and one for packed refs, giving loose
references precedence over packed refs. This is rather complicated code,
and is quite specialized to the files backend. It also requires callers
to encapsulate their work into a callback function, which often means
that they have to define and use a "cb_data" struct to manage their
context.
The current design is already bursting at the seams, and will become
even more awkward in the upcoming world of multiple reference storage
backends:
* Per-worktree vs. shared references are currently handled via a kludge
in git_path() rather than iterating over each part of the reference
namespace separately and merging the results. This kludge will cease
to work when we have multiple reference storage backends.
* The current scheme is inflexible. What if we sometimes want to bypass
the ref_cache, or use it only for packed or only for loose refs? What
if we want to store symbolic refs in one type of storage backend and
non-symbolic ones in another?
In the future, each reference backend will need to define its own way of
iterating over references. The crux of the problem with the current
design is that it is impossible to compose for_each_ref()-style
iterations, because the flow of control is owned by the for_each_ref()
function. There is nothing that a caller can do but iterate through all
references in a single burst, so there is no way for it to interleave
references from multiple backends and present the result to the rest of
the world as a single compound backend.
This commit introduces a new iteration primitive for references: a
ref_iterator. A ref_iterator is a polymorphic object that a reference
storage backend can be asked to instantiate. There are three functions
that can be applied to a ref_iterator:
* ref_iterator_advance(): move to the next reference in the iteration
* ref_iterator_abort(): end the iteration before it is exhausted
* ref_iterator_peel(): peel the reference currently being looked at
Iterating using a ref_iterator leaves the flow of control in the hands
of the caller, which means that ref_iterators from multiple
sources (e.g., loose and packed refs) can be composed and presented to
the world as a single compound ref_iterator.
It also means that the backend code for implementing reference iteration
will sometimes be more complicated. For example, the
cache_ref_iterator (which iterates over a ref_cache) can't use the C
stack to recurse; instead, it must manage its own stack internally as
explicit data structures. There is also a lot of boilerplate connected
with object-oriented programming in C.
Eventually, end-user callers will be able to be written in a more
natural way—managing their own flow of control rather than having to
work via callbacks. Since there will only be a few reference backends
but there are many consumers of this API, this is a good tradeoff.
More importantly, we gain composability, and especially the possibility
of writing interchangeable parts that can work with any ref_iterator.
For example, merge_ref_iterator implements a generic way of merging the
contents of any two ref_iterators. It is used to merge loose + packed
refs as part of the implementation of the files_ref_iterator. But it
will also be possible to use it to merge other pairs of reference
sources (e.g., per-worktree vs. shared refs).
Another example is prefix_ref_iterator, which can be used to trim a
prefix off the front of reference names before presenting them to the
caller (e.g., "refs/heads/master" -> "master").
In this patch, we introduce the iterator abstraction and many utilities,
and implement a reference iterator for the files ref storage backend.
(I've written several other obvious utilities, for example a generic way
to filter references being iterated over. These will probably be useful
in the future. But they are not needed for this patch series, so I am
not including them at this time.)
In a moment we will rewrite do_for_each_ref() to work via reference
iterators (allowing some special-purpose code to be discarded), and do
something similar for reflogs. In future patch series, we will expose
the ref_iterator abstraction in the public refs API so that callers can
use it directly.
Implementation note: I tried abstracting this a layer further to allow
generic iterators (over arbitrary types of objects) and generic
utilities like a generic merge_iterator. But the implementation in C was
very cumbersome, involving (in my opinion) too much boilerplate and too
much unsafe casting, some of which would have had to be done on the
caller side. However, I did put a few iterator-related constants in a
top-level header file, iterator.h, as they will be useful in a moment to
implement iteration over directory trees and possibly other types of
iterators in the future.
Signed-off-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-18 04:15:15 +00:00
|
|
|
|
|
|
|
|
iter->iter0 = overlay_ref_iterator_begin(loose_iter, packed_iter);
|
|
|
|
|
iter->flags = flags;
|
|
|
|
|
|
|
|
|
|
return ref_iterator;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Verify that the reference locked by lock has the value old_sha1.
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
2017-03-26 02:42:36 +00:00
|
|
|
static int verify_lock(struct ref_store *ref_store, struct ref_lock *lock,
|
2015-11-09 13:34:01 +00:00
|
|
|
const unsigned char *old_sha1, int mustexist,
|
|
|
|
|
struct strbuf *err)
|
|
|
|
|
{
|
|
|
|
|
assert(err);
|
|
|
|
|
|
2017-03-26 02:42:36 +00:00
|
|
|
if (refs_read_ref_full(ref_store, lock->ref_name,
|
|
|
|
|
mustexist ? RESOLVE_REF_READING : 0,
|
|
|
|
|
lock->old_oid.hash, NULL)) {
|
lock_ref_sha1_basic: always fill old_oid while holding lock
Our basic strategy for taking a ref lock is:
1. Create $ref.lock to take the lock
2. Read the ref again while holding the lock (during which
time we know that nobody else can be updating it).
3. Compare the value we read to the expected "old_sha1"
The value we read in step (2) is returned to the caller via
the lock->old_oid field, who may use it for other purposes
(such as writing a reflog).
If we have no "old_sha1" (i.e., we are unconditionally
taking the lock), then we obviously must omit step 3. But we
_also_ omit step 2. This seems like a nice optimization, but
it means that the caller sees only whatever was left in
lock->old_oid from previous calls to resolve_ref_unsafe(),
which happened outside of the lock.
We can demonstrate this race pretty easily. Imagine you have
three commits, $one, $two, and $three. One script just flips
between $one and $two, without providing an old-sha1:
while true; do
git update-ref -m one refs/heads/foo $one
git update-ref -m two refs/heads/foo $two
done
Meanwhile, another script tries to set the value to $three,
also not using an old-sha1:
while true; do
git update-ref -m three refs/heads/foo $three
done
If these run simultaneously, we'll see a lot of lock
contention, but each of the writes will succeed some of the
time. The reflog may record movements between any of the
three refs, but we would expect it to provide a consistent
log: the "from" field of each log entry should be the same
as the "to" field of the previous one.
But if we check this:
perl -alne '
print "mismatch on line $."
if defined $last && $F[0] ne $last;
$last = $F[1];
' .git/logs/refs/heads/foo
we'll see many mismatches. Why?
Because sometimes, in the time between lock_ref_sha1_basic
filling lock->old_oid via resolve_ref_unsafe() and it taking
the lock, there may be a complete write by another process.
And the "from" field in our reflog entry will be wrong, and
will refer to an older value.
This is probably quite rare in practice. It requires writers
which do not provide an old-sha1 value, and it is a very
quick race. However, it is easy to fix: we simply perform
step (2), the read-under-lock, whether we have an old-sha1
or not. Then the value we hand back to the caller is always
atomic.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-12 21:44:39 +00:00
|
|
|
if (old_sha1) {
|
|
|
|
|
int save_errno = errno;
|
2016-04-27 13:21:36 +00:00
|
|
|
strbuf_addf(err, "can't verify ref '%s'", lock->ref_name);
|
lock_ref_sha1_basic: always fill old_oid while holding lock
Our basic strategy for taking a ref lock is:
1. Create $ref.lock to take the lock
2. Read the ref again while holding the lock (during which
time we know that nobody else can be updating it).
3. Compare the value we read to the expected "old_sha1"
The value we read in step (2) is returned to the caller via
the lock->old_oid field, who may use it for other purposes
(such as writing a reflog).
If we have no "old_sha1" (i.e., we are unconditionally
taking the lock), then we obviously must omit step 3. But we
_also_ omit step 2. This seems like a nice optimization, but
it means that the caller sees only whatever was left in
lock->old_oid from previous calls to resolve_ref_unsafe(),
which happened outside of the lock.
We can demonstrate this race pretty easily. Imagine you have
three commits, $one, $two, and $three. One script just flips
between $one and $two, without providing an old-sha1:
while true; do
git update-ref -m one refs/heads/foo $one
git update-ref -m two refs/heads/foo $two
done
Meanwhile, another script tries to set the value to $three,
also not using an old-sha1:
while true; do
git update-ref -m three refs/heads/foo $three
done
If these run simultaneously, we'll see a lot of lock
contention, but each of the writes will succeed some of the
time. The reflog may record movements between any of the
three refs, but we would expect it to provide a consistent
log: the "from" field of each log entry should be the same
as the "to" field of the previous one.
But if we check this:
perl -alne '
print "mismatch on line $."
if defined $last && $F[0] ne $last;
$last = $F[1];
' .git/logs/refs/heads/foo
we'll see many mismatches. Why?
Because sometimes, in the time between lock_ref_sha1_basic
filling lock->old_oid via resolve_ref_unsafe() and it taking
the lock, there may be a complete write by another process.
And the "from" field in our reflog entry will be wrong, and
will refer to an older value.
This is probably quite rare in practice. It requires writers
which do not provide an old-sha1 value, and it is a very
quick race. However, it is easy to fix: we simply perform
step (2), the read-under-lock, whether we have an old-sha1
or not. Then the value we hand back to the caller is always
atomic.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-12 21:44:39 +00:00
|
|
|
errno = save_errno;
|
|
|
|
|
return -1;
|
|
|
|
|
} else {
|
2016-06-24 23:09:22 +00:00
|
|
|
oidclr(&lock->old_oid);
|
lock_ref_sha1_basic: always fill old_oid while holding lock
Our basic strategy for taking a ref lock is:
1. Create $ref.lock to take the lock
2. Read the ref again while holding the lock (during which
time we know that nobody else can be updating it).
3. Compare the value we read to the expected "old_sha1"
The value we read in step (2) is returned to the caller via
the lock->old_oid field, who may use it for other purposes
(such as writing a reflog).
If we have no "old_sha1" (i.e., we are unconditionally
taking the lock), then we obviously must omit step 3. But we
_also_ omit step 2. This seems like a nice optimization, but
it means that the caller sees only whatever was left in
lock->old_oid from previous calls to resolve_ref_unsafe(),
which happened outside of the lock.
We can demonstrate this race pretty easily. Imagine you have
three commits, $one, $two, and $three. One script just flips
between $one and $two, without providing an old-sha1:
while true; do
git update-ref -m one refs/heads/foo $one
git update-ref -m two refs/heads/foo $two
done
Meanwhile, another script tries to set the value to $three,
also not using an old-sha1:
while true; do
git update-ref -m three refs/heads/foo $three
done
If these run simultaneously, we'll see a lot of lock
contention, but each of the writes will succeed some of the
time. The reflog may record movements between any of the
three refs, but we would expect it to provide a consistent
log: the "from" field of each log entry should be the same
as the "to" field of the previous one.
But if we check this:
perl -alne '
print "mismatch on line $."
if defined $last && $F[0] ne $last;
$last = $F[1];
' .git/logs/refs/heads/foo
we'll see many mismatches. Why?
Because sometimes, in the time between lock_ref_sha1_basic
filling lock->old_oid via resolve_ref_unsafe() and it taking
the lock, there may be a complete write by another process.
And the "from" field in our reflog entry will be wrong, and
will refer to an older value.
This is probably quite rare in practice. It requires writers
which do not provide an old-sha1 value, and it is a very
quick race. However, it is easy to fix: we simply perform
step (2), the read-under-lock, whether we have an old-sha1
or not. Then the value we hand back to the caller is always
atomic.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-12 21:44:39 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
lock_ref_sha1_basic: always fill old_oid while holding lock
Our basic strategy for taking a ref lock is:
1. Create $ref.lock to take the lock
2. Read the ref again while holding the lock (during which
time we know that nobody else can be updating it).
3. Compare the value we read to the expected "old_sha1"
The value we read in step (2) is returned to the caller via
the lock->old_oid field, who may use it for other purposes
(such as writing a reflog).
If we have no "old_sha1" (i.e., we are unconditionally
taking the lock), then we obviously must omit step 3. But we
_also_ omit step 2. This seems like a nice optimization, but
it means that the caller sees only whatever was left in
lock->old_oid from previous calls to resolve_ref_unsafe(),
which happened outside of the lock.
We can demonstrate this race pretty easily. Imagine you have
three commits, $one, $two, and $three. One script just flips
between $one and $two, without providing an old-sha1:
while true; do
git update-ref -m one refs/heads/foo $one
git update-ref -m two refs/heads/foo $two
done
Meanwhile, another script tries to set the value to $three,
also not using an old-sha1:
while true; do
git update-ref -m three refs/heads/foo $three
done
If these run simultaneously, we'll see a lot of lock
contention, but each of the writes will succeed some of the
time. The reflog may record movements between any of the
three refs, but we would expect it to provide a consistent
log: the "from" field of each log entry should be the same
as the "to" field of the previous one.
But if we check this:
perl -alne '
print "mismatch on line $."
if defined $last && $F[0] ne $last;
$last = $F[1];
' .git/logs/refs/heads/foo
we'll see many mismatches. Why?
Because sometimes, in the time between lock_ref_sha1_basic
filling lock->old_oid via resolve_ref_unsafe() and it taking
the lock, there may be a complete write by another process.
And the "from" field in our reflog entry will be wrong, and
will refer to an older value.
This is probably quite rare in practice. It requires writers
which do not provide an old-sha1 value, and it is a very
quick race. However, it is easy to fix: we simply perform
step (2), the read-under-lock, whether we have an old-sha1
or not. Then the value we hand back to the caller is always
atomic.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-12 21:44:39 +00:00
|
|
|
if (old_sha1 && hashcmp(lock->old_oid.hash, old_sha1)) {
|
2016-04-27 13:21:36 +00:00
|
|
|
strbuf_addf(err, "ref '%s' is at %s but expected %s",
|
2015-11-09 13:34:01 +00:00
|
|
|
lock->ref_name,
|
2016-06-24 23:09:22 +00:00
|
|
|
oid_to_hex(&lock->old_oid),
|
2015-11-09 13:34:01 +00:00
|
|
|
sha1_to_hex(old_sha1));
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-06 16:22:28 +00:00
|
|
|
static int create_reflock(const char *path, void *cb)
|
|
|
|
|
{
|
|
|
|
|
struct lock_file *lk = cb;
|
|
|
|
|
|
|
|
|
|
return hold_lock_file_for_update(lk, path, LOCK_NO_DEREF) < 0 ? -1 : 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-09 13:34:01 +00:00
|
|
|
/*
|
|
|
|
|
* Locks a ref returning the lock on success and NULL on failure.
|
|
|
|
|
* On failure errno is set to something meaningful.
|
|
|
|
|
*/
|
2016-09-04 16:08:34 +00:00
|
|
|
static struct ref_lock *lock_ref_sha1_basic(struct files_ref_store *refs,
|
|
|
|
|
const char *refname,
|
2015-11-09 13:34:01 +00:00
|
|
|
const unsigned char *old_sha1,
|
|
|
|
|
const struct string_list *extras,
|
|
|
|
|
const struct string_list *skip,
|
2016-04-22 07:13:00 +00:00
|
|
|
unsigned int flags, int *type,
|
2015-11-09 13:34:01 +00:00
|
|
|
struct strbuf *err)
|
|
|
|
|
{
|
|
|
|
|
struct strbuf ref_file = STRBUF_INIT;
|
|
|
|
|
struct ref_lock *lock;
|
|
|
|
|
int last_errno = 0;
|
|
|
|
|
int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
|
2016-04-22 13:25:25 +00:00
|
|
|
int resolve_flags = RESOLVE_REF_NO_RECURSE;
|
|
|
|
|
int resolved;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-02-10 11:16:16 +00:00
|
|
|
files_assert_main_repository(refs, "lock_ref_sha1_basic");
|
2015-11-09 13:34:01 +00:00
|
|
|
assert(err);
|
|
|
|
|
|
|
|
|
|
lock = xcalloc(1, sizeof(struct ref_lock));
|
|
|
|
|
|
|
|
|
|
if (mustexist)
|
|
|
|
|
resolve_flags |= RESOLVE_REF_READING;
|
lock_ref_sha1_basic: handle REF_NODEREF with invalid refs
We sometimes call lock_ref_sha1_basic with REF_NODEREF
to operate directly on a symbolic ref. This is used, for
example, to move to a detached HEAD, or when updating
the contents of HEAD via checkout or symbolic-ref.
However, the first step of the function is to resolve the
refname to get the "old" sha1, and we do so without telling
resolve_ref_unsafe() that we are only interested in the
symref. As a result, we may detect a problem there not with
the symref itself, but with something it points to.
The real-world example I found (and what is used in the test
suite) is a HEAD pointing to a ref that cannot exist,
because it would cause a directory/file conflict with other
existing refs. This situation is somewhat broken, of
course, as trying to _commit_ on that HEAD would fail. But
it's not explicitly forbidden, and we should be able to move
away from it. However, neither "git checkout" nor "git
symbolic-ref" can do so. We try to take the lock on HEAD,
which is pointing to a non-existent ref. We bail from
resolve_ref_unsafe() with errno set to EISDIR, and the lock
code thinks we are attempting to create a d/f conflict.
Of course we're not. The problem is that the lock code has
no idea what level we were at when we got EISDIR, so trying
to diagnose or remove empty directories for HEAD is not
useful.
To make things even more complicated, we only get EISDIR in
the loose-ref case. If the refs are packed, the resolution
may "succeed", giving us the pointed-to ref in "refname",
but a null oid. Later, we say "ah, the null oid means we are
creating; let's make sure there is room for it", but
mistakenly check against the _resolved_ refname, not the
original.
We can fix this by making two tweaks:
1. Call resolve_ref_unsafe() with RESOLVE_REF_NO_RECURSE
when REF_NODEREF is set. This means any errors
we get will be from the orig_refname, and we can act
accordingly.
We already do this in the REF_DELETING case, but we
should do it for update, too.
2. If we do get a "refname" return from
resolve_ref_unsafe(), even with RESOLVE_REF_NO_RECURSE
it may be the name of the ref pointed-to by a symref.
We already normalize this back to orig_refname before
taking the lockfile, but we need to do so before the
null_oid check.
While we're rearranging the REF_NODEREF handling, we can
also bump the initialization of lflags to the top of the
function, where we are setting up other flags. This saves us
from having yet another conditional block on REF_NODEREF
just to set it later.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-12 21:45:09 +00:00
|
|
|
if (flags & REF_DELETING)
|
2015-11-09 13:34:01 +00:00
|
|
|
resolve_flags |= RESOLVE_REF_ALLOW_BAD_NAME;
|
|
|
|
|
|
2017-03-26 02:42:23 +00:00
|
|
|
files_ref_path(refs, &ref_file, refname);
|
2017-03-26 02:42:36 +00:00
|
|
|
resolved = !!refs_resolve_ref_unsafe(&refs->base,
|
|
|
|
|
refname, resolve_flags,
|
|
|
|
|
lock->old_oid.hash, type);
|
2016-04-22 13:25:25 +00:00
|
|
|
if (!resolved && errno == EISDIR) {
|
2015-11-09 13:34:01 +00:00
|
|
|
/*
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
2016-04-22 13:25:25 +00:00
|
|
|
if (remove_empty_directories(&ref_file)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
last_errno = errno;
|
2017-04-16 06:41:26 +00:00
|
|
|
if (!refs_verify_refname_available(
|
|
|
|
|
&refs->base,
|
|
|
|
|
refname, extras, skip, err))
|
2015-11-09 13:34:01 +00:00
|
|
|
strbuf_addf(err, "there are still refs under '%s'",
|
2016-04-22 13:25:25 +00:00
|
|
|
refname);
|
2015-11-09 13:34:01 +00:00
|
|
|
goto error_return;
|
|
|
|
|
}
|
2017-03-26 02:42:36 +00:00
|
|
|
resolved = !!refs_resolve_ref_unsafe(&refs->base,
|
|
|
|
|
refname, resolve_flags,
|
|
|
|
|
lock->old_oid.hash, type);
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
2016-04-22 13:25:25 +00:00
|
|
|
if (!resolved) {
|
2015-11-09 13:34:01 +00:00
|
|
|
last_errno = errno;
|
|
|
|
|
if (last_errno != ENOTDIR ||
|
2017-04-16 06:41:26 +00:00
|
|
|
!refs_verify_refname_available(&refs->base, refname,
|
|
|
|
|
extras, skip, err))
|
2016-04-27 13:21:36 +00:00
|
|
|
strbuf_addf(err, "unable to resolve reference '%s': %s",
|
2016-04-22 13:25:25 +00:00
|
|
|
refname, strerror(last_errno));
|
2015-11-09 13:34:01 +00:00
|
|
|
|
|
|
|
|
goto error_return;
|
|
|
|
|
}
|
lock_ref_sha1_basic: handle REF_NODEREF with invalid refs
We sometimes call lock_ref_sha1_basic with REF_NODEREF
to operate directly on a symbolic ref. This is used, for
example, to move to a detached HEAD, or when updating
the contents of HEAD via checkout or symbolic-ref.
However, the first step of the function is to resolve the
refname to get the "old" sha1, and we do so without telling
resolve_ref_unsafe() that we are only interested in the
symref. As a result, we may detect a problem there not with
the symref itself, but with something it points to.
The real-world example I found (and what is used in the test
suite) is a HEAD pointing to a ref that cannot exist,
because it would cause a directory/file conflict with other
existing refs. This situation is somewhat broken, of
course, as trying to _commit_ on that HEAD would fail. But
it's not explicitly forbidden, and we should be able to move
away from it. However, neither "git checkout" nor "git
symbolic-ref" can do so. We try to take the lock on HEAD,
which is pointing to a non-existent ref. We bail from
resolve_ref_unsafe() with errno set to EISDIR, and the lock
code thinks we are attempting to create a d/f conflict.
Of course we're not. The problem is that the lock code has
no idea what level we were at when we got EISDIR, so trying
to diagnose or remove empty directories for HEAD is not
useful.
To make things even more complicated, we only get EISDIR in
the loose-ref case. If the refs are packed, the resolution
may "succeed", giving us the pointed-to ref in "refname",
but a null oid. Later, we say "ah, the null oid means we are
creating; let's make sure there is room for it", but
mistakenly check against the _resolved_ refname, not the
original.
We can fix this by making two tweaks:
1. Call resolve_ref_unsafe() with RESOLVE_REF_NO_RECURSE
when REF_NODEREF is set. This means any errors
we get will be from the orig_refname, and we can act
accordingly.
We already do this in the REF_DELETING case, but we
should do it for update, too.
2. If we do get a "refname" return from
resolve_ref_unsafe(), even with RESOLVE_REF_NO_RECURSE
it may be the name of the ref pointed-to by a symref.
We already normalize this back to orig_refname before
taking the lockfile, but we need to do so before the
null_oid check.
While we're rearranging the REF_NODEREF handling, we can
also bump the initialization of lflags to the top of the
function, where we are setting up other flags. This saves us
from having yet another conditional block on REF_NODEREF
just to set it later.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-12 21:45:09 +00:00
|
|
|
|
2015-11-09 13:34:01 +00:00
|
|
|
/*
|
|
|
|
|
* 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) &&
|
2017-04-16 06:41:27 +00:00
|
|
|
refs_verify_refname_available(&refs->base, refname,
|
|
|
|
|
extras, skip, err)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
last_errno = ENOTDIR;
|
|
|
|
|
goto error_return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
lock->lk = xcalloc(1, sizeof(struct lock_file));
|
|
|
|
|
|
|
|
|
|
lock->ref_name = xstrdup(refname);
|
|
|
|
|
|
2017-01-06 16:22:28 +00:00
|
|
|
if (raceproof_create_file(ref_file.buf, create_reflock, lock->lk)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
last_errno = errno;
|
2017-01-06 16:22:28 +00:00
|
|
|
unable_to_lock_message(ref_file.buf, errno, err);
|
2015-11-09 13:34:01 +00:00
|
|
|
goto error_return;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-26 02:42:36 +00:00
|
|
|
if (verify_lock(&refs->base, lock, old_sha1, mustexist, err)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
2017-04-16 06:41:40 +00:00
|
|
|
static void write_packed_entry(FILE *fh, const char *refname,
|
|
|
|
|
const unsigned char *sha1,
|
|
|
|
|
const unsigned char *peeled)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
|
|
|
|
fprintf_or_die(fh, "%s %s\n", sha1_to_hex(sha1), refname);
|
|
|
|
|
if (peeled)
|
|
|
|
|
fprintf_or_die(fh, "^%s\n", sha1_to_hex(peeled));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Lock the packed-refs file for writing. Flags is passed to
|
|
|
|
|
* hold_lock_file_for_update(). Return 0 on success. On errors, set
|
|
|
|
|
* errno appropriately and return a nonzero value.
|
|
|
|
|
*/
|
2017-06-23 07:01:29 +00:00
|
|
|
static int lock_packed_refs(struct packed_ref_store *refs, int flags)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
|
|
|
|
static int timeout_configured = 0;
|
|
|
|
|
static int timeout_value = 1000;
|
|
|
|
|
struct packed_ref_cache *packed_ref_cache;
|
|
|
|
|
|
2017-06-23 07:01:29 +00:00
|
|
|
packed_assert_main_repository(refs, "lock_packed_refs");
|
2016-09-04 16:08:15 +00:00
|
|
|
|
2015-11-09 13:34:01 +00:00
|
|
|
if (!timeout_configured) {
|
|
|
|
|
git_config_get_int("core.packedrefstimeout", &timeout_value);
|
|
|
|
|
timeout_configured = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (hold_lock_file_for_update_timeout(
|
2017-06-23 07:01:29 +00:00
|
|
|
&refs->lock,
|
|
|
|
|
refs->path,
|
2015-11-09 13:34:01 +00:00
|
|
|
flags, timeout_value) < 0)
|
|
|
|
|
return -1;
|
2017-06-12 08:06:13 +00:00
|
|
|
|
2015-11-09 13:34:01 +00:00
|
|
|
/*
|
2017-06-12 08:06:13 +00:00
|
|
|
* Now that we hold the `packed-refs` lock, make sure that our
|
|
|
|
|
* cache matches the current version of the file. Normally
|
|
|
|
|
* `get_packed_ref_cache()` does that for us, but that
|
|
|
|
|
* function assumes that when the file is locked, any existing
|
|
|
|
|
* cache is still valid. We've just locked the file, but it
|
|
|
|
|
* might have changed the moment *before* we locked it.
|
2015-11-09 13:34:01 +00:00
|
|
|
*/
|
2017-06-23 07:01:29 +00:00
|
|
|
validate_packed_ref_cache(refs);
|
2017-06-12 08:06:13 +00:00
|
|
|
|
2017-06-23 07:01:29 +00:00
|
|
|
packed_ref_cache = get_packed_ref_cache(refs);
|
2015-11-09 13:34:01 +00:00
|
|
|
/* Increment the reference count to prevent it from being freed: */
|
|
|
|
|
acquire_packed_ref_cache(packed_ref_cache);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Write the current version of the packed refs cache from memory to
|
|
|
|
|
* disk. The packed-refs file must already be locked for writing (see
|
|
|
|
|
* lock_packed_refs()). Return zero on success. On errors, set errno
|
|
|
|
|
* and return a nonzero value
|
|
|
|
|
*/
|
2017-06-23 07:01:30 +00:00
|
|
|
static int commit_packed_refs(struct packed_ref_store *refs)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
|
|
|
|
struct packed_ref_cache *packed_ref_cache =
|
2017-06-23 07:01:30 +00:00
|
|
|
get_packed_ref_cache(refs);
|
2017-04-16 06:41:40 +00:00
|
|
|
int ok, error = 0;
|
2015-11-09 13:34:01 +00:00
|
|
|
int save_errno = 0;
|
|
|
|
|
FILE *out;
|
2017-04-16 06:41:40 +00:00
|
|
|
struct ref_iterator *iter;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-06-23 07:01:30 +00:00
|
|
|
packed_assert_main_repository(refs, "commit_packed_refs");
|
2016-09-04 16:08:15 +00:00
|
|
|
|
2017-06-23 07:01:30 +00:00
|
|
|
if (!is_lock_file_locked(&refs->lock))
|
2017-05-22 14:17:34 +00:00
|
|
|
die("BUG: packed-refs not locked");
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-06-23 07:01:30 +00:00
|
|
|
out = fdopen_lock_file(&refs->lock, "w");
|
2015-11-09 13:34:01 +00:00
|
|
|
if (!out)
|
|
|
|
|
die_errno("unable to fdopen packed-refs descriptor");
|
|
|
|
|
|
|
|
|
|
fprintf_or_die(out, "%s", PACKED_REFS_HEADER);
|
2017-04-16 06:41:40 +00:00
|
|
|
|
|
|
|
|
iter = cache_ref_iterator_begin(packed_ref_cache->cache, NULL, 0);
|
|
|
|
|
while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
|
|
|
|
|
struct object_id peeled;
|
|
|
|
|
int peel_error = ref_iterator_peel(iter, &peeled);
|
|
|
|
|
|
|
|
|
|
write_packed_entry(out, iter->refname, iter->oid->hash,
|
|
|
|
|
peel_error ? NULL : peeled.hash);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ok != ITER_DONE)
|
|
|
|
|
die("error while iterating over references");
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-06-23 07:01:30 +00:00
|
|
|
if (commit_lock_file(&refs->lock)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
save_errno = errno;
|
|
|
|
|
error = -1;
|
|
|
|
|
}
|
|
|
|
|
release_packed_ref_cache(packed_ref_cache);
|
|
|
|
|
errno = save_errno;
|
|
|
|
|
return error;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Rollback the lockfile for the packed-refs file, and discard the
|
|
|
|
|
* in-memory packed reference cache. (The packed-refs file will be
|
|
|
|
|
* read anew if it is needed again after this function is called.)
|
|
|
|
|
*/
|
2016-09-04 16:08:15 +00:00
|
|
|
static void rollback_packed_refs(struct files_ref_store *refs)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
|
|
|
|
struct packed_ref_cache *packed_ref_cache =
|
2017-06-23 07:01:26 +00:00
|
|
|
get_packed_ref_cache(refs->packed_ref_store);
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-02-10 11:16:16 +00:00
|
|
|
files_assert_main_repository(refs, "rollback_packed_refs");
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-06-23 07:01:23 +00:00
|
|
|
if (!is_lock_file_locked(&refs->packed_ref_store->lock))
|
2017-05-22 14:17:34 +00:00
|
|
|
die("BUG: packed-refs not locked");
|
2017-06-23 07:01:23 +00:00
|
|
|
rollback_lock_file(&refs->packed_ref_store->lock);
|
2015-11-09 13:34:01 +00:00
|
|
|
release_packed_ref_cache(packed_ref_cache);
|
2017-06-23 07:01:24 +00:00
|
|
|
clear_packed_ref_cache(refs->packed_ref_store);
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct ref_to_prune {
|
|
|
|
|
struct ref_to_prune *next;
|
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
char name[FLEX_ARRAY];
|
|
|
|
|
};
|
|
|
|
|
|
2017-01-06 16:22:42 +00:00
|
|
|
enum {
|
|
|
|
|
REMOVE_EMPTY_PARENTS_REF = 0x01,
|
|
|
|
|
REMOVE_EMPTY_PARENTS_REFLOG = 0x02
|
|
|
|
|
};
|
|
|
|
|
|
2015-11-09 13:34:01 +00:00
|
|
|
/*
|
2017-01-06 16:22:42 +00:00
|
|
|
* 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.
|
2015-11-09 13:34:01 +00:00
|
|
|
*/
|
2017-03-26 02:42:22 +00:00
|
|
|
static void try_remove_empty_parents(struct files_ref_store *refs,
|
|
|
|
|
const char *refname,
|
|
|
|
|
unsigned int flags)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-01-06 16:22:41 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2017-03-26 02:42:20 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2015-11-09 13:34:01 +00:00
|
|
|
char *p, *q;
|
|
|
|
|
int i;
|
2017-01-06 16:22:41 +00:00
|
|
|
|
|
|
|
|
strbuf_addstr(&buf, refname);
|
|
|
|
|
p = buf.buf;
|
2015-11-09 13:34:01 +00:00
|
|
|
for (i = 0; i < 2; i++) { /* refs/{heads,tags,...}/ */
|
|
|
|
|
while (*p && *p != '/')
|
|
|
|
|
p++;
|
|
|
|
|
/* tolerate duplicate slashes; see check_refname_format() */
|
|
|
|
|
while (*p == '/')
|
|
|
|
|
p++;
|
|
|
|
|
}
|
2017-01-06 16:22:41 +00:00
|
|
|
q = buf.buf + buf.len;
|
2017-01-06 16:22:42 +00:00
|
|
|
while (flags & (REMOVE_EMPTY_PARENTS_REF | REMOVE_EMPTY_PARENTS_REFLOG)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
while (q > p && *q != '/')
|
|
|
|
|
q--;
|
|
|
|
|
while (q > p && *(q-1) == '/')
|
|
|
|
|
q--;
|
|
|
|
|
if (q == p)
|
|
|
|
|
break;
|
2017-01-06 16:22:41 +00:00
|
|
|
strbuf_setlen(&buf, q - buf.buf);
|
2017-03-26 02:42:20 +00:00
|
|
|
|
|
|
|
|
strbuf_reset(&sb);
|
2017-03-26 02:42:23 +00:00
|
|
|
files_ref_path(refs, &sb, buf.buf);
|
2017-03-26 02:42:20 +00:00
|
|
|
if ((flags & REMOVE_EMPTY_PARENTS_REF) && rmdir(sb.buf))
|
2017-01-06 16:22:42 +00:00
|
|
|
flags &= ~REMOVE_EMPTY_PARENTS_REF;
|
2017-03-26 02:42:20 +00:00
|
|
|
|
|
|
|
|
strbuf_reset(&sb);
|
2017-03-26 02:42:22 +00:00
|
|
|
files_reflog_path(refs, &sb, buf.buf);
|
2017-03-26 02:42:20 +00:00
|
|
|
if ((flags & REMOVE_EMPTY_PARENTS_REFLOG) && rmdir(sb.buf))
|
2017-01-06 16:22:42 +00:00
|
|
|
flags &= ~REMOVE_EMPTY_PARENTS_REFLOG;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
2017-01-06 16:22:41 +00:00
|
|
|
strbuf_release(&buf);
|
2017-03-26 02:42:20 +00:00
|
|
|
strbuf_release(&sb);
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* make sure nobody touched the ref, and unlink */
|
2017-03-26 02:42:36 +00:00
|
|
|
static void prune_ref(struct files_ref_store *refs, struct ref_to_prune *r)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
|
|
|
|
struct ref_transaction *transaction;
|
|
|
|
|
struct strbuf err = STRBUF_INIT;
|
|
|
|
|
|
|
|
|
|
if (check_refname_format(r->name, 0))
|
|
|
|
|
return;
|
|
|
|
|
|
2017-03-26 02:42:36 +00:00
|
|
|
transaction = ref_store_transaction_begin(&refs->base, &err);
|
2015-11-09 13:34:01 +00:00
|
|
|
if (!transaction ||
|
|
|
|
|
ref_transaction_delete(transaction, r->name, r->sha1,
|
2016-04-24 07:48:26 +00:00
|
|
|
REF_ISPRUNING | REF_NODEREF, NULL, &err) ||
|
2015-11-09 13:34:01 +00:00
|
|
|
ref_transaction_commit(transaction, &err)) {
|
|
|
|
|
ref_transaction_free(transaction);
|
|
|
|
|
error("%s", err.buf);
|
|
|
|
|
strbuf_release(&err);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
ref_transaction_free(transaction);
|
|
|
|
|
strbuf_release(&err);
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-26 02:42:36 +00:00
|
|
|
static void prune_refs(struct files_ref_store *refs, struct ref_to_prune *r)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
|
|
|
|
while (r) {
|
2017-03-26 02:42:36 +00:00
|
|
|
prune_ref(refs, r);
|
2015-11-09 13:34:01 +00:00
|
|
|
r = r->next;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-22 14:17:48 +00:00
|
|
|
/*
|
|
|
|
|
* 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;
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-04 16:08:27 +00:00
|
|
|
static int files_pack_refs(struct ref_store *ref_store, unsigned int flags)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2016-09-04 16:08:11 +00:00
|
|
|
struct files_ref_store *refs =
|
2017-03-26 02:42:32 +00:00
|
|
|
files_downcast(ref_store, REF_STORE_WRITE | REF_STORE_ODB,
|
|
|
|
|
"pack_refs");
|
2017-04-16 06:41:41 +00:00
|
|
|
struct ref_iterator *iter;
|
|
|
|
|
int ok;
|
|
|
|
|
struct ref_to_prune *refs_to_prune = NULL;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-06-23 07:01:29 +00:00
|
|
|
lock_packed_refs(refs->packed_ref_store, LOCK_DIE_ON_ERROR);
|
2017-04-16 06:41:41 +00:00
|
|
|
|
|
|
|
|
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.
|
|
|
|
|
*/
|
2017-05-22 14:17:48 +00:00
|
|
|
if (!should_pack_ref(iter->refname, iter->oid, iter->flags,
|
|
|
|
|
flags))
|
2017-04-16 06:41:41 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Create an entry in the packed-refs cache equivalent
|
|
|
|
|
* to the one from the loose ref cache, except that
|
|
|
|
|
* we don't copy the peeled status, because we want it
|
|
|
|
|
* to be re-peeled.
|
|
|
|
|
*/
|
2017-06-23 07:01:28 +00:00
|
|
|
add_packed_ref(refs->packed_ref_store, iter->refname, iter->oid);
|
2017-04-16 06:41:41 +00:00
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
hashcpy(n->sha1, iter->oid->hash);
|
|
|
|
|
n->next = refs_to_prune;
|
|
|
|
|
refs_to_prune = n;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (ok != ITER_DONE)
|
|
|
|
|
die("error while iterating over references");
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-06-23 07:01:30 +00:00
|
|
|
if (commit_packed_refs(refs->packed_ref_store))
|
2015-11-09 13:34:01 +00:00
|
|
|
die_errno("unable to overwrite old ref-pack file");
|
|
|
|
|
|
2017-04-16 06:41:41 +00:00
|
|
|
prune_refs(refs, refs_to_prune);
|
2015-11-09 13:34:01 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Rewrite the packed-refs file, omitting any refs listed in
|
|
|
|
|
* 'refnames'. On error, leave packed-refs unchanged, write an error
|
|
|
|
|
* message to 'err', and return a nonzero value.
|
|
|
|
|
*
|
|
|
|
|
* The refs in 'refnames' needn't be sorted. `err` must not be NULL.
|
|
|
|
|
*/
|
2016-09-04 16:08:30 +00:00
|
|
|
static int repack_without_refs(struct files_ref_store *refs,
|
|
|
|
|
struct string_list *refnames, struct strbuf *err)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
|
|
|
|
struct ref_dir *packed;
|
|
|
|
|
struct string_list_item *refname;
|
|
|
|
|
int ret, needs_repacking = 0, removed = 0;
|
|
|
|
|
|
2017-02-10 11:16:16 +00:00
|
|
|
files_assert_main_repository(refs, "repack_without_refs");
|
2015-11-09 13:34:01 +00:00
|
|
|
assert(err);
|
|
|
|
|
|
|
|
|
|
/* Look for a packed ref */
|
|
|
|
|
for_each_string_list_item(refname, refnames) {
|
2016-09-04 16:08:13 +00:00
|
|
|
if (get_packed_ref(refs, refname->string)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
needs_repacking = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Avoid locking if we have nothing to do */
|
|
|
|
|
if (!needs_repacking)
|
|
|
|
|
return 0; /* no refname exists in packed refs */
|
|
|
|
|
|
2017-06-23 07:01:29 +00:00
|
|
|
if (lock_packed_refs(refs->packed_ref_store, 0)) {
|
2017-06-23 07:01:22 +00:00
|
|
|
unable_to_lock_message(refs->packed_ref_store->path, errno, err);
|
2015-11-09 13:34:01 +00:00
|
|
|
return -1;
|
|
|
|
|
}
|
2017-06-23 07:01:27 +00:00
|
|
|
packed = get_packed_refs(refs->packed_ref_store);
|
2015-11-09 13:34:01 +00:00
|
|
|
|
|
|
|
|
/* Remove refnames from the cache */
|
|
|
|
|
for_each_string_list_item(refname, refnames)
|
2017-04-16 06:41:30 +00:00
|
|
|
if (remove_entry_from_dir(packed, refname->string) != -1)
|
2015-11-09 13:34:01 +00:00
|
|
|
removed = 1;
|
|
|
|
|
if (!removed) {
|
|
|
|
|
/*
|
|
|
|
|
* All packed entries disappeared while we were
|
|
|
|
|
* acquiring the lock.
|
|
|
|
|
*/
|
2016-09-04 16:08:15 +00:00
|
|
|
rollback_packed_refs(refs);
|
2015-11-09 13:34:01 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Write what remains */
|
2017-06-23 07:01:30 +00:00
|
|
|
ret = commit_packed_refs(refs->packed_ref_store);
|
2015-11-09 13:34:01 +00:00
|
|
|
if (ret)
|
|
|
|
|
strbuf_addf(err, "unable to overwrite old ref-pack file: %s",
|
|
|
|
|
strerror(errno));
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-22 14:17:38 +00:00
|
|
|
static int files_delete_refs(struct ref_store *ref_store, const char *msg,
|
2016-09-04 16:08:40 +00:00
|
|
|
struct string_list *refnames, unsigned int flags)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2016-09-04 16:08:30 +00:00
|
|
|
struct files_ref_store *refs =
|
2017-03-26 02:42:32 +00:00
|
|
|
files_downcast(ref_store, REF_STORE_WRITE, "delete_refs");
|
2015-11-09 13:34:01 +00:00
|
|
|
struct strbuf err = STRBUF_INIT;
|
|
|
|
|
int i, result = 0;
|
|
|
|
|
|
|
|
|
|
if (!refnames->nr)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2016-09-04 16:08:30 +00:00
|
|
|
result = repack_without_refs(refs, refnames, &err);
|
2015-11-09 13:34:01 +00:00
|
|
|
if (result) {
|
|
|
|
|
/*
|
|
|
|
|
* 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);
|
|
|
|
|
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < refnames->nr; i++) {
|
|
|
|
|
const char *refname = refnames->items[i].string;
|
|
|
|
|
|
2017-05-22 14:17:38 +00:00
|
|
|
if (refs_delete_ref(&refs->base, msg, refname, NULL, flags))
|
2015-11-09 13:34:01 +00:00
|
|
|
result |= error(_("could not remove reference %s"), refname);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
strbuf_release(&err);
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
2017-03-26 02:42:21 +00:00
|
|
|
#define TMP_RENAMED_LOG "refs/.tmp-renamed-log"
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-03-26 02:42:20 +00:00
|
|
|
struct rename_cb {
|
|
|
|
|
const char *tmp_renamed_log;
|
|
|
|
|
int true_errno;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int rename_tmp_log_callback(const char *path, void *cb_data)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-03-26 02:42:20 +00:00
|
|
|
struct rename_cb *cb = cb_data;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-03-26 02:42:20 +00:00
|
|
|
if (rename(cb->tmp_renamed_log, path)) {
|
2017-01-06 16:22:29 +00:00
|
|
|
/*
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
2017-03-26 02:42:20 +00:00
|
|
|
cb->true_errno = errno;
|
2017-01-06 16:22:29 +00:00
|
|
|
if (errno == ENOTDIR)
|
|
|
|
|
errno = EISDIR;
|
|
|
|
|
return -1;
|
|
|
|
|
} else {
|
|
|
|
|
return 0;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
2017-01-06 16:22:29 +00:00
|
|
|
}
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
static int rename_tmp_log(struct files_ref_store *refs, const char *newrefname)
|
2017-01-06 16:22:29 +00:00
|
|
|
{
|
2017-03-26 02:42:20 +00:00
|
|
|
struct strbuf path = STRBUF_INIT;
|
|
|
|
|
struct strbuf tmp = STRBUF_INIT;
|
|
|
|
|
struct rename_cb cb;
|
|
|
|
|
int ret;
|
2017-01-06 16:22:29 +00:00
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
files_reflog_path(refs, &path, newrefname);
|
|
|
|
|
files_reflog_path(refs, &tmp, TMP_RENAMED_LOG);
|
2017-03-26 02:42:20 +00:00
|
|
|
cb.tmp_renamed_log = tmp.buf;
|
|
|
|
|
ret = raceproof_create_file(path.buf, rename_tmp_log_callback, &cb);
|
2017-01-06 16:22:29 +00:00
|
|
|
if (ret) {
|
|
|
|
|
if (errno == EISDIR)
|
2017-03-26 02:42:20 +00:00
|
|
|
error("directory not empty: %s", path.buf);
|
2017-01-06 16:22:29 +00:00
|
|
|
else
|
2017-01-06 16:22:30 +00:00
|
|
|
error("unable to move logfile %s to %s: %s",
|
2017-03-26 02:42:20 +00:00
|
|
|
tmp.buf, path.buf,
|
|
|
|
|
strerror(cb.true_errno));
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
2017-01-06 16:22:29 +00:00
|
|
|
|
2017-03-26 02:42:20 +00:00
|
|
|
strbuf_release(&path);
|
|
|
|
|
strbuf_release(&tmp);
|
2015-11-09 13:34:01 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int write_ref_to_lockfile(struct ref_lock *lock,
|
2017-05-06 22:10:24 +00:00
|
|
|
const struct object_id *oid, struct strbuf *err);
|
2016-09-04 16:08:32 +00:00
|
|
|
static int commit_ref_update(struct files_ref_store *refs,
|
|
|
|
|
struct ref_lock *lock,
|
2017-05-06 22:10:24 +00:00
|
|
|
const struct object_id *oid, const char *logmsg,
|
2016-04-22 12:38:56 +00:00
|
|
|
struct strbuf *err);
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2016-09-04 16:08:42 +00:00
|
|
|
static int files_rename_ref(struct ref_store *ref_store,
|
|
|
|
|
const char *oldrefname, const char *newrefname,
|
|
|
|
|
const char *logmsg)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2016-09-04 16:08:42 +00:00
|
|
|
struct files_ref_store *refs =
|
2017-03-26 02:42:32 +00:00
|
|
|
files_downcast(ref_store, REF_STORE_WRITE, "rename_ref");
|
2017-05-06 22:10:24 +00:00
|
|
|
struct object_id oid, orig_oid;
|
2015-11-09 13:34:01 +00:00
|
|
|
int flag = 0, logmoved = 0;
|
|
|
|
|
struct ref_lock *lock;
|
|
|
|
|
struct stat loginfo;
|
2017-03-26 02:42:20 +00:00
|
|
|
struct strbuf sb_oldref = STRBUF_INIT;
|
|
|
|
|
struct strbuf sb_newref = STRBUF_INIT;
|
|
|
|
|
struct strbuf tmp_renamed_log = STRBUF_INIT;
|
|
|
|
|
int log, ret;
|
2015-11-09 13:34:01 +00:00
|
|
|
struct strbuf err = STRBUF_INIT;
|
|
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
files_reflog_path(refs, &sb_oldref, oldrefname);
|
|
|
|
|
files_reflog_path(refs, &sb_newref, newrefname);
|
|
|
|
|
files_reflog_path(refs, &tmp_renamed_log, TMP_RENAMED_LOG);
|
2017-03-26 02:42:20 +00:00
|
|
|
|
|
|
|
|
log = !lstat(sb_oldref.buf, &loginfo);
|
2017-03-26 02:42:19 +00:00
|
|
|
if (log && S_ISLNK(loginfo.st_mode)) {
|
|
|
|
|
ret = error("reflog for %s is a symlink", oldrefname);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-03-26 02:42:36 +00:00
|
|
|
if (!refs_resolve_ref_unsafe(&refs->base, oldrefname,
|
|
|
|
|
RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE,
|
2017-05-06 22:10:24 +00:00
|
|
|
orig_oid.hash, &flag)) {
|
2017-03-26 02:42:19 +00:00
|
|
|
ret = error("refname %s not found", oldrefname);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2016-04-21 21:42:19 +00:00
|
|
|
|
2017-03-26 02:42:19 +00:00
|
|
|
if (flag & REF_ISSYMREF) {
|
|
|
|
|
ret = error("refname %s is a symbolic ref, renaming it is not supported",
|
|
|
|
|
oldrefname);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2017-03-26 02:42:34 +00:00
|
|
|
if (!refs_rename_ref_available(&refs->base, oldrefname, newrefname)) {
|
2017-03-26 02:42:19 +00:00
|
|
|
ret = 1;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-03-26 02:42:20 +00:00
|
|
|
if (log && rename(sb_oldref.buf, tmp_renamed_log.buf)) {
|
2017-03-26 02:42:21 +00:00
|
|
|
ret = error("unable to move logfile logs/%s to logs/"TMP_RENAMED_LOG": %s",
|
2017-03-26 02:42:19 +00:00
|
|
|
oldrefname, strerror(errno));
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-03-26 02:42:36 +00:00
|
|
|
if (refs_delete_ref(&refs->base, logmsg, oldrefname,
|
2017-05-06 22:10:24 +00:00
|
|
|
orig_oid.hash, REF_NODEREF)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
error("unable to delete old %s", oldrefname);
|
|
|
|
|
goto rollback;
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-24 22:58:51 +00:00
|
|
|
/*
|
2017-05-06 22:10:24 +00:00
|
|
|
* 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
|
2016-02-24 22:58:51 +00:00
|
|
|
* the safety anyway; we want to delete the reference whatever
|
|
|
|
|
* its current value.
|
|
|
|
|
*/
|
2017-03-26 02:42:36 +00:00
|
|
|
if (!refs_read_ref_full(&refs->base, newrefname,
|
|
|
|
|
RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE,
|
2017-05-06 22:10:24 +00:00
|
|
|
oid.hash, NULL) &&
|
2017-03-26 02:42:36 +00:00
|
|
|
refs_delete_ref(&refs->base, NULL, newrefname,
|
|
|
|
|
NULL, REF_NODEREF)) {
|
2017-01-06 16:22:21 +00:00
|
|
|
if (errno == EISDIR) {
|
2015-11-09 13:34:01 +00:00
|
|
|
struct strbuf path = STRBUF_INIT;
|
|
|
|
|
int result;
|
|
|
|
|
|
2017-03-26 02:42:23 +00:00
|
|
|
files_ref_path(refs, &path, newrefname);
|
2015-11-09 13:34:01 +00:00
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
if (log && rename_tmp_log(refs, newrefname))
|
2015-11-09 13:34:01 +00:00
|
|
|
goto rollback;
|
|
|
|
|
|
|
|
|
|
logmoved = log;
|
|
|
|
|
|
2016-09-04 16:08:34 +00:00
|
|
|
lock = lock_ref_sha1_basic(refs, newrefname, NULL, NULL, NULL,
|
|
|
|
|
REF_NODEREF, NULL, &err);
|
2015-11-09 13:34:01 +00:00
|
|
|
if (!lock) {
|
|
|
|
|
error("unable to rename '%s' to '%s': %s", oldrefname, newrefname, err.buf);
|
|
|
|
|
strbuf_release(&err);
|
|
|
|
|
goto rollback;
|
|
|
|
|
}
|
2017-05-06 22:10:24 +00:00
|
|
|
oidcpy(&lock->old_oid, &orig_oid);
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-05-06 22:10:24 +00:00
|
|
|
if (write_ref_to_lockfile(lock, &orig_oid, &err) ||
|
|
|
|
|
commit_ref_update(refs, lock, &orig_oid, logmsg, &err)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
error("unable to write current sha1 into %s: %s", newrefname, err.buf);
|
|
|
|
|
strbuf_release(&err);
|
|
|
|
|
goto rollback;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-26 02:42:19 +00:00
|
|
|
ret = 0;
|
|
|
|
|
goto out;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
|
|
|
|
rollback:
|
2016-09-04 16:08:34 +00:00
|
|
|
lock = lock_ref_sha1_basic(refs, oldrefname, NULL, NULL, NULL,
|
|
|
|
|
REF_NODEREF, NULL, &err);
|
2015-11-09 13:34:01 +00:00
|
|
|
if (!lock) {
|
|
|
|
|
error("unable to lock %s for rollback: %s", oldrefname, err.buf);
|
|
|
|
|
strbuf_release(&err);
|
|
|
|
|
goto rollbacklog;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
flag = log_all_ref_updates;
|
2017-01-27 10:09:47 +00:00
|
|
|
log_all_ref_updates = LOG_REFS_NONE;
|
2017-05-06 22:10:24 +00:00
|
|
|
if (write_ref_to_lockfile(lock, &orig_oid, &err) ||
|
|
|
|
|
commit_ref_update(refs, lock, &orig_oid, NULL, &err)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
error("unable to write current sha1 into %s: %s", oldrefname, err.buf);
|
|
|
|
|
strbuf_release(&err);
|
|
|
|
|
}
|
|
|
|
|
log_all_ref_updates = flag;
|
|
|
|
|
|
|
|
|
|
rollbacklog:
|
2017-03-26 02:42:20 +00:00
|
|
|
if (logmoved && rename(sb_newref.buf, sb_oldref.buf))
|
2015-11-09 13:34:01 +00:00
|
|
|
error("unable to restore logfile %s from %s: %s",
|
|
|
|
|
oldrefname, newrefname, strerror(errno));
|
|
|
|
|
if (!logmoved && log &&
|
2017-03-26 02:42:20 +00:00
|
|
|
rename(tmp_renamed_log.buf, sb_oldref.buf))
|
2017-03-26 02:42:21 +00:00
|
|
|
error("unable to restore logfile %s from logs/"TMP_RENAMED_LOG": %s",
|
2015-11-09 13:34:01 +00:00
|
|
|
oldrefname, strerror(errno));
|
2017-03-26 02:42:19 +00:00
|
|
|
ret = 1;
|
|
|
|
|
out:
|
2017-03-26 02:42:20 +00:00
|
|
|
strbuf_release(&sb_newref);
|
|
|
|
|
strbuf_release(&sb_oldref);
|
|
|
|
|
strbuf_release(&tmp_renamed_log);
|
|
|
|
|
|
2017-03-26 02:42:19 +00:00
|
|
|
return ret;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int close_ref(struct ref_lock *lock)
|
|
|
|
|
{
|
|
|
|
|
if (close_lock_file(lock->lk))
|
|
|
|
|
return -1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int commit_ref(struct ref_lock *lock)
|
|
|
|
|
{
|
commit_ref(): if there is an empty dir in the way, delete it
Part of the bug revealed in the last commit is that resolve_ref_unsafe()
incorrectly returns EISDIR if it finds a directory in the place where it
is looking for a loose reference, even if the corresponding packed
reference exists. lock_ref_sha1_basic() notices the bogus EISDIR, and
use it as an indication that it should call remove_empty_directories()
and call resolve_ref_unsafe() again.
But resolve_ref_unsafe() shouldn't report EISDIR in this case. If we
would simply make that change, then remove_empty_directories() wouldn't
get called anymore, and the empty directory would get in the way when
commit_ref() calls commit_lock_file() to rename the lockfile into place.
So instead of relying on lock_ref_sha1_basic() to delete empty
directories, teach commit_ref(), just before calling commit_lock_file(),
to check whether a directory is in the way, and if so, try to delete it.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
2016-05-05 13:33:03 +00:00
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-09 13:34:01 +00:00
|
|
|
if (commit_lock_file(lock->lk))
|
|
|
|
|
return -1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-06 16:22:33 +00:00
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-09 13:34:01 +00:00
|
|
|
/*
|
2017-01-06 16:22:36 +00:00
|
|
|
* 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.
|
2015-11-09 13:34:01 +00:00
|
|
|
*/
|
2017-03-26 02:42:22 +00:00
|
|
|
static int log_ref_setup(struct files_ref_store *refs,
|
|
|
|
|
const char *refname, int force_create,
|
2017-01-06 16:22:36 +00:00
|
|
|
int *logfd, struct strbuf *err)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-03-26 02:42:22 +00:00
|
|
|
struct strbuf logfile_sb = STRBUF_INIT;
|
|
|
|
|
char *logfile;
|
|
|
|
|
|
|
|
|
|
files_reflog_path(refs, &logfile_sb, refname);
|
|
|
|
|
logfile = strbuf_detach(&logfile_sb, NULL);
|
2015-11-09 13:34:01 +00:00
|
|
|
|
|
|
|
|
if (force_create || should_autocreate_reflog(refname)) {
|
2017-01-06 16:22:36 +00:00
|
|
|
if (raceproof_create_file(logfile, open_or_create_logfile, logfd)) {
|
2017-01-06 16:22:33 +00:00
|
|
|
if (errno == ENOENT)
|
|
|
|
|
strbuf_addf(err, "unable to create directory for '%s': "
|
2017-01-06 16:22:36 +00:00
|
|
|
"%s", logfile, strerror(errno));
|
2017-01-06 16:22:33 +00:00
|
|
|
else if (errno == EISDIR)
|
|
|
|
|
strbuf_addf(err, "there are still logs under '%s'",
|
2017-01-06 16:22:36 +00:00
|
|
|
logfile);
|
2017-01-06 16:22:33 +00:00
|
|
|
else
|
2017-01-06 16:22:32 +00:00
|
|
|
strbuf_addf(err, "unable to append to '%s': %s",
|
2017-01-06 16:22:36 +00:00
|
|
|
logfile, strerror(errno));
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-01-06 16:22:36 +00:00
|
|
|
goto error;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
2017-01-06 16:22:32 +00:00
|
|
|
} else {
|
2017-01-06 16:22:36 +00:00
|
|
|
*logfd = open(logfile, O_APPEND | O_WRONLY, 0666);
|
2017-01-06 16:22:34 +00:00
|
|
|
if (*logfd < 0) {
|
2017-01-06 16:22:32 +00:00
|
|
|
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",
|
2017-01-06 16:22:36 +00:00
|
|
|
logfile, strerror(errno));
|
|
|
|
|
goto error;
|
2017-01-06 16:22:32 +00:00
|
|
|
}
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-06 16:22:34 +00:00
|
|
|
if (*logfd >= 0)
|
2017-01-06 16:22:36 +00:00
|
|
|
adjust_shared_perm(logfile);
|
2017-01-06 16:22:32 +00:00
|
|
|
|
2017-01-06 16:22:36 +00:00
|
|
|
free(logfile);
|
2015-11-09 13:34:01 +00:00
|
|
|
return 0;
|
|
|
|
|
|
2017-01-06 16:22:36 +00:00
|
|
|
error:
|
|
|
|
|
free(logfile);
|
|
|
|
|
return -1;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
2016-09-04 16:08:38 +00:00
|
|
|
static int files_create_reflog(struct ref_store *ref_store,
|
|
|
|
|
const char *refname, int force_create,
|
|
|
|
|
struct strbuf *err)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-03-26 02:42:22 +00:00
|
|
|
struct files_ref_store *refs =
|
2017-03-26 02:42:32 +00:00
|
|
|
files_downcast(ref_store, REF_STORE_WRITE, "create_reflog");
|
2017-01-06 16:22:34 +00:00
|
|
|
int fd;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
if (log_ref_setup(refs, refname, force_create, &fd, err))
|
2017-01-06 16:22:36 +00:00
|
|
|
return -1;
|
|
|
|
|
|
2017-01-06 16:22:34 +00:00
|
|
|
if (fd >= 0)
|
|
|
|
|
close(fd);
|
2017-01-06 16:22:36 +00:00
|
|
|
|
|
|
|
|
return 0;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
2017-05-06 22:10:24 +00:00
|
|
|
static int log_ref_write_fd(int fd, const struct object_id *old_oid,
|
|
|
|
|
const struct object_id *new_oid,
|
2015-11-09 13:34:01 +00:00
|
|
|
const char *committer, const char *msg)
|
|
|
|
|
{
|
|
|
|
|
int msglen, written;
|
|
|
|
|
unsigned maxlen, len;
|
|
|
|
|
char *logrec;
|
|
|
|
|
|
|
|
|
|
msglen = msg ? strlen(msg) : 0;
|
|
|
|
|
maxlen = strlen(committer) + msglen + 100;
|
|
|
|
|
logrec = xmalloc(maxlen);
|
|
|
|
|
len = xsnprintf(logrec, maxlen, "%s %s %s\n",
|
2017-05-06 22:10:24 +00:00
|
|
|
oid_to_hex(old_oid),
|
|
|
|
|
oid_to_hex(new_oid),
|
2015-11-09 13:34:01 +00:00
|
|
|
committer);
|
|
|
|
|
if (msglen)
|
|
|
|
|
len += copy_reflog_msg(logrec + len - 1, msg) - 1;
|
|
|
|
|
|
|
|
|
|
written = len <= maxlen ? write_in_full(fd, logrec, len) : -1;
|
|
|
|
|
free(logrec);
|
|
|
|
|
if (written != len)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
static int files_log_ref_write(struct files_ref_store *refs,
|
2017-05-06 22:10:24 +00:00
|
|
|
const char *refname, const struct object_id *old_oid,
|
|
|
|
|
const struct object_id *new_oid, const char *msg,
|
2017-03-26 02:42:15 +00:00
|
|
|
int flags, struct strbuf *err)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-01-06 16:22:34 +00:00
|
|
|
int logfd, result;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-01-27 10:09:47 +00:00
|
|
|
if (log_all_ref_updates == LOG_REFS_UNSET)
|
|
|
|
|
log_all_ref_updates = is_bare_repository() ? LOG_REFS_NONE : LOG_REFS_NORMAL;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
result = log_ref_setup(refs, refname,
|
|
|
|
|
flags & REF_FORCE_CREATE_REFLOG,
|
2017-01-06 16:22:36 +00:00
|
|
|
&logfd, err);
|
2015-11-09 13:34:01 +00:00
|
|
|
|
|
|
|
|
if (result)
|
|
|
|
|
return result;
|
|
|
|
|
|
|
|
|
|
if (logfd < 0)
|
|
|
|
|
return 0;
|
2017-05-06 22:10:24 +00:00
|
|
|
result = log_ref_write_fd(logfd, old_oid, new_oid,
|
2015-11-09 13:34:01 +00:00
|
|
|
git_committer_info(0), msg);
|
|
|
|
|
if (result) {
|
2017-03-26 02:42:20 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2017-01-06 16:22:35 +00:00
|
|
|
int save_errno = errno;
|
|
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
files_reflog_path(refs, &sb, refname);
|
2017-01-06 16:22:35 +00:00
|
|
|
strbuf_addf(err, "unable to append to '%s': %s",
|
2017-03-26 02:42:20 +00:00
|
|
|
sb.buf, strerror(save_errno));
|
|
|
|
|
strbuf_release(&sb);
|
2015-11-09 13:34:01 +00:00
|
|
|
close(logfd);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
if (close(logfd)) {
|
2017-03-26 02:42:20 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2017-01-06 16:22:35 +00:00
|
|
|
int save_errno = errno;
|
|
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
files_reflog_path(refs, &sb, refname);
|
2017-01-06 16:22:35 +00:00
|
|
|
strbuf_addf(err, "unable to append to '%s': %s",
|
2017-03-26 02:42:20 +00:00
|
|
|
sb.buf, strerror(save_errno));
|
|
|
|
|
strbuf_release(&sb);
|
2015-11-09 13:34:01 +00:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Write sha1 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,
|
2017-05-06 22:10:24 +00:00
|
|
|
const struct object_id *oid, struct strbuf *err)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
|
|
|
|
static char term = '\n';
|
|
|
|
|
struct object *o;
|
|
|
|
|
int fd;
|
|
|
|
|
|
object: convert parse_object* to take struct object_id
Make parse_object, parse_object_or_die, and parse_object_buffer take a
pointer to struct object_id. Remove the temporary variables inserted
earlier, since they are no longer necessary. Transform all of the
callers using the following semantic patch:
@@
expression E1;
@@
- parse_object(E1.hash)
+ parse_object(&E1)
@@
expression E1;
@@
- parse_object(E1->hash)
+ parse_object(E1)
@@
expression E1, E2;
@@
- parse_object_or_die(E1.hash, E2)
+ parse_object_or_die(&E1, E2)
@@
expression E1, E2;
@@
- parse_object_or_die(E1->hash, E2)
+ parse_object_or_die(E1, E2)
@@
expression E1, E2, E3, E4, E5;
@@
- parse_object_buffer(E1.hash, E2, E3, E4, E5)
+ parse_object_buffer(&E1, E2, E3, E4, E5)
@@
expression E1, E2, E3, E4, E5;
@@
- parse_object_buffer(E1->hash, E2, E3, E4, E5)
+ parse_object_buffer(E1, E2, E3, E4, E5)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-06 22:10:38 +00:00
|
|
|
o = parse_object(oid);
|
2015-11-09 13:34:01 +00:00
|
|
|
if (!o) {
|
|
|
|
|
strbuf_addf(err,
|
2016-04-27 13:21:36 +00:00
|
|
|
"trying to write ref '%s' with nonexistent object %s",
|
2017-05-06 22:10:24 +00:00
|
|
|
lock->ref_name, oid_to_hex(oid));
|
2015-11-09 13:34:01 +00:00
|
|
|
unlock_ref(lock);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {
|
|
|
|
|
strbuf_addf(err,
|
2016-04-27 13:21:36 +00:00
|
|
|
"trying to write non-commit object %s to branch '%s'",
|
2017-05-06 22:10:24 +00:00
|
|
|
oid_to_hex(oid), lock->ref_name);
|
2015-11-09 13:34:01 +00:00
|
|
|
unlock_ref(lock);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
fd = get_lock_file_fd(lock->lk);
|
2017-05-06 22:10:24 +00:00
|
|
|
if (write_in_full(fd, oid_to_hex(oid), GIT_SHA1_HEXSZ) != GIT_SHA1_HEXSZ ||
|
2015-11-09 13:34:01 +00:00
|
|
|
write_in_full(fd, &term, 1) != 1 ||
|
|
|
|
|
close_ref(lock) < 0) {
|
|
|
|
|
strbuf_addf(err,
|
2016-04-27 13:21:36 +00:00
|
|
|
"couldn't write '%s'", get_lock_file_path(lock->lk));
|
2015-11-09 13:34:01 +00:00
|
|
|
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).
|
|
|
|
|
*/
|
2016-09-04 16:08:32 +00:00
|
|
|
static int commit_ref_update(struct files_ref_store *refs,
|
|
|
|
|
struct ref_lock *lock,
|
2017-05-06 22:10:24 +00:00
|
|
|
const struct object_id *oid, const char *logmsg,
|
2016-04-22 12:38:56 +00:00
|
|
|
struct strbuf *err)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-02-10 11:16:16 +00:00
|
|
|
files_assert_main_repository(refs, "commit_ref_update");
|
2016-09-04 16:08:11 +00:00
|
|
|
|
|
|
|
|
clear_loose_ref_cache(refs);
|
2017-03-26 02:42:22 +00:00
|
|
|
if (files_log_ref_write(refs, lock->ref_name,
|
2017-05-06 22:10:24 +00:00
|
|
|
&lock->old_oid, oid,
|
2017-01-06 16:22:31 +00:00
|
|
|
logmsg, 0, err)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
char *old_msg = strbuf_detach(err, NULL);
|
2016-04-27 13:21:36 +00:00
|
|
|
strbuf_addf(err, "cannot update the ref '%s': %s",
|
2015-11-09 13:34:01 +00:00
|
|
|
lock->ref_name, old_msg);
|
|
|
|
|
free(old_msg);
|
|
|
|
|
unlock_ref(lock);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2016-04-22 13:25:25 +00:00
|
|
|
|
|
|
|
|
if (strcmp(lock->ref_name, "HEAD") != 0) {
|
2015-11-09 13:34:01 +00:00
|
|
|
/*
|
|
|
|
|
* 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).
|
|
|
|
|
*/
|
2017-05-06 22:10:24 +00:00
|
|
|
struct object_id head_oid;
|
2015-11-09 13:34:01 +00:00
|
|
|
int head_flag;
|
|
|
|
|
const char *head_ref;
|
2016-04-22 13:25:25 +00:00
|
|
|
|
2017-03-26 02:42:36 +00:00
|
|
|
head_ref = refs_resolve_ref_unsafe(&refs->base, "HEAD",
|
|
|
|
|
RESOLVE_REF_READING,
|
2017-05-06 22:10:24 +00:00
|
|
|
head_oid.hash, &head_flag);
|
2015-11-09 13:34:01 +00:00
|
|
|
if (head_ref && (head_flag & REF_ISSYMREF) &&
|
|
|
|
|
!strcmp(head_ref, lock->ref_name)) {
|
|
|
|
|
struct strbuf log_err = STRBUF_INIT;
|
2017-03-26 02:42:22 +00:00
|
|
|
if (files_log_ref_write(refs, "HEAD",
|
2017-05-06 22:10:24 +00:00
|
|
|
&lock->old_oid, oid,
|
2017-03-26 02:42:22 +00:00
|
|
|
logmsg, 0, &log_err)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
error("%s", log_err.buf);
|
|
|
|
|
strbuf_release(&log_err);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-04-22 13:25:25 +00:00
|
|
|
|
2015-11-09 13:34:01 +00:00
|
|
|
if (commit_ref(lock)) {
|
2016-04-27 13:21:36 +00:00
|
|
|
strbuf_addf(err, "couldn't set '%s'", lock->ref_name);
|
2015-11-09 13:34:01 +00:00
|
|
|
unlock_ref(lock);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
unlock_ref(lock);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
create_symref: use existing ref-lock code
The create_symref() function predates the existence of
"struct lock_file", let alone the more recent "struct
ref_lock". Instead, it just does its own manual dot-locking.
Besides being more code, this has a few downsides:
- if git is interrupted while holding the lock, we don't
clean up the lockfile
- we don't do the usual directory/filename conflict check.
So you can sometimes create a symref "refs/heads/foo/bar",
even if "refs/heads/foo" exists (namely, if the refs are
packed and we do not hit the d/f conflict in the
filesystem).
This patch refactors create_symref() to use the "struct
ref_lock" interface, which handles both of these things.
There are a few bonus cleanups that come along with it:
- we leaked ref_path in some error cases
- the symref contents were stored in a fixed-size buffer,
putting an artificial (albeit large) limitation on the
length of the refname. We now write through fprintf, and
handle refnames of any size.
- we called adjust_shared_perm only after the file was
renamed into place, creating a potential race with
readers in a shared repository. The lockfile code now
handles this when creating the lockfile, making it
atomic.
- the legacy prefer_symlink_refs path did not do any
locking at all. Admittedly, it is not atomic from a
reader's perspective (as it unlinks and re-creates the
symlink to overwrite), but at least it cannot conflict
with other writers now.
- the result of this patch is hopefully more readable. It
eliminates three goto labels. Two were for error checking
that is now simplified, and the third was to reach shared
code that has been pulled into its own function.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-29 05:57:01 +00:00
|
|
|
static int create_ref_symlink(struct ref_lock *lock, const char *target)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
create_symref: use existing ref-lock code
The create_symref() function predates the existence of
"struct lock_file", let alone the more recent "struct
ref_lock". Instead, it just does its own manual dot-locking.
Besides being more code, this has a few downsides:
- if git is interrupted while holding the lock, we don't
clean up the lockfile
- we don't do the usual directory/filename conflict check.
So you can sometimes create a symref "refs/heads/foo/bar",
even if "refs/heads/foo" exists (namely, if the refs are
packed and we do not hit the d/f conflict in the
filesystem).
This patch refactors create_symref() to use the "struct
ref_lock" interface, which handles both of these things.
There are a few bonus cleanups that come along with it:
- we leaked ref_path in some error cases
- the symref contents were stored in a fixed-size buffer,
putting an artificial (albeit large) limitation on the
length of the refname. We now write through fprintf, and
handle refnames of any size.
- we called adjust_shared_perm only after the file was
renamed into place, creating a potential race with
readers in a shared repository. The lockfile code now
handles this when creating the lockfile, making it
atomic.
- the legacy prefer_symlink_refs path did not do any
locking at all. Admittedly, it is not atomic from a
reader's perspective (as it unlinks and re-creates the
symlink to overwrite), but at least it cannot conflict
with other writers now.
- the result of this patch is hopefully more readable. It
eliminates three goto labels. Two were for error checking
that is now simplified, and the third was to reach shared
code that has been pulled into its own function.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-29 05:57:01 +00:00
|
|
|
int ret = -1;
|
2015-11-09 13:34:01 +00:00
|
|
|
#ifndef NO_SYMLINK_HEAD
|
create_symref: use existing ref-lock code
The create_symref() function predates the existence of
"struct lock_file", let alone the more recent "struct
ref_lock". Instead, it just does its own manual dot-locking.
Besides being more code, this has a few downsides:
- if git is interrupted while holding the lock, we don't
clean up the lockfile
- we don't do the usual directory/filename conflict check.
So you can sometimes create a symref "refs/heads/foo/bar",
even if "refs/heads/foo" exists (namely, if the refs are
packed and we do not hit the d/f conflict in the
filesystem).
This patch refactors create_symref() to use the "struct
ref_lock" interface, which handles both of these things.
There are a few bonus cleanups that come along with it:
- we leaked ref_path in some error cases
- the symref contents were stored in a fixed-size buffer,
putting an artificial (albeit large) limitation on the
length of the refname. We now write through fprintf, and
handle refnames of any size.
- we called adjust_shared_perm only after the file was
renamed into place, creating a potential race with
readers in a shared repository. The lockfile code now
handles this when creating the lockfile, making it
atomic.
- the legacy prefer_symlink_refs path did not do any
locking at all. Admittedly, it is not atomic from a
reader's perspective (as it unlinks and re-creates the
symlink to overwrite), but at least it cannot conflict
with other writers now.
- the result of this patch is hopefully more readable. It
eliminates three goto labels. Two were for error checking
that is now simplified, and the third was to reach shared
code that has been pulled into its own function.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-29 05:57:01 +00:00
|
|
|
char *ref_path = get_locked_file_path(lock->lk);
|
|
|
|
|
unlink(ref_path);
|
|
|
|
|
ret = symlink(target, ref_path);
|
|
|
|
|
free(ref_path);
|
|
|
|
|
|
|
|
|
|
if (ret)
|
2015-11-09 13:34:01 +00:00
|
|
|
fprintf(stderr, "no symlink - falling back to symbolic ref\n");
|
|
|
|
|
#endif
|
create_symref: use existing ref-lock code
The create_symref() function predates the existence of
"struct lock_file", let alone the more recent "struct
ref_lock". Instead, it just does its own manual dot-locking.
Besides being more code, this has a few downsides:
- if git is interrupted while holding the lock, we don't
clean up the lockfile
- we don't do the usual directory/filename conflict check.
So you can sometimes create a symref "refs/heads/foo/bar",
even if "refs/heads/foo" exists (namely, if the refs are
packed and we do not hit the d/f conflict in the
filesystem).
This patch refactors create_symref() to use the "struct
ref_lock" interface, which handles both of these things.
There are a few bonus cleanups that come along with it:
- we leaked ref_path in some error cases
- the symref contents were stored in a fixed-size buffer,
putting an artificial (albeit large) limitation on the
length of the refname. We now write through fprintf, and
handle refnames of any size.
- we called adjust_shared_perm only after the file was
renamed into place, creating a potential race with
readers in a shared repository. The lockfile code now
handles this when creating the lockfile, making it
atomic.
- the legacy prefer_symlink_refs path did not do any
locking at all. Admittedly, it is not atomic from a
reader's perspective (as it unlinks and re-creates the
symlink to overwrite), but at least it cannot conflict
with other writers now.
- the result of this patch is hopefully more readable. It
eliminates three goto labels. Two were for error checking
that is now simplified, and the third was to reach shared
code that has been pulled into its own function.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-29 05:57:01 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
static void update_symref_reflog(struct files_ref_store *refs,
|
|
|
|
|
struct ref_lock *lock, const char *refname,
|
create_symref: use existing ref-lock code
The create_symref() function predates the existence of
"struct lock_file", let alone the more recent "struct
ref_lock". Instead, it just does its own manual dot-locking.
Besides being more code, this has a few downsides:
- if git is interrupted while holding the lock, we don't
clean up the lockfile
- we don't do the usual directory/filename conflict check.
So you can sometimes create a symref "refs/heads/foo/bar",
even if "refs/heads/foo" exists (namely, if the refs are
packed and we do not hit the d/f conflict in the
filesystem).
This patch refactors create_symref() to use the "struct
ref_lock" interface, which handles both of these things.
There are a few bonus cleanups that come along with it:
- we leaked ref_path in some error cases
- the symref contents were stored in a fixed-size buffer,
putting an artificial (albeit large) limitation on the
length of the refname. We now write through fprintf, and
handle refnames of any size.
- we called adjust_shared_perm only after the file was
renamed into place, creating a potential race with
readers in a shared repository. The lockfile code now
handles this when creating the lockfile, making it
atomic.
- the legacy prefer_symlink_refs path did not do any
locking at all. Admittedly, it is not atomic from a
reader's perspective (as it unlinks and re-creates the
symlink to overwrite), but at least it cannot conflict
with other writers now.
- the result of this patch is hopefully more readable. It
eliminates three goto labels. Two were for error checking
that is now simplified, and the third was to reach shared
code that has been pulled into its own function.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-29 05:57:01 +00:00
|
|
|
const char *target, const char *logmsg)
|
|
|
|
|
{
|
|
|
|
|
struct strbuf err = STRBUF_INIT;
|
2017-05-06 22:10:24 +00:00
|
|
|
struct object_id new_oid;
|
2017-03-26 02:42:36 +00:00
|
|
|
if (logmsg &&
|
|
|
|
|
!refs_read_ref_full(&refs->base, target,
|
2017-05-06 22:10:24 +00:00
|
|
|
RESOLVE_REF_READING, new_oid.hash, NULL) &&
|
|
|
|
|
files_log_ref_write(refs, refname, &lock->old_oid,
|
|
|
|
|
&new_oid, logmsg, 0, &err)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
error("%s", err.buf);
|
|
|
|
|
strbuf_release(&err);
|
|
|
|
|
}
|
create_symref: use existing ref-lock code
The create_symref() function predates the existence of
"struct lock_file", let alone the more recent "struct
ref_lock". Instead, it just does its own manual dot-locking.
Besides being more code, this has a few downsides:
- if git is interrupted while holding the lock, we don't
clean up the lockfile
- we don't do the usual directory/filename conflict check.
So you can sometimes create a symref "refs/heads/foo/bar",
even if "refs/heads/foo" exists (namely, if the refs are
packed and we do not hit the d/f conflict in the
filesystem).
This patch refactors create_symref() to use the "struct
ref_lock" interface, which handles both of these things.
There are a few bonus cleanups that come along with it:
- we leaked ref_path in some error cases
- the symref contents were stored in a fixed-size buffer,
putting an artificial (albeit large) limitation on the
length of the refname. We now write through fprintf, and
handle refnames of any size.
- we called adjust_shared_perm only after the file was
renamed into place, creating a potential race with
readers in a shared repository. The lockfile code now
handles this when creating the lockfile, making it
atomic.
- the legacy prefer_symlink_refs path did not do any
locking at all. Admittedly, it is not atomic from a
reader's perspective (as it unlinks and re-creates the
symlink to overwrite), but at least it cannot conflict
with other writers now.
- the result of this patch is hopefully more readable. It
eliminates three goto labels. Two were for error checking
that is now simplified, and the third was to reach shared
code that has been pulled into its own function.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-29 05:57:01 +00:00
|
|
|
}
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
static int create_symref_locked(struct files_ref_store *refs,
|
|
|
|
|
struct ref_lock *lock, const char *refname,
|
create_symref: use existing ref-lock code
The create_symref() function predates the existence of
"struct lock_file", let alone the more recent "struct
ref_lock". Instead, it just does its own manual dot-locking.
Besides being more code, this has a few downsides:
- if git is interrupted while holding the lock, we don't
clean up the lockfile
- we don't do the usual directory/filename conflict check.
So you can sometimes create a symref "refs/heads/foo/bar",
even if "refs/heads/foo" exists (namely, if the refs are
packed and we do not hit the d/f conflict in the
filesystem).
This patch refactors create_symref() to use the "struct
ref_lock" interface, which handles both of these things.
There are a few bonus cleanups that come along with it:
- we leaked ref_path in some error cases
- the symref contents were stored in a fixed-size buffer,
putting an artificial (albeit large) limitation on the
length of the refname. We now write through fprintf, and
handle refnames of any size.
- we called adjust_shared_perm only after the file was
renamed into place, creating a potential race with
readers in a shared repository. The lockfile code now
handles this when creating the lockfile, making it
atomic.
- the legacy prefer_symlink_refs path did not do any
locking at all. Admittedly, it is not atomic from a
reader's perspective (as it unlinks and re-creates the
symlink to overwrite), but at least it cannot conflict
with other writers now.
- the result of this patch is hopefully more readable. It
eliminates three goto labels. Two were for error checking
that is now simplified, and the third was to reach shared
code that has been pulled into its own function.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-29 05:57:01 +00:00
|
|
|
const char *target, const char *logmsg)
|
|
|
|
|
{
|
|
|
|
|
if (prefer_symlink_refs && !create_ref_symlink(lock, target)) {
|
2017-03-26 02:42:22 +00:00
|
|
|
update_symref_reflog(refs, lock, refname, target, logmsg);
|
create_symref: use existing ref-lock code
The create_symref() function predates the existence of
"struct lock_file", let alone the more recent "struct
ref_lock". Instead, it just does its own manual dot-locking.
Besides being more code, this has a few downsides:
- if git is interrupted while holding the lock, we don't
clean up the lockfile
- we don't do the usual directory/filename conflict check.
So you can sometimes create a symref "refs/heads/foo/bar",
even if "refs/heads/foo" exists (namely, if the refs are
packed and we do not hit the d/f conflict in the
filesystem).
This patch refactors create_symref() to use the "struct
ref_lock" interface, which handles both of these things.
There are a few bonus cleanups that come along with it:
- we leaked ref_path in some error cases
- the symref contents were stored in a fixed-size buffer,
putting an artificial (albeit large) limitation on the
length of the refname. We now write through fprintf, and
handle refnames of any size.
- we called adjust_shared_perm only after the file was
renamed into place, creating a potential race with
readers in a shared repository. The lockfile code now
handles this when creating the lockfile, making it
atomic.
- the legacy prefer_symlink_refs path did not do any
locking at all. Admittedly, it is not atomic from a
reader's perspective (as it unlinks and re-creates the
symlink to overwrite), but at least it cannot conflict
with other writers now.
- the result of this patch is hopefully more readable. It
eliminates three goto labels. Two were for error checking
that is now simplified, and the third was to reach shared
code that has been pulled into its own function.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-29 05:57:01 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!fdopen_lock_file(lock->lk, "w"))
|
|
|
|
|
return error("unable to fdopen %s: %s",
|
|
|
|
|
lock->lk->tempfile.filename.buf, strerror(errno));
|
|
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
update_symref_reflog(refs, lock, refname, target, logmsg);
|
2015-12-29 05:57:25 +00:00
|
|
|
|
create_symref: use existing ref-lock code
The create_symref() function predates the existence of
"struct lock_file", let alone the more recent "struct
ref_lock". Instead, it just does its own manual dot-locking.
Besides being more code, this has a few downsides:
- if git is interrupted while holding the lock, we don't
clean up the lockfile
- we don't do the usual directory/filename conflict check.
So you can sometimes create a symref "refs/heads/foo/bar",
even if "refs/heads/foo" exists (namely, if the refs are
packed and we do not hit the d/f conflict in the
filesystem).
This patch refactors create_symref() to use the "struct
ref_lock" interface, which handles both of these things.
There are a few bonus cleanups that come along with it:
- we leaked ref_path in some error cases
- the symref contents were stored in a fixed-size buffer,
putting an artificial (albeit large) limitation on the
length of the refname. We now write through fprintf, and
handle refnames of any size.
- we called adjust_shared_perm only after the file was
renamed into place, creating a potential race with
readers in a shared repository. The lockfile code now
handles this when creating the lockfile, making it
atomic.
- the legacy prefer_symlink_refs path did not do any
locking at all. Admittedly, it is not atomic from a
reader's perspective (as it unlinks and re-creates the
symlink to overwrite), but at least it cannot conflict
with other writers now.
- the result of this patch is hopefully more readable. It
eliminates three goto labels. Two were for error checking
that is now simplified, and the third was to reach shared
code that has been pulled into its own function.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-29 05:57:01 +00:00
|
|
|
/* 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));
|
2015-11-09 13:34:01 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-04 16:08:28 +00:00
|
|
|
static int files_create_symref(struct ref_store *ref_store,
|
|
|
|
|
const char *refname, const char *target,
|
|
|
|
|
const char *logmsg)
|
create_symref: use existing ref-lock code
The create_symref() function predates the existence of
"struct lock_file", let alone the more recent "struct
ref_lock". Instead, it just does its own manual dot-locking.
Besides being more code, this has a few downsides:
- if git is interrupted while holding the lock, we don't
clean up the lockfile
- we don't do the usual directory/filename conflict check.
So you can sometimes create a symref "refs/heads/foo/bar",
even if "refs/heads/foo" exists (namely, if the refs are
packed and we do not hit the d/f conflict in the
filesystem).
This patch refactors create_symref() to use the "struct
ref_lock" interface, which handles both of these things.
There are a few bonus cleanups that come along with it:
- we leaked ref_path in some error cases
- the symref contents were stored in a fixed-size buffer,
putting an artificial (albeit large) limitation on the
length of the refname. We now write through fprintf, and
handle refnames of any size.
- we called adjust_shared_perm only after the file was
renamed into place, creating a potential race with
readers in a shared repository. The lockfile code now
handles this when creating the lockfile, making it
atomic.
- the legacy prefer_symlink_refs path did not do any
locking at all. Admittedly, it is not atomic from a
reader's perspective (as it unlinks and re-creates the
symlink to overwrite), but at least it cannot conflict
with other writers now.
- the result of this patch is hopefully more readable. It
eliminates three goto labels. Two were for error checking
that is now simplified, and the third was to reach shared
code that has been pulled into its own function.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-29 05:57:01 +00:00
|
|
|
{
|
2016-09-04 16:08:34 +00:00
|
|
|
struct files_ref_store *refs =
|
2017-03-26 02:42:32 +00:00
|
|
|
files_downcast(ref_store, REF_STORE_WRITE, "create_symref");
|
create_symref: use existing ref-lock code
The create_symref() function predates the existence of
"struct lock_file", let alone the more recent "struct
ref_lock". Instead, it just does its own manual dot-locking.
Besides being more code, this has a few downsides:
- if git is interrupted while holding the lock, we don't
clean up the lockfile
- we don't do the usual directory/filename conflict check.
So you can sometimes create a symref "refs/heads/foo/bar",
even if "refs/heads/foo" exists (namely, if the refs are
packed and we do not hit the d/f conflict in the
filesystem).
This patch refactors create_symref() to use the "struct
ref_lock" interface, which handles both of these things.
There are a few bonus cleanups that come along with it:
- we leaked ref_path in some error cases
- the symref contents were stored in a fixed-size buffer,
putting an artificial (albeit large) limitation on the
length of the refname. We now write through fprintf, and
handle refnames of any size.
- we called adjust_shared_perm only after the file was
renamed into place, creating a potential race with
readers in a shared repository. The lockfile code now
handles this when creating the lockfile, making it
atomic.
- the legacy prefer_symlink_refs path did not do any
locking at all. Admittedly, it is not atomic from a
reader's perspective (as it unlinks and re-creates the
symlink to overwrite), but at least it cannot conflict
with other writers now.
- the result of this patch is hopefully more readable. It
eliminates three goto labels. Two were for error checking
that is now simplified, and the third was to reach shared
code that has been pulled into its own function.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-29 05:57:01 +00:00
|
|
|
struct strbuf err = STRBUF_INIT;
|
|
|
|
|
struct ref_lock *lock;
|
|
|
|
|
int ret;
|
|
|
|
|
|
2016-09-04 16:08:34 +00:00
|
|
|
lock = lock_ref_sha1_basic(refs, refname, NULL,
|
|
|
|
|
NULL, NULL, REF_NODEREF, NULL,
|
create_symref: use existing ref-lock code
The create_symref() function predates the existence of
"struct lock_file", let alone the more recent "struct
ref_lock". Instead, it just does its own manual dot-locking.
Besides being more code, this has a few downsides:
- if git is interrupted while holding the lock, we don't
clean up the lockfile
- we don't do the usual directory/filename conflict check.
So you can sometimes create a symref "refs/heads/foo/bar",
even if "refs/heads/foo" exists (namely, if the refs are
packed and we do not hit the d/f conflict in the
filesystem).
This patch refactors create_symref() to use the "struct
ref_lock" interface, which handles both of these things.
There are a few bonus cleanups that come along with it:
- we leaked ref_path in some error cases
- the symref contents were stored in a fixed-size buffer,
putting an artificial (albeit large) limitation on the
length of the refname. We now write through fprintf, and
handle refnames of any size.
- we called adjust_shared_perm only after the file was
renamed into place, creating a potential race with
readers in a shared repository. The lockfile code now
handles this when creating the lockfile, making it
atomic.
- the legacy prefer_symlink_refs path did not do any
locking at all. Admittedly, it is not atomic from a
reader's perspective (as it unlinks and re-creates the
symlink to overwrite), but at least it cannot conflict
with other writers now.
- the result of this patch is hopefully more readable. It
eliminates three goto labels. Two were for error checking
that is now simplified, and the third was to reach shared
code that has been pulled into its own function.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-29 05:57:01 +00:00
|
|
|
&err);
|
|
|
|
|
if (!lock) {
|
|
|
|
|
error("%s", err.buf);
|
|
|
|
|
strbuf_release(&err);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
ret = create_symref_locked(refs, lock, refname, target, logmsg);
|
create_symref: use existing ref-lock code
The create_symref() function predates the existence of
"struct lock_file", let alone the more recent "struct
ref_lock". Instead, it just does its own manual dot-locking.
Besides being more code, this has a few downsides:
- if git is interrupted while holding the lock, we don't
clean up the lockfile
- we don't do the usual directory/filename conflict check.
So you can sometimes create a symref "refs/heads/foo/bar",
even if "refs/heads/foo" exists (namely, if the refs are
packed and we do not hit the d/f conflict in the
filesystem).
This patch refactors create_symref() to use the "struct
ref_lock" interface, which handles both of these things.
There are a few bonus cleanups that come along with it:
- we leaked ref_path in some error cases
- the symref contents were stored in a fixed-size buffer,
putting an artificial (albeit large) limitation on the
length of the refname. We now write through fprintf, and
handle refnames of any size.
- we called adjust_shared_perm only after the file was
renamed into place, creating a potential race with
readers in a shared repository. The lockfile code now
handles this when creating the lockfile, making it
atomic.
- the legacy prefer_symlink_refs path did not do any
locking at all. Admittedly, it is not atomic from a
reader's perspective (as it unlinks and re-creates the
symlink to overwrite), but at least it cannot conflict
with other writers now.
- the result of this patch is hopefully more readable. It
eliminates three goto labels. Two were for error checking
that is now simplified, and the third was to reach shared
code that has been pulled into its own function.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-29 05:57:01 +00:00
|
|
|
unlock_ref(lock);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-04 16:08:38 +00:00
|
|
|
static int files_reflog_exists(struct ref_store *ref_store,
|
|
|
|
|
const char *refname)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-03-26 02:42:22 +00:00
|
|
|
struct files_ref_store *refs =
|
2017-03-26 02:42:32 +00:00
|
|
|
files_downcast(ref_store, REF_STORE_READ, "reflog_exists");
|
2017-03-26 02:42:20 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2015-11-09 13:34:01 +00:00
|
|
|
struct stat st;
|
2017-03-26 02:42:20 +00:00
|
|
|
int ret;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
files_reflog_path(refs, &sb, refname);
|
2017-03-26 02:42:20 +00:00
|
|
|
ret = !lstat(sb.buf, &st) && S_ISREG(st.st_mode);
|
|
|
|
|
strbuf_release(&sb);
|
|
|
|
|
return ret;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
2016-09-04 16:08:38 +00:00
|
|
|
static int files_delete_reflog(struct ref_store *ref_store,
|
|
|
|
|
const char *refname)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-03-26 02:42:22 +00:00
|
|
|
struct files_ref_store *refs =
|
2017-03-26 02:42:32 +00:00
|
|
|
files_downcast(ref_store, REF_STORE_WRITE, "delete_reflog");
|
2017-03-26 02:42:20 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
|
int ret;
|
|
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
files_reflog_path(refs, &sb, refname);
|
2017-03-26 02:42:20 +00:00
|
|
|
ret = remove_path(sb.buf);
|
|
|
|
|
strbuf_release(&sb);
|
|
|
|
|
return ret;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int show_one_reflog_ent(struct strbuf *sb, each_reflog_ent_fn fn, void *cb_data)
|
|
|
|
|
{
|
2017-02-21 23:47:32 +00:00
|
|
|
struct object_id ooid, noid;
|
2015-11-09 13:34:01 +00:00
|
|
|
char *email_end, *message;
|
2017-04-26 19:29:31 +00:00
|
|
|
timestamp_t timestamp;
|
2015-11-09 13:34:01 +00:00
|
|
|
int tz;
|
2017-02-21 23:47:33 +00:00
|
|
|
const char *p = sb->buf;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
|
|
|
|
/* old SP new SP name <email> SP time TAB msg LF */
|
2017-02-21 23:47:33 +00:00
|
|
|
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, '>')) ||
|
2015-11-09 13:34:01 +00:00
|
|
|
email_end[1] != ' ' ||
|
2017-04-21 10:45:44 +00:00
|
|
|
!(timestamp = parse_timestamp(email_end + 2, &message, 10)) ||
|
2015-11-09 13:34:01 +00:00
|
|
|
!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;
|
2017-02-21 23:47:33 +00:00
|
|
|
return fn(&ooid, &noid, p, timestamp, tz, message, cb_data);
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-04 16:08:38 +00:00
|
|
|
static int files_for_each_reflog_ent_reverse(struct ref_store *ref_store,
|
|
|
|
|
const char *refname,
|
|
|
|
|
each_reflog_ent_fn fn,
|
|
|
|
|
void *cb_data)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-03-26 02:42:22 +00:00
|
|
|
struct files_ref_store *refs =
|
2017-03-26 02:42:32 +00:00
|
|
|
files_downcast(ref_store, REF_STORE_READ,
|
|
|
|
|
"for_each_reflog_ent_reverse");
|
2015-11-09 13:34:01 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
|
FILE *logfp;
|
|
|
|
|
long pos;
|
|
|
|
|
int ret = 0, at_tail = 1;
|
|
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
files_reflog_path(refs, &sb, refname);
|
2017-03-26 02:42:20 +00:00
|
|
|
logfp = fopen(sb.buf, "r");
|
|
|
|
|
strbuf_release(&sb);
|
2015-11-09 13:34:01 +00:00
|
|
|
if (!logfp)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
/* Jump to the end */
|
|
|
|
|
if (fseek(logfp, 0, SEEK_END) < 0)
|
2017-04-16 16:55:46 +00:00
|
|
|
ret = error("cannot seek back reflog for %s: %s",
|
|
|
|
|
refname, strerror(errno));
|
2015-11-09 13:34:01 +00:00
|
|
|
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;
|
2017-04-16 16:55:46 +00:00
|
|
|
if (fseek(logfp, pos - cnt, SEEK_SET)) {
|
|
|
|
|
ret = error("cannot seek back reflog for %s: %s",
|
|
|
|
|
refname, strerror(errno));
|
|
|
|
|
break;
|
|
|
|
|
}
|
2015-11-09 13:34:01 +00:00
|
|
|
nread = fread(buf, cnt, 1, logfp);
|
2017-04-16 16:55:46 +00:00
|
|
|
if (nread != 1) {
|
|
|
|
|
ret = error("cannot read %d bytes from reflog for %s: %s",
|
|
|
|
|
cnt, refname, strerror(errno));
|
|
|
|
|
break;
|
|
|
|
|
}
|
2015-11-09 13:34:01 +00:00
|
|
|
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)
|
|
|
|
|
die("BUG: reverse reflog parser had leftover data");
|
|
|
|
|
|
|
|
|
|
fclose(logfp);
|
|
|
|
|
strbuf_release(&sb);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-04 16:08:38 +00:00
|
|
|
static int files_for_each_reflog_ent(struct ref_store *ref_store,
|
|
|
|
|
const char *refname,
|
|
|
|
|
each_reflog_ent_fn fn, void *cb_data)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2017-03-26 02:42:22 +00:00
|
|
|
struct files_ref_store *refs =
|
2017-03-26 02:42:32 +00:00
|
|
|
files_downcast(ref_store, REF_STORE_READ,
|
|
|
|
|
"for_each_reflog_ent");
|
2015-11-09 13:34:01 +00:00
|
|
|
FILE *logfp;
|
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
files_reflog_path(refs, &sb, refname);
|
2017-03-26 02:42:20 +00:00
|
|
|
logfp = fopen(sb.buf, "r");
|
|
|
|
|
strbuf_release(&sb);
|
2015-11-09 13:34:01 +00:00
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2016-06-18 04:15:19 +00:00
|
|
|
struct files_reflog_iterator {
|
|
|
|
|
struct ref_iterator base;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-03-26 02:42:36 +00:00
|
|
|
struct ref_store *ref_store;
|
2016-06-18 04:15:19 +00:00
|
|
|
struct dir_iterator *dir_iterator;
|
|
|
|
|
struct object_id oid;
|
|
|
|
|
};
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2016-06-18 04:15:19 +00:00
|
|
|
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))
|
2015-11-09 13:34:01 +00:00
|
|
|
continue;
|
2016-06-18 04:15:19 +00:00
|
|
|
if (diter->basename[0] == '.')
|
|
|
|
|
continue;
|
|
|
|
|
if (ends_with(diter->basename, ".lock"))
|
2015-11-09 13:34:01 +00:00
|
|
|
continue;
|
|
|
|
|
|
2017-03-26 02:42:36 +00:00
|
|
|
if (refs_read_ref_full(iter->ref_store,
|
|
|
|
|
diter->relative_path, 0,
|
|
|
|
|
iter->oid.hash, &flags)) {
|
2016-06-18 04:15:19 +00:00
|
|
|
error("bad ref for %s", diter->path.buf);
|
|
|
|
|
continue;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
2016-06-18 04:15:19 +00:00
|
|
|
|
|
|
|
|
iter->base.refname = diter->relative_path;
|
|
|
|
|
iter->base.oid = &iter->oid;
|
|
|
|
|
iter->base.flags = flags;
|
|
|
|
|
return ITER_OK;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
2016-06-18 04:15:19 +00:00
|
|
|
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
die("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
|
|
|
|
|
};
|
|
|
|
|
|
2016-09-04 16:08:38 +00:00
|
|
|
static struct ref_iterator *files_reflog_iterator_begin(struct ref_store *ref_store)
|
2016-06-18 04:15:19 +00:00
|
|
|
{
|
2017-03-26 02:42:22 +00:00
|
|
|
struct files_ref_store *refs =
|
2017-03-26 02:42:32 +00:00
|
|
|
files_downcast(ref_store, REF_STORE_READ,
|
|
|
|
|
"reflog_iterator_begin");
|
2016-06-18 04:15:19 +00:00
|
|
|
struct files_reflog_iterator *iter = xcalloc(1, sizeof(*iter));
|
|
|
|
|
struct ref_iterator *ref_iterator = &iter->base;
|
2017-03-26 02:42:20 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2016-06-18 04:15:19 +00:00
|
|
|
|
|
|
|
|
base_ref_iterator_init(ref_iterator, &files_reflog_iterator_vtable);
|
2017-03-26 02:42:22 +00:00
|
|
|
files_reflog_path(refs, &sb, NULL);
|
2017-03-26 02:42:20 +00:00
|
|
|
iter->dir_iterator = dir_iterator_begin(sb.buf);
|
2017-03-26 02:42:36 +00:00
|
|
|
iter->ref_store = ref_store;
|
2017-03-26 02:42:20 +00:00
|
|
|
strbuf_release(&sb);
|
2016-06-18 04:15:19 +00:00
|
|
|
return ref_iterator;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
2016-04-24 06:58:41 +00:00
|
|
|
/*
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
* 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_ISPRUNING) ||
|
|
|
|
|
(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 insertion is O(N) in the transaction
|
|
|
|
|
* size, but it happens at most once per transaction.
|
|
|
|
|
*/
|
|
|
|
|
item = string_list_insert(affected_refnames, "HEAD");
|
|
|
|
|
if (item->util) {
|
|
|
|
|
/* 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_NODEREF,
|
2017-05-06 22:10:23 +00:00
|
|
|
update->new_oid.hash, update->old_oid.hash,
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
update->msg);
|
|
|
|
|
|
|
|
|
|
item->util = new_update;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* update is for a symref that points at referent and doesn't have
|
|
|
|
|
* REF_NODEREF set. Split it into two updates:
|
|
|
|
|
* - The original update, but with REF_LOG_ONLY and REF_NODEREF 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.
|
|
|
|
|
*/
|
2016-09-04 16:08:35 +00:00
|
|
|
static int split_symref_update(struct files_ref_store *refs,
|
|
|
|
|
struct ref_update *update,
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
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 insertion is O(N) in the transaction
|
|
|
|
|
* size, but it happens at most once per symref in a
|
|
|
|
|
* transaction.
|
|
|
|
|
*/
|
|
|
|
|
item = string_list_insert(affected_refnames, referent);
|
|
|
|
|
if (item->util) {
|
|
|
|
|
/* An entry already existed */
|
|
|
|
|
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,
|
2017-05-06 22:10:23 +00:00
|
|
|
update->new_oid.hash, update->old_oid.hash,
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
update->msg);
|
|
|
|
|
|
2016-04-25 15:48:32 +00:00
|
|
|
new_update->parent_update = update;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Change the symbolic ref update to log only. Also, it
|
|
|
|
|
* doesn't need to check its old SHA-1 value, as that will be
|
|
|
|
|
* done when new_update is processed.
|
|
|
|
|
*/
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
update->flags |= REF_LOG_ONLY | REF_NODEREF;
|
2016-04-25 15:48:32 +00:00
|
|
|
update->flags &= ~REF_HAVE_OLD;
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
|
|
|
|
|
item->util = new_update;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-25 15:48:32 +00:00
|
|
|
/*
|
|
|
|
|
* 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;
|
|
|
|
|
}
|
|
|
|
|
|
2016-06-07 07:29:23 +00:00
|
|
|
/*
|
|
|
|
|
* 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) ||
|
2017-05-06 22:10:23 +00:00
|
|
|
!oidcmp(oid, &update->old_oid))
|
2016-06-07 07:29:23 +00:00
|
|
|
return 0;
|
|
|
|
|
|
2017-05-06 22:10:23 +00:00
|
|
|
if (is_null_oid(&update->old_oid))
|
2016-06-07 07:29:23 +00:00
|
|
|
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),
|
2017-05-06 22:10:23 +00:00
|
|
|
oid_to_hex(&update->old_oid));
|
2016-06-07 07:29:23 +00:00
|
|
|
else
|
|
|
|
|
strbuf_addf(err, "cannot lock ref '%s': "
|
|
|
|
|
"is at %s but expected %s",
|
|
|
|
|
original_update_refname(update),
|
|
|
|
|
oid_to_hex(oid),
|
2017-05-06 22:10:23 +00:00
|
|
|
oid_to_hex(&update->old_oid));
|
2016-06-07 07:29:23 +00:00
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
/*
|
|
|
|
|
* Prepare for carrying out update:
|
|
|
|
|
* - Lock the reference referred to by update.
|
|
|
|
|
* - Read the reference under lock.
|
|
|
|
|
* - Check that its old SHA-1 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_NODEREF, 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.
|
2016-04-24 06:58:41 +00:00
|
|
|
*/
|
2016-09-04 16:08:33 +00:00
|
|
|
static int lock_ref_for_update(struct files_ref_store *refs,
|
|
|
|
|
struct ref_update *update,
|
2016-04-24 06:58:41 +00:00
|
|
|
struct ref_transaction *transaction,
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
const char *head_ref,
|
2016-04-24 06:58:41 +00:00
|
|
|
struct string_list *affected_refnames,
|
|
|
|
|
struct strbuf *err)
|
|
|
|
|
{
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
struct strbuf referent = STRBUF_INIT;
|
|
|
|
|
int mustexist = (update->flags & REF_HAVE_OLD) &&
|
2017-05-06 22:10:23 +00:00
|
|
|
!is_null_oid(&update->old_oid);
|
2016-04-24 06:58:41 +00:00
|
|
|
int ret;
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
struct ref_lock *lock;
|
2016-04-24 06:58:41 +00:00
|
|
|
|
2017-02-10 11:16:16 +00:00
|
|
|
files_assert_main_repository(refs, "lock_ref_for_update");
|
2016-09-04 16:08:33 +00:00
|
|
|
|
2017-05-06 22:10:23 +00:00
|
|
|
if ((update->flags & REF_HAVE_NEW) && is_null_oid(&update->new_oid))
|
2016-04-24 06:58:41 +00:00
|
|
|
update->flags |= REF_DELETING;
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
|
|
|
|
|
if (head_ref) {
|
|
|
|
|
ret = split_head_update(update, transaction, head_ref,
|
|
|
|
|
affected_refnames, err);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-04 16:08:31 +00:00
|
|
|
ret = lock_raw_ref(refs, update->refname, mustexist,
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
affected_refnames, NULL,
|
2016-09-04 16:08:43 +00:00
|
|
|
&lock, &referent,
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
&update->type, err);
|
|
|
|
|
if (ret) {
|
2016-04-24 06:58:41 +00:00
|
|
|
char *reason;
|
|
|
|
|
|
|
|
|
|
reason = strbuf_detach(err, NULL);
|
|
|
|
|
strbuf_addf(err, "cannot lock ref '%s': %s",
|
2016-06-07 07:29:23 +00:00
|
|
|
original_update_refname(update), reason);
|
2016-04-24 06:58:41 +00:00
|
|
|
free(reason);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
|
2016-09-04 16:08:43 +00:00
|
|
|
update->backend_data = lock;
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
|
2016-04-25 15:38:35 +00:00
|
|
|
if (update->type & REF_ISSYMREF) {
|
2016-04-25 15:48:32 +00:00
|
|
|
if (update->flags & REF_NODEREF) {
|
|
|
|
|
/*
|
|
|
|
|
* 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_sha1:
|
|
|
|
|
*/
|
2017-03-26 02:42:36 +00:00
|
|
|
if (refs_read_ref_full(&refs->base,
|
|
|
|
|
referent.buf, 0,
|
|
|
|
|
lock->old_oid.hash, NULL)) {
|
2016-04-25 15:48:32 +00:00
|
|
|
if (update->flags & REF_HAVE_OLD) {
|
|
|
|
|
strbuf_addf(err, "cannot lock ref '%s': "
|
2016-06-07 07:29:23 +00:00
|
|
|
"error reading reference",
|
|
|
|
|
original_update_refname(update));
|
|
|
|
|
return -1;
|
2016-04-25 15:48:32 +00:00
|
|
|
}
|
2016-06-07 07:29:23 +00:00
|
|
|
} else if (check_old_oid(update, &lock->old_oid, err)) {
|
2016-04-25 15:38:35 +00:00
|
|
|
return TRANSACTION_GENERIC_ERROR;
|
|
|
|
|
}
|
2016-04-25 15:48:32 +00:00
|
|
|
} else {
|
|
|
|
|
/*
|
|
|
|
|
* Create a new update for the reference this
|
|
|
|
|
* symref is pointing at. Also, we will record
|
|
|
|
|
* and verify old_sha1 for this update as part
|
|
|
|
|
* of processing the split-off update, so we
|
|
|
|
|
* don't have to do it here.
|
|
|
|
|
*/
|
2016-09-04 16:08:35 +00:00
|
|
|
ret = split_symref_update(refs, update,
|
|
|
|
|
referent.buf, transaction,
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
affected_refnames, err);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2016-04-25 15:48:32 +00:00
|
|
|
} else {
|
|
|
|
|
struct ref_update *parent_update;
|
2016-04-25 15:38:35 +00:00
|
|
|
|
2016-06-07 07:29:23 +00:00
|
|
|
if (check_old_oid(update, &lock->old_oid, err))
|
|
|
|
|
return TRANSACTION_GENERIC_ERROR;
|
|
|
|
|
|
2016-04-25 15:48:32 +00:00
|
|
|
/*
|
|
|
|
|
* If this update is happening indirectly because of a
|
|
|
|
|
* symref update, record the old SHA-1 in the parent
|
|
|
|
|
* update:
|
|
|
|
|
*/
|
|
|
|
|
for (parent_update = update->parent_update;
|
|
|
|
|
parent_update;
|
|
|
|
|
parent_update = parent_update->parent_update) {
|
2016-09-04 16:08:43 +00:00
|
|
|
struct ref_lock *parent_lock = parent_update->backend_data;
|
|
|
|
|
oidcpy(&parent_lock->old_oid, &lock->old_oid);
|
2016-04-25 15:48:32 +00:00
|
|
|
}
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
}
|
|
|
|
|
|
2016-04-24 06:58:41 +00:00
|
|
|
if ((update->flags & REF_HAVE_NEW) &&
|
|
|
|
|
!(update->flags & REF_DELETING) &&
|
|
|
|
|
!(update->flags & REF_LOG_ONLY)) {
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
if (!(update->type & REF_ISSYMREF) &&
|
2017-05-06 22:10:23 +00:00
|
|
|
!oidcmp(&lock->old_oid, &update->new_oid)) {
|
2016-04-24 06:58:41 +00:00
|
|
|
/*
|
|
|
|
|
* The reference already has the desired
|
|
|
|
|
* value, so we don't need to write it.
|
|
|
|
|
*/
|
2017-05-06 22:10:24 +00:00
|
|
|
} else if (write_ref_to_lockfile(lock, &update->new_oid,
|
2016-04-24 06:58:41 +00:00
|
|
|
err)) {
|
|
|
|
|
char *write_err = strbuf_detach(err, NULL);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The lock was freed upon failure of
|
|
|
|
|
* write_ref_to_lockfile():
|
|
|
|
|
*/
|
2016-09-04 16:08:43 +00:00
|
|
|
update->backend_data = NULL;
|
2016-04-24 06:58:41 +00:00
|
|
|
strbuf_addf(err,
|
2016-06-07 07:29:23 +00:00
|
|
|
"cannot update ref '%s': %s",
|
2016-04-24 06:58:41 +00:00
|
|
|
update->refname, write_err);
|
|
|
|
|
free(write_err);
|
|
|
|
|
return TRANSACTION_GENERIC_ERROR;
|
|
|
|
|
} 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:
|
|
|
|
|
*/
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
if (close_ref(lock)) {
|
2016-04-24 06:58:41 +00:00
|
|
|
strbuf_addf(err, "couldn't close '%s.lock'",
|
|
|
|
|
update->refname);
|
|
|
|
|
return TRANSACTION_GENERIC_ERROR;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-22 14:17:42 +00:00
|
|
|
/*
|
|
|
|
|
* Unlock any references in `transaction` that are still locked, and
|
|
|
|
|
* mark the transaction closed.
|
|
|
|
|
*/
|
|
|
|
|
static void files_transaction_cleanup(struct ref_transaction *transaction)
|
|
|
|
|
{
|
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < transaction->nr; i++) {
|
|
|
|
|
struct ref_update *update = transaction->updates[i];
|
|
|
|
|
struct ref_lock *lock = update->backend_data;
|
|
|
|
|
|
|
|
|
|
if (lock) {
|
|
|
|
|
unlock_ref(lock);
|
|
|
|
|
update->backend_data = NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
transaction->state = REF_TRANSACTION_CLOSED;
|
|
|
|
|
}
|
|
|
|
|
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
static int files_transaction_prepare(struct ref_store *ref_store,
|
|
|
|
|
struct ref_transaction *transaction,
|
|
|
|
|
struct strbuf *err)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2016-09-04 16:08:11 +00:00
|
|
|
struct files_ref_store *refs =
|
2017-03-26 02:42:32 +00:00
|
|
|
files_downcast(ref_store, REF_STORE_WRITE,
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
"ref_transaction_prepare");
|
2017-05-22 14:17:37 +00:00
|
|
|
size_t i;
|
|
|
|
|
int ret = 0;
|
2015-11-09 13:34:01 +00:00
|
|
|
struct string_list affected_refnames = STRING_LIST_INIT_NODUP;
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
char *head_ref = NULL;
|
|
|
|
|
int head_type;
|
|
|
|
|
struct object_id head_oid;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
|
|
|
|
assert(err);
|
|
|
|
|
|
2017-05-22 14:17:42 +00:00
|
|
|
if (!transaction->nr)
|
|
|
|
|
goto cleanup;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
/*
|
|
|
|
|
* 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.)
|
|
|
|
|
*/
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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;
|
|
|
|
|
}
|
2015-11-09 13:34:01 +00:00
|
|
|
string_list_sort(&affected_refnames);
|
|
|
|
|
if (ref_update_reject_duplicates(&affected_refnames, err)) {
|
|
|
|
|
ret = TRANSACTION_GENERIC_ERROR;
|
|
|
|
|
goto cleanup;
|
|
|
|
|
}
|
|
|
|
|
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
/*
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
2017-03-26 02:42:36 +00:00
|
|
|
head_ref = refs_resolve_refdup(ref_store, "HEAD",
|
|
|
|
|
RESOLVE_REF_NO_RECURSE,
|
|
|
|
|
head_oid.hash, &head_type);
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
|
|
|
|
|
if (head_ref && !(head_type & REF_ISSYMREF)) {
|
|
|
|
|
free(head_ref);
|
|
|
|
|
head_ref = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-09 13:34:01 +00:00
|
|
|
/*
|
|
|
|
|
* 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.
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
* Note that lock_ref_for_update() might append more updates
|
|
|
|
|
* to the transaction.
|
2015-11-09 13:34:01 +00:00
|
|
|
*/
|
2016-04-21 22:02:50 +00:00
|
|
|
for (i = 0; i < transaction->nr; i++) {
|
|
|
|
|
struct ref_update *update = transaction->updates[i];
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2016-09-04 16:08:33 +00:00
|
|
|
ret = lock_ref_for_update(refs, update, transaction,
|
|
|
|
|
head_ref, &affected_refnames, err);
|
2016-04-24 06:58:41 +00:00
|
|
|
if (ret)
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
|
free(head_ref);
|
|
|
|
|
string_list_clear(&affected_refnames, 0);
|
|
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
|
files_transaction_cleanup(transaction);
|
|
|
|
|
else
|
|
|
|
|
transaction->state = REF_TRANSACTION_PREPARED;
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int files_transaction_finish(struct ref_store *ref_store,
|
|
|
|
|
struct ref_transaction *transaction,
|
|
|
|
|
struct strbuf *err)
|
|
|
|
|
{
|
|
|
|
|
struct files_ref_store *refs =
|
|
|
|
|
files_downcast(ref_store, 0, "ref_transaction_finish");
|
|
|
|
|
size_t i;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
struct string_list refs_to_delete = STRING_LIST_INIT_NODUP;
|
|
|
|
|
struct string_list_item *ref_to_delete;
|
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
|
|
|
|
|
|
assert(err);
|
|
|
|
|
|
|
|
|
|
if (!transaction->nr) {
|
|
|
|
|
transaction->state = REF_TRANSACTION_CLOSED;
|
|
|
|
|
return 0;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Perform updates first so live commits remain referenced */
|
2016-04-21 22:02:50 +00:00
|
|
|
for (i = 0; i < transaction->nr; i++) {
|
|
|
|
|
struct ref_update *update = transaction->updates[i];
|
2016-09-04 16:08:43 +00:00
|
|
|
struct ref_lock *lock = update->backend_data;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2016-02-24 22:58:50 +00:00
|
|
|
if (update->flags & REF_NEEDS_COMMIT ||
|
|
|
|
|
update->flags & REF_LOG_ONLY) {
|
2017-03-26 02:42:22 +00:00
|
|
|
if (files_log_ref_write(refs,
|
|
|
|
|
lock->ref_name,
|
2017-05-06 22:10:24 +00:00
|
|
|
&lock->old_oid,
|
|
|
|
|
&update->new_oid,
|
2017-01-06 16:22:31 +00:00
|
|
|
update->msg, update->flags,
|
|
|
|
|
err)) {
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
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);
|
2016-09-04 16:08:43 +00:00
|
|
|
update->backend_data = NULL;
|
2015-11-09 13:34:01 +00:00
|
|
|
ret = TRANSACTION_GENERIC_ERROR;
|
|
|
|
|
goto cleanup;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (update->flags & REF_NEEDS_COMMIT) {
|
2016-09-04 16:08:11 +00:00
|
|
|
clear_loose_ref_cache(refs);
|
refs: resolve symbolic refs first
Before committing ref updates, split symbolic ref updates into two
parts: an update to the underlying ref, and a log-only update to the
symbolic ref. This ensures that both references are locked correctly
during the transaction, including while their reflogs are updated.
Similarly, if the reference pointed to by HEAD is modified directly, add
a separate log-only update to HEAD, rather than leaving the job of
updating HEAD's reflog to commit_ref_update(). This change ensures that
HEAD is locked correctly while its reflog is being modified, as well as
being cheaper (HEAD only needs to be resolved once).
This makes use of a new function, lock_raw_ref(), which is analogous to
read_raw_ref(), but acquires a lock on the reference before reading it.
This change still has two problems:
* There are redundant read_ref_full() reference lookups.
* It is still possible to get incorrect reflogs for symbolic references
if there is a concurrent update by another process, since the old_oid
of a symref is determined before the lock on the pointed-to ref is
held.
Both problems will soon be fixed.
Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
WIP
2016-04-25 13:56:07 +00:00
|
|
|
if (commit_ref(lock)) {
|
|
|
|
|
strbuf_addf(err, "couldn't set '%s'", lock->ref_name);
|
|
|
|
|
unlock_ref(lock);
|
2016-09-04 16:08:43 +00:00
|
|
|
update->backend_data = NULL;
|
2015-11-09 13:34:01 +00:00
|
|
|
ret = TRANSACTION_GENERIC_ERROR;
|
|
|
|
|
goto cleanup;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/* Perform deletes now that updates are safely completed */
|
2016-04-21 22:02:50 +00:00
|
|
|
for (i = 0; i < transaction->nr; i++) {
|
|
|
|
|
struct ref_update *update = transaction->updates[i];
|
2016-09-04 16:08:43 +00:00
|
|
|
struct ref_lock *lock = update->backend_data;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2016-02-24 22:58:50 +00:00
|
|
|
if (update->flags & REF_DELETING &&
|
|
|
|
|
!(update->flags & REF_LOG_ONLY)) {
|
2017-01-06 16:22:39 +00:00
|
|
|
if (!(update->type & REF_ISPACKED) ||
|
|
|
|
|
update->type & REF_ISSYMREF) {
|
|
|
|
|
/* It is a loose reference. */
|
2017-03-26 02:42:20 +00:00
|
|
|
strbuf_reset(&sb);
|
2017-03-26 02:42:23 +00:00
|
|
|
files_ref_path(refs, &sb, lock->ref_name);
|
2017-03-26 02:42:20 +00:00
|
|
|
if (unlink_or_msg(sb.buf, err)) {
|
2017-01-06 16:22:39 +00:00
|
|
|
ret = TRANSACTION_GENERIC_ERROR;
|
|
|
|
|
goto cleanup;
|
|
|
|
|
}
|
2017-01-06 16:22:43 +00:00
|
|
|
update->flags |= REF_DELETED_LOOSE;
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!(update->flags & REF_ISPRUNING))
|
|
|
|
|
string_list_append(&refs_to_delete,
|
2016-09-04 16:08:43 +00:00
|
|
|
lock->ref_name);
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-04 16:08:30 +00:00
|
|
|
if (repack_without_refs(refs, &refs_to_delete, err)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
ret = TRANSACTION_GENERIC_ERROR;
|
|
|
|
|
goto cleanup;
|
|
|
|
|
}
|
2017-01-06 16:22:43 +00:00
|
|
|
|
|
|
|
|
/* Delete the reflogs of any references that were deleted: */
|
|
|
|
|
for_each_string_list_item(ref_to_delete, &refs_to_delete) {
|
2017-03-26 02:42:20 +00:00
|
|
|
strbuf_reset(&sb);
|
2017-03-26 02:42:22 +00:00
|
|
|
files_reflog_path(refs, &sb, ref_to_delete->string);
|
2017-03-26 02:42:20 +00:00
|
|
|
if (!unlink_or_warn(sb.buf))
|
2017-03-26 02:42:22 +00:00
|
|
|
try_remove_empty_parents(refs, ref_to_delete->string,
|
2017-01-06 16:22:43 +00:00
|
|
|
REMOVE_EMPTY_PARENTS_REFLOG);
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-04 16:08:11 +00:00
|
|
|
clear_loose_ref_cache(refs);
|
2015-11-09 13:34:01 +00:00
|
|
|
|
|
|
|
|
cleanup:
|
2017-05-22 14:17:42 +00:00
|
|
|
files_transaction_cleanup(transaction);
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-01-06 16:22:43 +00:00
|
|
|
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.)
|
|
|
|
|
*/
|
2017-03-26 02:42:22 +00:00
|
|
|
try_remove_empty_parents(refs, update->refname,
|
2017-01-06 16:22:43 +00:00
|
|
|
REMOVE_EMPTY_PARENTS_REF);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
strbuf_release(&sb);
|
2015-11-09 13:34:01 +00:00
|
|
|
string_list_clear(&refs_to_delete, 0);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
static int files_transaction_abort(struct ref_store *ref_store,
|
|
|
|
|
struct ref_transaction *transaction,
|
|
|
|
|
struct strbuf *err)
|
|
|
|
|
{
|
|
|
|
|
files_transaction_cleanup(transaction);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-09 13:34:01 +00:00
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-04 16:08:39 +00:00
|
|
|
static int files_initial_transaction_commit(struct ref_store *ref_store,
|
|
|
|
|
struct ref_transaction *transaction,
|
|
|
|
|
struct strbuf *err)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2016-09-04 16:08:12 +00:00
|
|
|
struct files_ref_store *refs =
|
2017-03-26 02:42:32 +00:00
|
|
|
files_downcast(ref_store, REF_STORE_WRITE,
|
|
|
|
|
"initial_ref_transaction_commit");
|
2017-05-22 14:17:37 +00:00
|
|
|
size_t i;
|
|
|
|
|
int ret = 0;
|
2015-11-09 13:34:01 +00:00
|
|
|
struct string_list affected_refnames = STRING_LIST_INIT_NODUP;
|
|
|
|
|
|
|
|
|
|
assert(err);
|
|
|
|
|
|
|
|
|
|
if (transaction->state != REF_TRANSACTION_OPEN)
|
|
|
|
|
die("BUG: commit called for transaction that is not open");
|
|
|
|
|
|
|
|
|
|
/* Fail if a refname appears more than once in the transaction: */
|
2016-04-21 22:02:50 +00:00
|
|
|
for (i = 0; i < transaction->nr; i++)
|
|
|
|
|
string_list_append(&affected_refnames,
|
|
|
|
|
transaction->updates[i]->refname);
|
2015-11-09 13:34:01 +00:00
|
|
|
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.
|
|
|
|
|
*/
|
2017-03-26 02:42:36 +00:00
|
|
|
if (refs_for_each_rawref(&refs->base, ref_present,
|
|
|
|
|
&affected_refnames))
|
2015-11-09 13:34:01 +00:00
|
|
|
die("BUG: initial ref transaction called with existing refs");
|
|
|
|
|
|
2016-04-21 22:02:50 +00:00
|
|
|
for (i = 0; i < transaction->nr; i++) {
|
|
|
|
|
struct ref_update *update = transaction->updates[i];
|
2015-11-09 13:34:01 +00:00
|
|
|
|
|
|
|
|
if ((update->flags & REF_HAVE_OLD) &&
|
2017-05-06 22:10:23 +00:00
|
|
|
!is_null_oid(&update->old_oid))
|
2015-11-09 13:34:01 +00:00
|
|
|
die("BUG: initial ref transaction with old_sha1 set");
|
2017-03-26 02:42:34 +00:00
|
|
|
if (refs_verify_refname_available(&refs->base, update->refname,
|
|
|
|
|
&affected_refnames, NULL,
|
|
|
|
|
err)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
ret = TRANSACTION_NAME_CONFLICT;
|
|
|
|
|
goto cleanup;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-23 07:01:29 +00:00
|
|
|
if (lock_packed_refs(refs->packed_ref_store, 0)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
strbuf_addf(err, "unable to lock packed-refs file: %s",
|
|
|
|
|
strerror(errno));
|
|
|
|
|
ret = TRANSACTION_GENERIC_ERROR;
|
|
|
|
|
goto cleanup;
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-21 22:02:50 +00:00
|
|
|
for (i = 0; i < transaction->nr; i++) {
|
|
|
|
|
struct ref_update *update = transaction->updates[i];
|
2015-11-09 13:34:01 +00:00
|
|
|
|
|
|
|
|
if ((update->flags & REF_HAVE_NEW) &&
|
2017-05-06 22:10:23 +00:00
|
|
|
!is_null_oid(&update->new_oid))
|
2017-06-23 07:01:28 +00:00
|
|
|
add_packed_ref(refs->packed_ref_store, update->refname,
|
2017-05-06 22:10:24 +00:00
|
|
|
&update->new_oid);
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
|
2017-06-23 07:01:30 +00:00
|
|
|
if (commit_packed_refs(refs->packed_ref_store)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
strbuf_addf(err, "unable to commit packed-refs file: %s",
|
|
|
|
|
strerror(errno));
|
|
|
|
|
ret = TRANSACTION_GENERIC_ERROR;
|
|
|
|
|
goto cleanup;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
|
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;
|
2017-02-21 23:47:32 +00:00
|
|
|
struct object_id last_kept_oid;
|
2015-11-09 13:34:01 +00:00
|
|
|
};
|
|
|
|
|
|
2017-02-21 23:47:32 +00:00
|
|
|
static int expire_reflog_ent(struct object_id *ooid, struct object_id *noid,
|
2017-04-26 19:29:31 +00:00
|
|
|
const char *email, timestamp_t timestamp, int tz,
|
2015-11-09 13:34:01 +00:00
|
|
|
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)
|
2017-02-21 23:47:32 +00:00
|
|
|
ooid = &cb->last_kept_oid;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
2017-05-06 22:10:00 +00:00
|
|
|
if ((*cb->should_prune_fn)(ooid, noid, email, timestamp, tz,
|
2015-11-09 13:34:01 +00:00
|
|
|
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) {
|
2017-04-21 10:45:48 +00:00
|
|
|
fprintf(cb->newlog, "%s %s %s %"PRItime" %+05d\t%s",
|
2017-02-21 23:47:32 +00:00
|
|
|
oid_to_hex(ooid), oid_to_hex(noid),
|
2015-11-09 13:34:01 +00:00
|
|
|
email, timestamp, tz, message);
|
2017-02-21 23:47:32 +00:00
|
|
|
oidcpy(&cb->last_kept_oid, noid);
|
2015-11-09 13:34:01 +00:00
|
|
|
}
|
|
|
|
|
if (cb->flags & EXPIRE_REFLOGS_VERBOSE)
|
|
|
|
|
printf("keep %s", message);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-04 16:08:38 +00:00
|
|
|
static int files_reflog_expire(struct ref_store *ref_store,
|
|
|
|
|
const char *refname, const unsigned char *sha1,
|
|
|
|
|
unsigned int flags,
|
|
|
|
|
reflog_expiry_prepare_fn prepare_fn,
|
|
|
|
|
reflog_expiry_should_prune_fn should_prune_fn,
|
|
|
|
|
reflog_expiry_cleanup_fn cleanup_fn,
|
|
|
|
|
void *policy_cb_data)
|
2015-11-09 13:34:01 +00:00
|
|
|
{
|
2016-09-04 16:08:34 +00:00
|
|
|
struct files_ref_store *refs =
|
2017-03-26 02:42:32 +00:00
|
|
|
files_downcast(ref_store, REF_STORE_WRITE, "reflog_expire");
|
2015-11-09 13:34:01 +00:00
|
|
|
static struct lock_file reflog_lock;
|
|
|
|
|
struct expire_reflog_cb cb;
|
|
|
|
|
struct ref_lock *lock;
|
2017-03-26 02:42:22 +00:00
|
|
|
struct strbuf log_file_sb = STRBUF_INIT;
|
2015-11-09 13:34:01 +00:00
|
|
|
char *log_file;
|
|
|
|
|
int status = 0;
|
|
|
|
|
int type;
|
|
|
|
|
struct strbuf err = STRBUF_INIT;
|
2017-05-06 22:10:00 +00:00
|
|
|
struct object_id oid;
|
2015-11-09 13:34:01 +00:00
|
|
|
|
|
|
|
|
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:
|
|
|
|
|
*/
|
2016-09-04 16:08:34 +00:00
|
|
|
lock = lock_ref_sha1_basic(refs, refname, sha1,
|
|
|
|
|
NULL, NULL, REF_NODEREF,
|
2016-04-07 19:03:11 +00:00
|
|
|
&type, &err);
|
2015-11-09 13:34:01 +00:00
|
|
|
if (!lock) {
|
|
|
|
|
error("cannot lock ref '%s': %s", refname, err.buf);
|
|
|
|
|
strbuf_release(&err);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2017-03-26 02:42:36 +00:00
|
|
|
if (!refs_reflog_exists(ref_store, refname)) {
|
2015-11-09 13:34:01 +00:00
|
|
|
unlock_ref(lock);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-26 02:42:22 +00:00
|
|
|
files_reflog_path(refs, &log_file_sb, refname);
|
|
|
|
|
log_file = strbuf_detach(&log_file_sb, NULL);
|
2015-11-09 13:34:01 +00:00
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-06 22:10:00 +00:00
|
|
|
hashcpy(oid.hash, sha1);
|
|
|
|
|
|
|
|
|
|
(*prepare_fn)(refname, &oid, cb.policy_cb);
|
2017-03-26 02:42:36 +00:00
|
|
|
refs_for_each_reflog_ent(ref_store, refname, expire_reflog_ent, &cb);
|
2015-11-09 13:34:01 +00:00
|
|
|
(*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) &&
|
2017-02-21 23:47:32 +00:00
|
|
|
!is_null_oid(&cb.last_kept_oid);
|
2015-11-09 13:34:01 +00:00
|
|
|
|
|
|
|
|
if (close_lock_file(&reflog_lock)) {
|
|
|
|
|
status |= error("couldn't write %s: %s", log_file,
|
|
|
|
|
strerror(errno));
|
|
|
|
|
} else if (update &&
|
|
|
|
|
(write_in_full(get_lock_file_fd(lock->lk),
|
2017-02-21 23:47:32 +00:00
|
|
|
oid_to_hex(&cb.last_kept_oid), GIT_SHA1_HEXSZ) != GIT_SHA1_HEXSZ ||
|
2015-11-09 13:34:01 +00:00
|
|
|
write_str_in_full(get_lock_file_fd(lock->lk), "\n") != 1 ||
|
|
|
|
|
close_ref(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)) {
|
2015-12-11 18:40:54 +00:00
|
|
|
status |= error("unable to write reflog '%s' (%s)",
|
2015-11-09 13:34:01 +00:00
|
|
|
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;
|
|
|
|
|
}
|
2016-09-04 16:08:10 +00:00
|
|
|
|
2016-09-04 16:08:41 +00:00
|
|
|
static int files_init_db(struct ref_store *ref_store, struct strbuf *err)
|
|
|
|
|
{
|
2017-03-26 02:42:23 +00:00
|
|
|
struct files_ref_store *refs =
|
2017-03-26 02:42:32 +00:00
|
|
|
files_downcast(ref_store, REF_STORE_WRITE, "init_db");
|
2017-03-26 02:42:20 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
|
|
2016-09-04 16:08:41 +00:00
|
|
|
/*
|
|
|
|
|
* Create .git/refs/{heads,tags}
|
|
|
|
|
*/
|
2017-03-26 02:42:23 +00:00
|
|
|
files_ref_path(refs, &sb, "refs/heads");
|
2017-03-26 02:42:20 +00:00
|
|
|
safe_create_dir(sb.buf, 1);
|
|
|
|
|
|
|
|
|
|
strbuf_reset(&sb);
|
2017-03-26 02:42:23 +00:00
|
|
|
files_ref_path(refs, &sb, "refs/tags");
|
2017-03-26 02:42:20 +00:00
|
|
|
safe_create_dir(sb.buf, 1);
|
|
|
|
|
|
|
|
|
|
strbuf_release(&sb);
|
2016-09-04 16:08:41 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-04 16:08:10 +00:00
|
|
|
struct ref_storage_be refs_be_files = {
|
|
|
|
|
NULL,
|
2016-09-04 16:08:11 +00:00
|
|
|
"files",
|
2016-09-04 16:08:16 +00:00
|
|
|
files_ref_store_create,
|
2016-09-04 16:08:41 +00:00
|
|
|
files_init_db,
|
ref_transaction_prepare(): new optional step for reference updates
In the future, compound reference stores will sometimes need to modify
references in two different reference stores at the same time, meaning
that a single logical reference transaction might have to be
implemented as two internal sub-transactions. They won't want to call
`ref_transaction_commit()` for the two sub-transactions one after the
other, because that wouldn't be atomic (the first commit could succeed
and the second one fail). Instead, they will want to prepare both
sub-transactions (i.e., obtain any necessary locks and do any
pre-checks), and only if both prepare steps succeed, then commit both
sub-transactions.
Start preparing for that day by adding a new, optional
`ref_transaction_prepare()` step to the reference transaction
sequence, which obtains the locks and does any prechecks, reporting
any errors that occur. Also add a `ref_transaction_abort()` function
that can be used to abort a sub-transaction even if it has already
been prepared.
That is on the side of the public-facing API. On the side of the
`ref_store` VTABLE, get rid of `transaction_commit` and instead add
methods `transaction_prepare`, `transaction_finish`, and
`transaction_abort`. A `ref_transaction_commit()` now basically calls
methods `transaction_prepare` then `transaction_finish`.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:44 +00:00
|
|
|
files_transaction_prepare,
|
|
|
|
|
files_transaction_finish,
|
|
|
|
|
files_transaction_abort,
|
2016-09-04 16:08:39 +00:00
|
|
|
files_initial_transaction_commit,
|
2016-09-04 16:08:25 +00:00
|
|
|
|
2016-09-04 16:08:27 +00:00
|
|
|
files_pack_refs,
|
2016-09-04 16:08:29 +00:00
|
|
|
files_peel_ref,
|
2016-09-04 16:08:28 +00:00
|
|
|
files_create_symref,
|
2016-09-04 16:08:40 +00:00
|
|
|
files_delete_refs,
|
2016-09-04 16:08:42 +00:00
|
|
|
files_rename_ref,
|
2016-09-04 16:08:27 +00:00
|
|
|
|
2016-09-04 16:08:37 +00:00
|
|
|
files_ref_iterator_begin,
|
2016-09-04 16:08:26 +00:00
|
|
|
files_read_raw_ref,
|
2016-09-04 16:08:38 +00:00
|
|
|
|
|
|
|
|
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
|
2016-09-04 16:08:10 +00:00
|
|
|
};
|