2023-03-21 06:25:53 +00:00
|
|
|
#include "../cache.h"
|
2023-02-24 00:09:24 +00:00
|
|
|
#include "../alloc.h"
|
2017-08-22 17:29:16 +00:00
|
|
|
#include "../config.h"
|
2023-03-21 06:25:54 +00:00
|
|
|
#include "../gettext.h"
|
2023-02-24 00:09:27 +00:00
|
|
|
#include "../hex.h"
|
2017-06-23 07:01:37 +00:00
|
|
|
#include "../refs.h"
|
|
|
|
#include "refs-internal.h"
|
|
|
|
#include "packed-backend.h"
|
|
|
|
#include "../iterator.h"
|
|
|
|
#include "../lockfile.h"
|
2018-03-30 18:35:12 +00:00
|
|
|
#include "../chdir-notify.h"
|
2023-04-11 07:42:02 +00:00
|
|
|
#include "../wrapper.h"
|
2023-03-21 06:26:07 +00:00
|
|
|
#include "../write-or-die.h"
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-25 08:00:10 +00:00
|
|
|
enum mmap_strategy {
|
|
|
|
/*
|
|
|
|
* Don't use mmap() at all for reading `packed-refs`.
|
|
|
|
*/
|
|
|
|
MMAP_NONE,
|
2017-06-23 07:01:37 +00:00
|
|
|
|
|
|
|
/*
|
2017-09-25 08:00:10 +00:00
|
|
|
* Can use mmap() for reading `packed-refs`, but the file must
|
|
|
|
* not remain mmapped. This is the usual option on Windows,
|
|
|
|
* where you cannot rename a new version of a file onto a file
|
|
|
|
* that is currently mmapped.
|
2017-06-23 07:01:37 +00:00
|
|
|
*/
|
2017-09-25 08:00:10 +00:00
|
|
|
MMAP_TEMPORARY,
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-25 08:00:10 +00:00
|
|
|
/*
|
|
|
|
* It is OK to leave the `packed-refs` file mmapped while
|
|
|
|
* arbitrary other code is running.
|
|
|
|
*/
|
|
|
|
MMAP_OK
|
2017-06-23 07:01:37 +00:00
|
|
|
};
|
|
|
|
|
2017-09-25 08:00:10 +00:00
|
|
|
#if defined(NO_MMAP)
|
|
|
|
static enum mmap_strategy mmap_strategy = MMAP_NONE;
|
|
|
|
#elif defined(MMAP_PREVENTS_DELETE)
|
|
|
|
static enum mmap_strategy mmap_strategy = MMAP_TEMPORARY;
|
|
|
|
#else
|
|
|
|
static enum mmap_strategy mmap_strategy = MMAP_OK;
|
|
|
|
#endif
|
|
|
|
|
2017-09-13 17:15:57 +00:00
|
|
|
struct packed_ref_store;
|
2017-06-23 07:01:37 +00:00
|
|
|
|
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* A `snapshot` represents one snapshot of a `packed-refs` file.
|
|
|
|
*
|
|
|
|
* Normally, this will be a mmapped view of the contents of the
|
|
|
|
* `packed-refs` file at the time the snapshot was created. However,
|
|
|
|
* if the `packed-refs` file was not sorted, this might point at heap
|
|
|
|
* memory holding the contents of the `packed-refs` file with its
|
|
|
|
* records sorted by refname.
|
|
|
|
*
|
|
|
|
* `snapshot` instances are reference counted (via
|
|
|
|
* `acquire_snapshot()` and `release_snapshot()`). This is to prevent
|
|
|
|
* an instance from disappearing while an iterator is still iterating
|
|
|
|
* over it. Instances are garbage collected when their `referrers`
|
|
|
|
* count goes to zero.
|
|
|
|
*
|
|
|
|
* The most recent `snapshot`, if available, is referenced by the
|
|
|
|
* `packed_ref_store`. Its freshness is checked whenever
|
|
|
|
* `get_snapshot()` is called; if the existing snapshot is obsolete, a
|
|
|
|
* new snapshot is taken.
|
2017-06-23 07:01:37 +00:00
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
struct snapshot {
|
2017-09-13 17:15:57 +00:00
|
|
|
/*
|
|
|
|
* A back-pointer to the packed_ref_store with which this
|
2017-09-25 08:00:18 +00:00
|
|
|
* snapshot is associated:
|
2017-09-13 17:15:57 +00:00
|
|
|
*/
|
|
|
|
struct packed_ref_store *refs;
|
|
|
|
|
2017-09-25 08:00:10 +00:00
|
|
|
/* Is the `packed-refs` file currently mmapped? */
|
|
|
|
int mmapped;
|
|
|
|
|
|
|
|
/*
|
2018-01-24 11:14:11 +00:00
|
|
|
* The contents of the `packed-refs` file:
|
|
|
|
*
|
|
|
|
* - buf -- a pointer to the start of the memory
|
|
|
|
* - start -- a pointer to the first byte of actual references
|
|
|
|
* (i.e., after the header line, if one is present)
|
|
|
|
* - eof -- a pointer just past the end of the reference
|
|
|
|
* contents
|
|
|
|
*
|
|
|
|
* If the `packed-refs` file was already sorted, `buf` points
|
|
|
|
* at the mmapped contents of the file. If not, it points at
|
|
|
|
* heap-allocated memory containing the contents, sorted. If
|
|
|
|
* there were no contents (e.g., because the file didn't
|
|
|
|
* exist), `buf`, `start`, and `eof` are all NULL.
|
2017-09-25 08:00:10 +00:00
|
|
|
*/
|
2018-01-24 11:14:11 +00:00
|
|
|
char *buf, *start, *eof;
|
2017-09-25 08:00:10 +00:00
|
|
|
|
2017-09-25 08:00:06 +00:00
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* What is the peeled state of the `packed-refs` file that
|
|
|
|
* this snapshot represents? (This is usually determined from
|
|
|
|
* the file's header.)
|
2017-09-25 08:00:06 +00:00
|
|
|
*/
|
|
|
|
enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled;
|
|
|
|
|
2017-06-23 07:01:37 +00:00
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* Count of references to this instance, including the pointer
|
|
|
|
* from `packed_ref_store::snapshot`, if any. The instance
|
|
|
|
* will not be freed as long as the reference count is
|
|
|
|
* nonzero.
|
2017-06-23 07:01:37 +00:00
|
|
|
*/
|
|
|
|
unsigned int referrers;
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
/*
|
|
|
|
* The metadata of the `packed-refs` file from which this
|
|
|
|
* snapshot was created, used to tell if the file has been
|
|
|
|
* replaced since we read it.
|
|
|
|
*/
|
2017-06-23 07:01:37 +00:00
|
|
|
struct stat_validity validity;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* A `ref_store` representing references stored in a `packed-refs`
|
|
|
|
* file. It implements the `ref_store` interface, though it has some
|
|
|
|
* limitations:
|
|
|
|
*
|
|
|
|
* - It cannot store symbolic references.
|
|
|
|
*
|
|
|
|
* - It cannot store reflogs.
|
|
|
|
*
|
|
|
|
* - It does not support reference renaming (though it could).
|
|
|
|
*
|
|
|
|
* On the other hand, it can be locked outside of a reference
|
|
|
|
* transaction. In that case, it remains locked even after the
|
|
|
|
* transaction is done and the new `packed-refs` file is activated.
|
2017-06-23 07:01:37 +00:00
|
|
|
*/
|
|
|
|
struct packed_ref_store {
|
2017-06-23 07:01:38 +00:00
|
|
|
struct ref_store base;
|
|
|
|
|
2017-06-23 07:01:37 +00:00
|
|
|
unsigned int store_flags;
|
|
|
|
|
|
|
|
/* The path of the "packed-refs" file: */
|
|
|
|
char *path;
|
|
|
|
|
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* A snapshot of the values read from the `packed-refs` file,
|
|
|
|
* if it might still be current; otherwise, NULL.
|
2017-06-23 07:01:37 +00:00
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
struct snapshot *snapshot;
|
2017-06-23 07:01:37 +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:40 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Temporary file used when rewriting new contents to the
|
|
|
|
* "packed-refs" file. Note that this (and thus the enclosing
|
|
|
|
* `packed_ref_store`) must not be freed.
|
|
|
|
*/
|
tempfile: auto-allocate tempfiles on heap
The previous commit taught the tempfile code to give up
ownership over tempfiles that have been renamed or deleted.
That makes it possible to use a stack variable like this:
struct tempfile t;
create_tempfile(&t, ...);
...
if (!err)
rename_tempfile(&t, ...);
else
delete_tempfile(&t);
But doing it this way has a high potential for creating
memory errors. The tempfile we pass to create_tempfile()
ends up on a global linked list, and it's not safe for it to
go out of scope until we've called one of those two
deactivation functions.
Imagine that we add an early return from the function that
forgets to call delete_tempfile(). With a static or heap
tempfile variable, the worst case is that the tempfile hangs
around until the program exits (and some functions like
setup_shallow_temporary rely on this intentionally, creating
a tempfile and then leaving it for later cleanup).
But with a stack variable as above, this is a serious memory
error: the variable goes out of scope and may be filled with
garbage by the time the tempfile code looks at it. Let's
see if we can make it harder to get this wrong.
Since many callers need to allocate arbitrary numbers of
tempfiles, we can't rely on static storage as a general
solution. So we need to turn to the heap. We could just ask
all callers to pass us a heap variable, but that puts the
burden on them to call free() at the right time.
Instead, let's have the tempfile code handle the heap
allocation _and_ the deallocation (when the tempfile is
deactivated and removed from the list).
This changes the return value of all of the creation
functions. For the cleanup functions (delete and rename),
we'll add one extra bit of safety: instead of taking a
tempfile pointer, we'll take a pointer-to-pointer and set it
to NULL after freeing the object. This makes it safe to
double-call functions like delete_tempfile(), as the second
call treats the NULL input as a noop. Several callsites
follow this pattern.
The resulting patch does have a fair bit of noise, as each
caller needs to be converted to handle:
1. Storing a pointer instead of the struct itself.
2. Passing the pointer instead of taking the struct
address.
3. Handling a "struct tempfile *" return instead of a file
descriptor.
We could play games to make this less noisy. For example, by
defining the tempfile like this:
struct tempfile {
struct heap_allocated_part_of_tempfile {
int fd;
...etc
} *actual_data;
}
Callers would continue to have a "struct tempfile", and it
would be "active" only when the inner pointer was non-NULL.
But that just makes things more awkward in the long run.
There aren't that many callers, so we can simply bite
the bullet and adjust all of them. And the compiler makes it
easy for us to find them all.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-05 12:15:08 +00:00
|
|
|
struct tempfile *tempfile;
|
2017-06-23 07:01:37 +00:00
|
|
|
};
|
|
|
|
|
2017-09-25 08:00:09 +00:00
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* Increment the reference count of `*snapshot`.
|
2017-09-25 08:00:09 +00:00
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
static void acquire_snapshot(struct snapshot *snapshot)
|
2017-09-25 08:00:09 +00:00
|
|
|
{
|
2017-09-25 08:00:18 +00:00
|
|
|
snapshot->referrers++;
|
2017-09-25 08:00:09 +00:00
|
|
|
}
|
|
|
|
|
2017-09-25 08:00:10 +00:00
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* If the buffer in `snapshot` is active, then either munmap the
|
2017-09-25 08:00:10 +00:00
|
|
|
* memory and close the file, or free the memory. Then set the buffer
|
|
|
|
* pointers to NULL.
|
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
static void clear_snapshot_buffer(struct snapshot *snapshot)
|
2017-09-25 08:00:10 +00:00
|
|
|
{
|
2017-09-25 08:00:18 +00:00
|
|
|
if (snapshot->mmapped) {
|
|
|
|
if (munmap(snapshot->buf, snapshot->eof - snapshot->buf))
|
2017-09-25 08:00:10 +00:00
|
|
|
die_errno("error ummapping packed-refs file %s",
|
2017-09-25 08:00:18 +00:00
|
|
|
snapshot->refs->path);
|
|
|
|
snapshot->mmapped = 0;
|
2017-09-25 08:00:10 +00:00
|
|
|
} else {
|
2017-09-25 08:00:18 +00:00
|
|
|
free(snapshot->buf);
|
2017-09-25 08:00:10 +00:00
|
|
|
}
|
2018-01-24 11:14:11 +00:00
|
|
|
snapshot->buf = snapshot->start = snapshot->eof = NULL;
|
2017-09-25 08:00:10 +00:00
|
|
|
}
|
|
|
|
|
2017-09-25 08:00:09 +00:00
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* Decrease the reference count of `*snapshot`. If it goes to zero,
|
|
|
|
* free `*snapshot` and return true; otherwise return false.
|
2017-09-25 08:00:09 +00:00
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
static int release_snapshot(struct snapshot *snapshot)
|
2017-09-25 08:00:09 +00:00
|
|
|
{
|
2017-09-25 08:00:18 +00:00
|
|
|
if (!--snapshot->referrers) {
|
|
|
|
stat_validity_clear(&snapshot->validity);
|
|
|
|
clear_snapshot_buffer(snapshot);
|
|
|
|
free(snapshot);
|
2017-09-25 08:00:09 +00:00
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-08 21:08:14 +00:00
|
|
|
struct ref_store *packed_ref_store_create(struct repository *repo,
|
2021-12-22 18:11:52 +00:00
|
|
|
const char *gitdir,
|
2017-06-23 07:01:38 +00:00
|
|
|
unsigned int store_flags)
|
2017-06-23 07:01:37 +00:00
|
|
|
{
|
|
|
|
struct packed_ref_store *refs = xcalloc(1, sizeof(*refs));
|
2017-06-23 07:01:38 +00:00
|
|
|
struct ref_store *ref_store = (struct ref_store *)refs;
|
2021-12-22 18:11:52 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2021-12-22 18:11:54 +00:00
|
|
|
base_ref_store_init(ref_store, repo, gitdir, &refs_be_packed);
|
2017-06-23 07:01:37 +00:00
|
|
|
refs->store_flags = store_flags;
|
2021-12-22 18:11:54 +00:00
|
|
|
|
2021-12-22 18:11:52 +00:00
|
|
|
strbuf_addf(&sb, "%s/packed-refs", gitdir);
|
|
|
|
refs->path = strbuf_detach(&sb, NULL);
|
2018-03-30 18:35:12 +00:00
|
|
|
chdir_notify_reparent("packed-refs", &refs->path);
|
2017-06-23 07:01:38 +00:00
|
|
|
return ref_store;
|
2017-06-23 07:01:37 +00:00
|
|
|
}
|
|
|
|
|
2017-06-23 07:01:38 +00:00
|
|
|
/*
|
|
|
|
* Downcast `ref_store` to `packed_ref_store`. Die if `ref_store` is
|
|
|
|
* not a `packed_ref_store`. Also die if `packed_ref_store` doesn't
|
|
|
|
* support at least the flags specified in `required_flags`. `caller`
|
|
|
|
* is used in any necessary error messages.
|
|
|
|
*/
|
|
|
|
static struct packed_ref_store *packed_downcast(struct ref_store *ref_store,
|
|
|
|
unsigned int required_flags,
|
|
|
|
const char *caller)
|
|
|
|
{
|
|
|
|
struct packed_ref_store *refs;
|
|
|
|
|
|
|
|
if (ref_store->be != &refs_be_packed)
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("ref_store is type \"%s\" not \"packed\" in %s",
|
2017-06-23 07:01:38 +00:00
|
|
|
ref_store->be->name, caller);
|
|
|
|
|
|
|
|
refs = (struct packed_ref_store *)ref_store;
|
|
|
|
|
|
|
|
if ((refs->store_flags & required_flags) != required_flags)
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("unallowed operation (%s), requires %x, has %x\n",
|
2017-06-23 07:01:38 +00:00
|
|
|
caller, required_flags, refs->store_flags);
|
|
|
|
|
|
|
|
return refs;
|
|
|
|
}
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
static void clear_snapshot(struct packed_ref_store *refs)
|
2017-06-23 07:01:37 +00:00
|
|
|
{
|
2017-09-25 08:00:18 +00:00
|
|
|
if (refs->snapshot) {
|
|
|
|
struct snapshot *snapshot = refs->snapshot;
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
refs->snapshot = NULL;
|
|
|
|
release_snapshot(snapshot);
|
2017-06-23 07:01:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-13 17:15:58 +00:00
|
|
|
static NORETURN void die_unterminated_line(const char *path,
|
|
|
|
const char *p, size_t len)
|
2017-06-23 07:01:37 +00:00
|
|
|
{
|
2017-09-13 17:15:58 +00:00
|
|
|
if (len < 80)
|
|
|
|
die("unterminated line in %s: %.*s", path, (int)len, p);
|
|
|
|
else
|
|
|
|
die("unterminated line in %s: %.75s...", path, p);
|
|
|
|
}
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-13 17:15:58 +00:00
|
|
|
static NORETURN void die_invalid_line(const char *path,
|
|
|
|
const char *p, size_t len)
|
|
|
|
{
|
|
|
|
const char *eol = memchr(p, '\n', len);
|
|
|
|
|
|
|
|
if (!eol)
|
|
|
|
die_unterminated_line(path, p, len);
|
|
|
|
else if (eol - p < 80)
|
|
|
|
die("unexpected line in %s: %.*s", path, (int)(eol - p), p);
|
|
|
|
else
|
|
|
|
die("unexpected line in %s: %.75s...", path, p);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
struct snapshot_record {
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
const char *start;
|
|
|
|
size_t len;
|
|
|
|
};
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
static int cmp_packed_ref_records(const void *v1, const void *v2)
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
{
|
2017-09-25 08:00:18 +00:00
|
|
|
const struct snapshot_record *e1 = v1, *e2 = v2;
|
2018-10-15 00:01:55 +00:00
|
|
|
const char *r1 = e1->start + the_hash_algo->hexsz + 1;
|
|
|
|
const char *r2 = e2->start + the_hash_algo->hexsz + 1;
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
|
|
|
|
while (1) {
|
|
|
|
if (*r1 == '\n')
|
|
|
|
return *r2 == '\n' ? 0 : -1;
|
|
|
|
if (*r1 != *r2) {
|
|
|
|
if (*r2 == '\n')
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return (unsigned char)*r1 < (unsigned char)*r2 ? -1 : +1;
|
|
|
|
}
|
|
|
|
r1++;
|
|
|
|
r2++;
|
2017-06-23 07:01:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-25 08:00:12 +00:00
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* Compare a snapshot record at `rec` to the specified NUL-terminated
|
|
|
|
* refname.
|
2017-09-25 08:00:12 +00:00
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
static int cmp_record_to_refname(const char *rec, const char *refname)
|
2017-09-25 08:00:12 +00:00
|
|
|
{
|
2018-10-15 00:01:55 +00:00
|
|
|
const char *r1 = rec + the_hash_algo->hexsz + 1;
|
2017-09-25 08:00:12 +00:00
|
|
|
const char *r2 = refname;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
if (*r1 == '\n')
|
|
|
|
return *r2 ? -1 : 0;
|
|
|
|
if (!*r2)
|
|
|
|
return 1;
|
|
|
|
if (*r1 != *r2)
|
|
|
|
return (unsigned char)*r1 < (unsigned char)*r2 ? -1 : +1;
|
|
|
|
r1++;
|
|
|
|
r2++;
|
|
|
|
}
|
|
|
|
}
|
2017-06-23 07:01:37 +00:00
|
|
|
|
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* `snapshot->buf` is not known to be sorted. Check whether it is, and
|
|
|
|
* if not, sort it into new memory and munmap/free the old storage.
|
2017-06-23 07:01:37 +00:00
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
static void sort_snapshot(struct snapshot *snapshot)
|
2017-06-23 07:01:37 +00:00
|
|
|
{
|
2017-09-25 08:00:18 +00:00
|
|
|
struct snapshot_record *records = NULL;
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
size_t alloc = 0, nr = 0;
|
|
|
|
int sorted = 1;
|
|
|
|
const char *pos, *eof, *eol;
|
|
|
|
size_t len, i;
|
|
|
|
char *new_buffer, *dst;
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2018-01-24 11:14:11 +00:00
|
|
|
pos = snapshot->start;
|
2017-09-25 08:00:18 +00:00
|
|
|
eof = snapshot->eof;
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2018-01-24 11:14:11 +00:00
|
|
|
if (pos == eof)
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
return;
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2018-01-24 11:14:11 +00:00
|
|
|
len = eof - pos;
|
|
|
|
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* Initialize records based on a crude estimate of the number
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
* of references in the file (we'll grow it below if needed):
|
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
ALLOC_GROW(records, len / 80 + 20, alloc);
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
|
|
|
|
while (pos < eof) {
|
|
|
|
eol = memchr(pos, '\n', eof - pos);
|
|
|
|
if (!eol)
|
|
|
|
/* The safety check should prevent this. */
|
|
|
|
BUG("unterminated line found in packed-refs");
|
2018-10-15 00:01:55 +00:00
|
|
|
if (eol - pos < the_hash_algo->hexsz + 2)
|
2017-09-25 08:00:18 +00:00
|
|
|
die_invalid_line(snapshot->refs->path,
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
pos, eof - pos);
|
|
|
|
eol++;
|
|
|
|
if (eol < eof && *eol == '^') {
|
|
|
|
/*
|
|
|
|
* Keep any peeled line together with its
|
|
|
|
* reference:
|
|
|
|
*/
|
|
|
|
const char *peeled_start = eol;
|
|
|
|
|
|
|
|
eol = memchr(peeled_start, '\n', eof - peeled_start);
|
|
|
|
if (!eol)
|
|
|
|
/* The safety check should prevent this. */
|
|
|
|
BUG("unterminated peeled line found in packed-refs");
|
|
|
|
eol++;
|
|
|
|
}
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
ALLOC_GROW(records, nr + 1, alloc);
|
|
|
|
records[nr].start = pos;
|
|
|
|
records[nr].len = eol - pos;
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
nr++;
|
|
|
|
|
|
|
|
if (sorted &&
|
|
|
|
nr > 1 &&
|
2017-09-25 08:00:18 +00:00
|
|
|
cmp_packed_ref_records(&records[nr - 2],
|
|
|
|
&records[nr - 1]) >= 0)
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
sorted = 0;
|
2017-06-23 07:01:37 +00:00
|
|
|
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
pos = eol;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sorted)
|
|
|
|
goto cleanup;
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
/* We need to sort the memory. First we sort the records array: */
|
|
|
|
QSORT(records, nr, cmp_packed_ref_records);
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate a new chunk of memory, and copy the old memory to
|
2017-09-25 08:00:18 +00:00
|
|
|
* the new in the order indicated by `records` (not bothering
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
* with the header line):
|
|
|
|
*/
|
|
|
|
new_buffer = xmalloc(len);
|
|
|
|
for (dst = new_buffer, i = 0; i < nr; i++) {
|
2017-09-25 08:00:18 +00:00
|
|
|
memcpy(dst, records[i].start, records[i].len);
|
|
|
|
dst += records[i].len;
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now munmap the old buffer and use the sorted buffer in its
|
|
|
|
* place:
|
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
clear_snapshot_buffer(snapshot);
|
2018-01-24 11:14:11 +00:00
|
|
|
snapshot->buf = snapshot->start = new_buffer;
|
2017-09-25 08:00:18 +00:00
|
|
|
snapshot->eof = new_buffer + len;
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
|
|
|
|
cleanup:
|
2017-09-25 08:00:18 +00:00
|
|
|
free(records);
|
2017-06-23 07:01:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
* Return a pointer to the start of the record that contains the
|
|
|
|
* character `*p` (which must be within the buffer). If no other
|
|
|
|
* record start is found, return `buf`.
|
|
|
|
*/
|
|
|
|
static const char *find_start_of_record(const char *buf, const char *p)
|
|
|
|
{
|
|
|
|
while (p > buf && (p[-1] != '\n' || p[0] == '^'))
|
|
|
|
p--;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2017-09-25 08:00:12 +00:00
|
|
|
/*
|
|
|
|
* Return a pointer to the start of the record following the record
|
|
|
|
* that contains `*p`. If none is found before `end`, return `end`.
|
|
|
|
*/
|
|
|
|
static const char *find_end_of_record(const char *p, const char *end)
|
|
|
|
{
|
|
|
|
while (++p < end && (p[-1] != '\n' || p[0] == '^'))
|
|
|
|
;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
/*
|
|
|
|
* We want to be able to compare mmapped reference records quickly,
|
|
|
|
* without totally parsing them. We can do so because the records are
|
|
|
|
* LF-terminated, and the refname should start exactly (GIT_SHA1_HEXSZ
|
|
|
|
* + 1) bytes past the beginning of the record.
|
|
|
|
*
|
|
|
|
* But what if the `packed-refs` file contains garbage? We're willing
|
|
|
|
* to tolerate not detecting the problem, as long as we don't produce
|
|
|
|
* totally garbled output (we can't afford to check the integrity of
|
|
|
|
* the whole file during every Git invocation). But we do want to be
|
|
|
|
* sure that we never read past the end of the buffer in memory and
|
|
|
|
* perform an illegal memory access.
|
|
|
|
*
|
|
|
|
* Guarantee that minimum level of safety by verifying that the last
|
|
|
|
* record in the file is LF-terminated, and that it has at least
|
|
|
|
* (GIT_SHA1_HEXSZ + 1) characters before the LF. Die if either of
|
|
|
|
* these checks fails.
|
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
static void verify_buffer_safe(struct snapshot *snapshot)
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
{
|
2018-01-24 11:14:11 +00:00
|
|
|
const char *start = snapshot->start;
|
2017-09-25 08:00:18 +00:00
|
|
|
const char *eof = snapshot->eof;
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
const char *last_line;
|
|
|
|
|
2018-01-24 11:14:11 +00:00
|
|
|
if (start == eof)
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
return;
|
|
|
|
|
2018-01-24 11:14:11 +00:00
|
|
|
last_line = find_start_of_record(start, eof - 1);
|
2018-10-15 00:01:55 +00:00
|
|
|
if (*(eof - 1) != '\n' || eof - last_line < the_hash_algo->hexsz + 2)
|
2017-09-25 08:00:18 +00:00
|
|
|
die_invalid_line(snapshot->refs->path,
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
last_line, eof - last_line);
|
|
|
|
}
|
|
|
|
|
2018-01-24 11:14:16 +00:00
|
|
|
#define SMALL_FILE_SIZE (32*1024)
|
|
|
|
|
2017-09-25 08:00:10 +00:00
|
|
|
/*
|
|
|
|
* Depending on `mmap_strategy`, either mmap or read the contents of
|
2017-09-25 08:00:18 +00:00
|
|
|
* the `packed-refs` file into the snapshot. Return 1 if the file
|
2018-01-24 11:14:15 +00:00
|
|
|
* existed and was read, or 0 if the file was absent or empty. Die on
|
|
|
|
* errors.
|
2017-09-25 08:00:10 +00:00
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
static int load_contents(struct snapshot *snapshot)
|
2017-09-25 08:00:10 +00:00
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
struct stat st;
|
|
|
|
size_t size;
|
|
|
|
ssize_t bytes_read;
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
fd = open(snapshot->refs->path, O_RDONLY);
|
2017-09-25 08:00:10 +00:00
|
|
|
if (fd < 0) {
|
|
|
|
if (errno == ENOENT) {
|
|
|
|
/*
|
|
|
|
* This is OK; it just means that no
|
|
|
|
* "packed-refs" file has been written yet,
|
|
|
|
* which is equivalent to it being empty,
|
|
|
|
* which is its state when initialized with
|
|
|
|
* zeros.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
} else {
|
2017-09-25 08:00:18 +00:00
|
|
|
die_errno("couldn't read %s", snapshot->refs->path);
|
2017-09-25 08:00:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
stat_validity_update(&snapshot->validity, fd);
|
2017-09-25 08:00:10 +00:00
|
|
|
|
|
|
|
if (fstat(fd, &st) < 0)
|
2017-09-25 08:00:18 +00:00
|
|
|
die_errno("couldn't stat %s", snapshot->refs->path);
|
2017-09-25 08:00:10 +00:00
|
|
|
size = xsize_t(st.st_size);
|
|
|
|
|
2018-01-24 11:14:15 +00:00
|
|
|
if (!size) {
|
2018-05-30 17:03:00 +00:00
|
|
|
close(fd);
|
2018-01-24 11:14:15 +00:00
|
|
|
return 0;
|
2018-01-24 11:14:16 +00:00
|
|
|
} else if (mmap_strategy == MMAP_NONE || size <= SMALL_FILE_SIZE) {
|
2017-09-25 08:00:18 +00:00
|
|
|
snapshot->buf = xmalloc(size);
|
|
|
|
bytes_read = read_in_full(fd, snapshot->buf, size);
|
2017-09-25 08:00:10 +00:00
|
|
|
if (bytes_read < 0 || bytes_read != size)
|
2017-09-25 08:00:18 +00:00
|
|
|
die_errno("couldn't read %s", snapshot->refs->path);
|
|
|
|
snapshot->mmapped = 0;
|
2018-01-24 11:14:15 +00:00
|
|
|
} else {
|
2017-09-25 08:00:18 +00:00
|
|
|
snapshot->buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
|
|
|
|
snapshot->mmapped = 1;
|
2017-09-25 08:00:10 +00:00
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
|
2018-01-24 11:14:11 +00:00
|
|
|
snapshot->start = snapshot->buf;
|
|
|
|
snapshot->eof = snapshot->buf + size;
|
|
|
|
|
2017-09-25 08:00:10 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-09-25 08:00:12 +00:00
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* Find the place in `snapshot->buf` where the start of the record for
|
2017-09-25 08:00:12 +00:00
|
|
|
* `refname` starts. If `mustexist` is true and the reference doesn't
|
|
|
|
* exist, then return NULL. If `mustexist` is false and the reference
|
|
|
|
* doesn't exist, then return the point where that reference would be
|
2018-01-24 11:14:13 +00:00
|
|
|
* inserted, or `snapshot->eof` (which might be NULL) if it would be
|
|
|
|
* inserted at the end of the file. In the latter mode, `refname`
|
|
|
|
* doesn't have to be a proper reference name; for example, one could
|
|
|
|
* search for "refs/replace/" to find the start of any replace
|
|
|
|
* references.
|
2017-09-25 08:00:12 +00:00
|
|
|
*
|
2017-09-25 08:00:18 +00:00
|
|
|
* The record is sought using a binary search, so `snapshot->buf` must
|
|
|
|
* be sorted.
|
2017-09-25 08:00:12 +00:00
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
static const char *find_reference_location(struct snapshot *snapshot,
|
2017-09-25 08:00:12 +00:00
|
|
|
const char *refname, int mustexist)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* This is not *quite* a garden-variety binary search, because
|
|
|
|
* the data we're searching is made up of records, and we
|
|
|
|
* always need to find the beginning of a record to do a
|
|
|
|
* comparison. A "record" here is one line for the reference
|
|
|
|
* itself and zero or one peel lines that start with '^'. Our
|
|
|
|
* loop invariant is described in the next two comments.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A pointer to the character at the start of a record whose
|
|
|
|
* preceding records all have reference names that come
|
|
|
|
* *before* `refname`.
|
|
|
|
*/
|
2018-01-24 11:14:11 +00:00
|
|
|
const char *lo = snapshot->start;
|
2017-09-25 08:00:12 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* A pointer to a the first character of a record whose
|
|
|
|
* reference name comes *after* `refname`.
|
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
const char *hi = snapshot->eof;
|
2017-09-25 08:00:12 +00:00
|
|
|
|
2018-01-24 11:14:13 +00:00
|
|
|
while (lo != hi) {
|
2017-09-25 08:00:12 +00:00
|
|
|
const char *mid, *rec;
|
|
|
|
int cmp;
|
|
|
|
|
|
|
|
mid = lo + (hi - lo) / 2;
|
|
|
|
rec = find_start_of_record(lo, mid);
|
2017-09-25 08:00:18 +00:00
|
|
|
cmp = cmp_record_to_refname(rec, refname);
|
2017-09-25 08:00:12 +00:00
|
|
|
if (cmp < 0) {
|
|
|
|
lo = find_end_of_record(mid, hi);
|
|
|
|
} else if (cmp > 0) {
|
|
|
|
hi = rec;
|
|
|
|
} else {
|
|
|
|
return rec;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mustexist)
|
|
|
|
return NULL;
|
|
|
|
else
|
|
|
|
return lo;
|
|
|
|
}
|
|
|
|
|
2017-06-23 07:01:37 +00:00
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* Create a newly-allocated `snapshot` of the `packed-refs` file in
|
|
|
|
* its current state and return it. The return value will already have
|
|
|
|
* its reference count incremented.
|
2017-06-23 07:01:37 +00:00
|
|
|
*
|
|
|
|
* A comment line of the form "# pack-refs with: " may contain zero or
|
|
|
|
* more traits. We interpret the traits as follows:
|
|
|
|
*
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
* Neither `peeled` nor `fully-peeled`:
|
2017-06-23 07:01:37 +00:00
|
|
|
*
|
|
|
|
* Probably no references are peeled. But if the file contains a
|
|
|
|
* peeled value for a reference, we will use it.
|
|
|
|
*
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
* `peeled`:
|
2017-06-23 07:01:37 +00:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
* `fully-peeled`:
|
2017-06-23 07:01:37 +00:00
|
|
|
*
|
|
|
|
* 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).
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
*
|
|
|
|
* `sorted`:
|
|
|
|
*
|
|
|
|
* The references in this file are known to be sorted by refname.
|
2017-06-23 07:01:37 +00:00
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
static struct snapshot *create_snapshot(struct packed_ref_store *refs)
|
2017-06-23 07:01:37 +00:00
|
|
|
{
|
2017-09-25 08:00:18 +00:00
|
|
|
struct snapshot *snapshot = xcalloc(1, sizeof(*snapshot));
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
int sorted = 0;
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
snapshot->refs = refs;
|
|
|
|
acquire_snapshot(snapshot);
|
|
|
|
snapshot->peeled = PEELED_NONE;
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
if (!load_contents(snapshot))
|
|
|
|
return snapshot;
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-13 17:16:00 +00:00
|
|
|
/* If the file has a header line, process it: */
|
2017-09-25 08:00:18 +00:00
|
|
|
if (snapshot->buf < snapshot->eof && *snapshot->buf == '#') {
|
2018-01-24 11:14:12 +00:00
|
|
|
char *tmp, *p, *eol;
|
2017-09-13 17:16:01 +00:00
|
|
|
struct string_list traits = STRING_LIST_INIT_NODUP;
|
2017-07-01 18:31:08 +00:00
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
eol = memchr(snapshot->buf, '\n',
|
|
|
|
snapshot->eof - snapshot->buf);
|
2017-09-13 17:16:00 +00:00
|
|
|
if (!eol)
|
2017-09-25 08:00:10 +00:00
|
|
|
die_unterminated_line(refs->path,
|
2017-09-25 08:00:18 +00:00
|
|
|
snapshot->buf,
|
|
|
|
snapshot->eof - snapshot->buf);
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2018-01-24 11:14:12 +00:00
|
|
|
tmp = xmemdupz(snapshot->buf, eol - snapshot->buf);
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2018-01-24 11:14:12 +00:00
|
|
|
if (!skip_prefix(tmp, "# pack-refs with:", (const char **)&p))
|
2017-09-25 08:00:10 +00:00
|
|
|
die_invalid_line(refs->path,
|
2017-09-25 08:00:18 +00:00
|
|
|
snapshot->buf,
|
|
|
|
snapshot->eof - snapshot->buf);
|
2017-09-13 17:16:00 +00:00
|
|
|
|
2017-09-13 17:16:01 +00:00
|
|
|
string_list_split_in_place(&traits, p, ' ', -1);
|
|
|
|
|
|
|
|
if (unsorted_string_list_has_string(&traits, "fully-peeled"))
|
2017-09-25 08:00:18 +00:00
|
|
|
snapshot->peeled = PEELED_FULLY;
|
2017-09-13 17:16:01 +00:00
|
|
|
else if (unsorted_string_list_has_string(&traits, "peeled"))
|
2017-09-25 08:00:18 +00:00
|
|
|
snapshot->peeled = PEELED_TAGS;
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
|
|
|
|
sorted = unsorted_string_list_has_string(&traits, "sorted");
|
|
|
|
|
2017-09-13 17:16:00 +00:00
|
|
|
/* perhaps other traits later as well */
|
|
|
|
|
|
|
|
/* The "+ 1" is for the LF character. */
|
2018-01-24 11:14:11 +00:00
|
|
|
snapshot->start = eol + 1;
|
2017-09-13 17:16:01 +00:00
|
|
|
|
|
|
|
string_list_clear(&traits, 0);
|
2018-01-24 11:14:12 +00:00
|
|
|
free(tmp);
|
2017-06-23 07:01:37 +00:00
|
|
|
}
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
verify_buffer_safe(snapshot);
|
2017-06-23 07:01:37 +00:00
|
|
|
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
if (!sorted) {
|
2017-09-25 08:00:18 +00:00
|
|
|
sort_snapshot(snapshot);
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Reordering the records might have moved a short one
|
|
|
|
* to the end of the buffer, so verify the buffer's
|
|
|
|
* safety again:
|
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
verify_buffer_safe(snapshot);
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
if (mmap_strategy != MMAP_OK && snapshot->mmapped) {
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
/*
|
|
|
|
* We don't want to leave the file mmapped, so we are
|
|
|
|
* forced to make a copy now:
|
|
|
|
*/
|
2018-01-24 11:14:11 +00:00
|
|
|
size_t size = snapshot->eof - snapshot->start;
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
char *buf_copy = xmalloc(size);
|
|
|
|
|
2018-01-24 11:14:11 +00:00
|
|
|
memcpy(buf_copy, snapshot->start, size);
|
2017-09-25 08:00:18 +00:00
|
|
|
clear_snapshot_buffer(snapshot);
|
2018-01-24 11:14:11 +00:00
|
|
|
snapshot->buf = snapshot->start = buf_copy;
|
2017-09-25 08:00:18 +00:00
|
|
|
snapshot->eof = buf_copy + size;
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
return snapshot;
|
2017-06-23 07:01:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* Check that `refs->snapshot` (if present) still reflects the
|
|
|
|
* contents of the `packed-refs` file. If not, clear the snapshot.
|
2017-06-23 07:01:37 +00:00
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
static void validate_snapshot(struct packed_ref_store *refs)
|
2017-06-23 07:01:37 +00:00
|
|
|
{
|
2017-09-25 08:00:18 +00:00
|
|
|
if (refs->snapshot &&
|
|
|
|
!stat_validity_check(&refs->snapshot->validity, refs->path))
|
|
|
|
clear_snapshot(refs);
|
2017-06-23 07:01:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* Get the `snapshot` for the specified packed_ref_store, creating and
|
|
|
|
* populating it if it hasn't been read before or if the file has been
|
|
|
|
* changed (according to its `validity` field) since it was last read.
|
|
|
|
* On the other hand, if we hold the lock, then assume that the file
|
|
|
|
* hasn't been changed out from under us, so skip the extra `stat()`
|
|
|
|
* call in `stat_validity_check()`. This function does *not* increase
|
|
|
|
* the snapshot's reference count on behalf of the caller.
|
2017-06-23 07:01:37 +00:00
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
static struct snapshot *get_snapshot(struct packed_ref_store *refs)
|
2017-06-23 07:01:37 +00:00
|
|
|
{
|
|
|
|
if (!is_lock_file_locked(&refs->lock))
|
2017-09-25 08:00:18 +00:00
|
|
|
validate_snapshot(refs);
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
if (!refs->snapshot)
|
|
|
|
refs->snapshot = create_snapshot(refs);
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
return refs->snapshot;
|
2017-06-23 07:01:37 +00:00
|
|
|
}
|
|
|
|
|
2021-08-23 11:52:40 +00:00
|
|
|
static int packed_read_raw_ref(struct ref_store *ref_store, const char *refname,
|
2022-08-25 17:09:48 +00:00
|
|
|
struct object_id *oid, struct strbuf *referent UNUSED,
|
2021-08-23 11:52:40 +00:00
|
|
|
unsigned int *type, int *failure_errno)
|
2017-06-23 07:01:37 +00:00
|
|
|
{
|
2017-06-23 07:01:38 +00:00
|
|
|
struct packed_ref_store *refs =
|
|
|
|
packed_downcast(ref_store, REF_STORE_READ, "read_raw_ref");
|
2017-09-25 08:00:18 +00:00
|
|
|
struct snapshot *snapshot = get_snapshot(refs);
|
2017-09-25 08:00:13 +00:00
|
|
|
const char *rec;
|
2017-06-23 07:01:37 +00:00
|
|
|
|
|
|
|
*type = 0;
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
rec = find_reference_location(snapshot, refname, 1);
|
2017-09-25 08:00:13 +00:00
|
|
|
|
|
|
|
if (!rec) {
|
|
|
|
/* refname is not a packed reference. */
|
2021-08-23 11:52:40 +00:00
|
|
|
*failure_errno = ENOENT;
|
2017-06-23 07:01:37 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2017-10-15 22:07:11 +00:00
|
|
|
if (get_oid_hex(rec, oid))
|
2017-09-25 08:00:18 +00:00
|
|
|
die_invalid_line(refs->path, rec, snapshot->eof - rec);
|
2017-09-25 08:00:13 +00:00
|
|
|
|
2017-06-23 07:01:37 +00:00
|
|
|
*type = REF_ISPACKED;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-09-25 08:00:17 +00:00
|
|
|
/*
|
|
|
|
* This value is set in `base.flags` if the peeled value of the
|
|
|
|
* current reference is known. In that case, `peeled` contains the
|
2017-11-05 08:42:09 +00:00
|
|
|
* correct peeled value for the reference, which might be `null_oid`
|
2017-09-25 08:00:17 +00:00
|
|
|
* if the reference is not a tag or if it is broken.
|
|
|
|
*/
|
|
|
|
#define REF_KNOWS_PEELED 0x40
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-25 08:00:17 +00:00
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* An iterator over a snapshot of a `packed-refs` file.
|
2017-09-25 08:00:17 +00:00
|
|
|
*/
|
2017-06-23 07:01:37 +00:00
|
|
|
struct packed_ref_iterator {
|
|
|
|
struct ref_iterator base;
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
struct snapshot *snapshot;
|
2017-09-25 08:00:17 +00:00
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
/* The current position in the snapshot's buffer: */
|
2017-09-25 08:00:17 +00:00
|
|
|
const char *pos;
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
/* The end of the part of the buffer that will be iterated over: */
|
2017-09-25 08:00:17 +00:00
|
|
|
const char *eof;
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
/* Scratch space for current values: */
|
2017-09-25 08:00:17 +00:00
|
|
|
struct object_id oid, peeled;
|
|
|
|
struct strbuf refname_buf;
|
|
|
|
|
2021-10-08 21:08:15 +00:00
|
|
|
struct repository *repo;
|
2017-06-23 07:01:37 +00:00
|
|
|
unsigned int flags;
|
|
|
|
};
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
/*
|
|
|
|
* Move the iterator to the next record in the snapshot, without
|
|
|
|
* respect for whether the record is actually required by the current
|
|
|
|
* iteration. Adjust the fields in `iter` and return `ITER_OK` or
|
|
|
|
* `ITER_DONE`. This function does not free the iterator in the case
|
|
|
|
* of `ITER_DONE`.
|
|
|
|
*/
|
2017-09-25 08:00:17 +00:00
|
|
|
static int next_record(struct packed_ref_iterator *iter)
|
|
|
|
{
|
|
|
|
const char *p = iter->pos, *eol;
|
|
|
|
|
|
|
|
strbuf_reset(&iter->refname_buf);
|
|
|
|
|
|
|
|
if (iter->pos == iter->eof)
|
|
|
|
return ITER_DONE;
|
|
|
|
|
|
|
|
iter->base.flags = REF_ISPACKED;
|
|
|
|
|
2018-10-15 00:01:55 +00:00
|
|
|
if (iter->eof - p < the_hash_algo->hexsz + 2 ||
|
2017-09-25 08:00:17 +00:00
|
|
|
parse_oid_hex(p, &iter->oid, &p) ||
|
|
|
|
!isspace(*p++))
|
2017-09-25 08:00:18 +00:00
|
|
|
die_invalid_line(iter->snapshot->refs->path,
|
2017-09-25 08:00:17 +00:00
|
|
|
iter->pos, iter->eof - iter->pos);
|
|
|
|
|
|
|
|
eol = memchr(p, '\n', iter->eof - p);
|
|
|
|
if (!eol)
|
2017-09-25 08:00:18 +00:00
|
|
|
die_unterminated_line(iter->snapshot->refs->path,
|
2017-09-25 08:00:17 +00:00
|
|
|
iter->pos, iter->eof - iter->pos);
|
|
|
|
|
|
|
|
strbuf_add(&iter->refname_buf, p, eol - p);
|
|
|
|
iter->base.refname = iter->refname_buf.buf;
|
|
|
|
|
|
|
|
if (check_refname_format(iter->base.refname, REFNAME_ALLOW_ONELEVEL)) {
|
|
|
|
if (!refname_is_safe(iter->base.refname))
|
|
|
|
die("packed refname is dangerous: %s",
|
|
|
|
iter->base.refname);
|
|
|
|
oidclr(&iter->oid);
|
|
|
|
iter->base.flags |= REF_BAD_NAME | REF_ISBROKEN;
|
|
|
|
}
|
2017-09-25 08:00:18 +00:00
|
|
|
if (iter->snapshot->peeled == PEELED_FULLY ||
|
|
|
|
(iter->snapshot->peeled == PEELED_TAGS &&
|
2017-09-25 08:00:17 +00:00
|
|
|
starts_with(iter->base.refname, "refs/tags/")))
|
|
|
|
iter->base.flags |= REF_KNOWS_PEELED;
|
|
|
|
|
|
|
|
iter->pos = eol + 1;
|
|
|
|
|
|
|
|
if (iter->pos < iter->eof && *iter->pos == '^') {
|
|
|
|
p = iter->pos + 1;
|
2018-10-15 00:01:55 +00:00
|
|
|
if (iter->eof - p < the_hash_algo->hexsz + 1 ||
|
2017-09-25 08:00:17 +00:00
|
|
|
parse_oid_hex(p, &iter->peeled, &p) ||
|
|
|
|
*p++ != '\n')
|
2017-09-25 08:00:18 +00:00
|
|
|
die_invalid_line(iter->snapshot->refs->path,
|
2017-09-25 08:00:17 +00:00
|
|
|
iter->pos, iter->eof - iter->pos);
|
|
|
|
iter->pos = p;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Regardless of what the file header said, we
|
|
|
|
* definitely know the value of *this* reference. But
|
|
|
|
* we suppress it if the reference is broken:
|
|
|
|
*/
|
|
|
|
if ((iter->base.flags & REF_ISBROKEN)) {
|
|
|
|
oidclr(&iter->peeled);
|
|
|
|
iter->base.flags &= ~REF_KNOWS_PEELED;
|
|
|
|
} else {
|
|
|
|
iter->base.flags |= REF_KNOWS_PEELED;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
oidclr(&iter->peeled);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ITER_OK;
|
|
|
|
}
|
|
|
|
|
2017-06-23 07:01:37 +00:00
|
|
|
static int packed_ref_iterator_advance(struct ref_iterator *ref_iterator)
|
|
|
|
{
|
|
|
|
struct packed_ref_iterator *iter =
|
|
|
|
(struct packed_ref_iterator *)ref_iterator;
|
|
|
|
int ok;
|
|
|
|
|
2017-09-25 08:00:17 +00:00
|
|
|
while ((ok = next_record(iter)) == ITER_OK) {
|
2017-06-23 07:01:37 +00:00
|
|
|
if (iter->flags & DO_FOR_EACH_PER_WORKTREE_ONLY &&
|
2022-09-19 16:34:50 +00:00
|
|
|
!is_per_worktree_ref(iter->base.refname))
|
2017-06-23 07:01:37 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!(iter->flags & DO_FOR_EACH_INCLUDE_BROKEN) &&
|
2021-10-08 21:08:15 +00:00
|
|
|
!ref_resolves_to_object(iter->base.refname, iter->repo,
|
|
|
|
&iter->oid, iter->flags))
|
2017-06-23 07:01:37 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
return ITER_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ref_iterator_abort(ref_iterator) != ITER_DONE)
|
|
|
|
ok = ITER_ERROR;
|
|
|
|
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int packed_ref_iterator_peel(struct ref_iterator *ref_iterator,
|
|
|
|
struct object_id *peeled)
|
|
|
|
{
|
|
|
|
struct packed_ref_iterator *iter =
|
|
|
|
(struct packed_ref_iterator *)ref_iterator;
|
|
|
|
|
2021-10-08 21:08:16 +00:00
|
|
|
if (iter->repo != the_repository)
|
|
|
|
BUG("peeling for non-the_repository is not supported");
|
|
|
|
|
2017-09-25 08:00:17 +00:00
|
|
|
if ((iter->base.flags & REF_KNOWS_PEELED)) {
|
|
|
|
oidcpy(peeled, &iter->peeled);
|
|
|
|
return is_null_oid(&iter->peeled) ? -1 : 0;
|
|
|
|
} else if ((iter->base.flags & (REF_ISBROKEN | REF_ISSYMREF))) {
|
|
|
|
return -1;
|
|
|
|
} else {
|
2021-05-19 15:31:28 +00:00
|
|
|
return peel_object(&iter->oid, peeled) ? -1 : 0;
|
2017-09-25 08:00:17 +00:00
|
|
|
}
|
2017-06-23 07:01:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int packed_ref_iterator_abort(struct ref_iterator *ref_iterator)
|
|
|
|
{
|
|
|
|
struct packed_ref_iterator *iter =
|
|
|
|
(struct packed_ref_iterator *)ref_iterator;
|
|
|
|
int ok = ITER_DONE;
|
|
|
|
|
2017-09-25 08:00:17 +00:00
|
|
|
strbuf_release(&iter->refname_buf);
|
2017-09-25 08:00:18 +00:00
|
|
|
release_snapshot(iter->snapshot);
|
2017-06-23 07:01:37 +00:00
|
|
|
base_ref_iterator_free(ref_iterator);
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ref_iterator_vtable packed_ref_iterator_vtable = {
|
2022-03-17 17:27:16 +00:00
|
|
|
.advance = packed_ref_iterator_advance,
|
|
|
|
.peel = packed_ref_iterator_peel,
|
|
|
|
.abort = packed_ref_iterator_abort
|
2017-06-23 07:01:37 +00:00
|
|
|
};
|
|
|
|
|
2017-06-23 07:01:38 +00:00
|
|
|
static struct ref_iterator *packed_ref_iterator_begin(
|
|
|
|
struct ref_store *ref_store,
|
2017-06-23 07:01:37 +00:00
|
|
|
const char *prefix, unsigned int flags)
|
|
|
|
{
|
2017-06-23 07:01:38 +00:00
|
|
|
struct packed_ref_store *refs;
|
2017-09-25 08:00:18 +00:00
|
|
|
struct snapshot *snapshot;
|
2017-09-25 08:00:12 +00:00
|
|
|
const char *start;
|
2017-06-23 07:01:37 +00:00
|
|
|
struct packed_ref_iterator *iter;
|
|
|
|
struct ref_iterator *ref_iterator;
|
2017-06-23 07:01:38 +00:00
|
|
|
unsigned int required_flags = REF_STORE_READ;
|
|
|
|
|
|
|
|
if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN))
|
|
|
|
required_flags |= REF_STORE_ODB;
|
|
|
|
refs = packed_downcast(ref_store, required_flags, "ref_iterator_begin");
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
/*
|
|
|
|
* Note that `get_snapshot()` internally checks whether the
|
|
|
|
* snapshot is up to date with what is on disk, and re-reads
|
|
|
|
* it if not.
|
|
|
|
*/
|
|
|
|
snapshot = get_snapshot(refs);
|
2017-09-25 08:00:17 +00:00
|
|
|
|
2018-01-24 11:14:14 +00:00
|
|
|
if (prefix && *prefix)
|
|
|
|
start = find_reference_location(snapshot, prefix, 0);
|
|
|
|
else
|
|
|
|
start = snapshot->start;
|
|
|
|
|
|
|
|
if (start == snapshot->eof)
|
2017-09-25 08:00:17 +00:00
|
|
|
return empty_ref_iterator_begin();
|
|
|
|
|
2021-03-13 16:17:22 +00:00
|
|
|
CALLOC_ARRAY(iter, 1);
|
2017-06-23 07:01:37 +00:00
|
|
|
ref_iterator = &iter->base;
|
2017-09-13 17:15:55 +00:00
|
|
|
base_ref_iterator_init(ref_iterator, &packed_ref_iterator_vtable, 1);
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
iter->snapshot = snapshot;
|
|
|
|
acquire_snapshot(snapshot);
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-25 08:00:17 +00:00
|
|
|
iter->pos = start;
|
2017-09-25 08:00:18 +00:00
|
|
|
iter->eof = snapshot->eof;
|
2017-09-25 08:00:17 +00:00
|
|
|
strbuf_init(&iter->refname_buf, 0);
|
|
|
|
|
|
|
|
iter->base.oid = &iter->oid;
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2021-10-08 21:08:15 +00:00
|
|
|
iter->repo = ref_store->repo;
|
2017-06-23 07:01:37 +00:00
|
|
|
iter->flags = flags;
|
|
|
|
|
2017-09-25 08:00:12 +00:00
|
|
|
if (prefix && *prefix)
|
|
|
|
/* Stop iteration after we've gone *past* prefix: */
|
|
|
|
ref_iterator = prefix_ref_iterator_begin(ref_iterator, prefix, 0);
|
|
|
|
|
2017-06-23 07:01:37 +00:00
|
|
|
return ref_iterator;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write an entry to the packed-refs file for the specified refname.
|
2017-06-23 07:01:39 +00:00
|
|
|
* If peeled is non-NULL, write it as the entry's peeled value. On
|
|
|
|
* error, return a nonzero value and leave errno set at the value left
|
|
|
|
* by the failing call to `fprintf()`.
|
2017-06-23 07:01:37 +00:00
|
|
|
*/
|
2017-06-23 07:01:39 +00:00
|
|
|
static int write_packed_entry(FILE *fh, const char *refname,
|
2017-11-05 08:42:08 +00:00
|
|
|
const struct object_id *oid,
|
|
|
|
const struct object_id *peeled)
|
2017-06-23 07:01:37 +00:00
|
|
|
{
|
2017-11-05 08:42:08 +00:00
|
|
|
if (fprintf(fh, "%s %s\n", oid_to_hex(oid), refname) < 0 ||
|
|
|
|
(peeled && fprintf(fh, "^%s\n", oid_to_hex(peeled)) < 0))
|
2017-06-23 07:01:39 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
2017-06-23 07:01:37 +00:00
|
|
|
}
|
|
|
|
|
2017-06-23 07:01:42 +00:00
|
|
|
int packed_refs_lock(struct ref_store *ref_store, int flags, struct strbuf *err)
|
2017-06-23 07:01:37 +00:00
|
|
|
{
|
2017-06-23 07:01:38 +00:00
|
|
|
struct packed_ref_store *refs =
|
|
|
|
packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN,
|
2017-06-23 07:01:41 +00:00
|
|
|
"packed_refs_lock");
|
2017-06-23 07:01:37 +00:00
|
|
|
static int timeout_configured = 0;
|
|
|
|
static int timeout_value = 1000;
|
|
|
|
|
|
|
|
if (!timeout_configured) {
|
|
|
|
git_config_get_int("core.packedrefstimeout", &timeout_value);
|
|
|
|
timeout_configured = 1;
|
|
|
|
}
|
|
|
|
|
2017-06-23 07:01:40 +00:00
|
|
|
/*
|
|
|
|
* Note that we close the lockfile immediately because we
|
|
|
|
* don't write new content to it, but rather to a separate
|
|
|
|
* tempfile.
|
|
|
|
*/
|
2017-06-23 07:01:37 +00:00
|
|
|
if (hold_lock_file_for_update_timeout(
|
|
|
|
&refs->lock,
|
|
|
|
refs->path,
|
2017-06-23 07:01:42 +00:00
|
|
|
flags, timeout_value) < 0) {
|
|
|
|
unable_to_lock_message(refs->path, errno, err);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2017-09-05 12:14:33 +00:00
|
|
|
if (close_lock_file_gently(&refs->lock)) {
|
2017-06-23 07:01:42 +00:00
|
|
|
strbuf_addf(err, "unable to close %s: %s", refs->path, strerror(errno));
|
2017-09-05 12:14:33 +00:00
|
|
|
rollback_lock_file(&refs->lock);
|
2017-06-23 07:01:37 +00:00
|
|
|
return -1;
|
2017-06-23 07:01:42 +00:00
|
|
|
}
|
2017-06-23 07:01:37 +00:00
|
|
|
|
|
|
|
/*
|
pack-refs: always refresh after taking the lock file
When a packed ref is deleted, the whole packed-refs file is
rewritten to omit the ref that no longer exists. However if another
gc command is running and calls `pack-refs --all` simultaneously,
there is a chance that a ref that was just updated lose the newly
created commits.
Through these steps, losing commits on newly updated refs can be
demonstrated:
# step 1: compile git without `USE_NSEC` option
Some kernel releases do enable it by default while some do
not. And if we compile git without `USE_NSEC`, it will be easier
demonstrated by the following steps.
# step 2: setup a repository and add the first commit
git init repo &&
(cd repo &&
git config core.logallrefupdates true &&
git commit --allow-empty -m foo)
# step 3: in one terminal, repack the refs repeatedly
cd repo &&
while true
do
git pack-refs --all
done
# step 4: in another terminal, simultaneously update the
# master with update-ref, and create and delete an
# unrelated ref also with update-ref
cd repo &&
while true
do
us=$(git commit-tree -m foo -p HEAD HEAD^{tree}) &&
git update-ref refs/heads/newbranch $us &&
git update-ref refs/heads/master $us &&
git update-ref -d refs/heads/newbranch &&
them=$(git rev-parse master) &&
if test "$them" != "$us"
then
echo >&2 "lost commit: $us"
exit 1
fi
# eye candy
printf .
done
Though we have the packed-refs lock file and loose refs lock
files to avoid updating conflicts, a ref will lost its newly
commits if racy stat-validity of `packed-refs` file happens
(which is quite same as the racy-git described in
`Documentation/technical/racy-git.txt`), the following
specific set of operations demonstrates the problem:
1. Call `pack-refs --all` to pack all the loose refs to
packed-refs, and let say the modify time of the
packed-refs is DATE_M.
2. Call `update-ref` to update a new commit to master while
it is already packed. the old value (let us call it
OID_A) remains in the packed-refs file and write the new
value (let us call it OID_B) to $GIT_DIR/refs/heads/master.
3. Call `update-ref -d` within the same DATE_M from the 1th
step to delete a different ref newbranch which is packed
in the packed-refs file. It check newbranch's oid from
packed-refs file without locking it.
Meanwhile it keeps a snapshot of the packed-refs file in
memory and record the file's attributes with the snapshot.
The oid of master in the packed-refs's snapshot is OID_A.
4. Call a new `pack-refs --all` to pack the loose refs, the
oid of master in packe-refs file is OID_B, and the loose
refs $GIT_DIR/refs/heads/master is removed. Let's say
the `pack-refs --all` is very quickly done and the new
packed-refs file's modify time is still DATE_M, and it
has the same file size, even the same inode.
5. 3th step now goes on after checking the newbranch, it
begin to rewrite the packed-refs file. After get the
lock file of packed-ref file, it checks it's on-disk
file attributes with the snapshot, suck as the timestamp,
the file size and the inode value. If they are both the
same values, and the snapshot is not refreshed.
Because the loose ref of master is removed by 4th step,
`update-ref -d` will updates the new packed-ref to disk
which contains master with the oid OID_A. So now the
newly commit OID_B of master is lost.
The best path forward is just always refreshing after take
the lock file of `packed-refs` file. Traditionally we avoided
that because refreshing it implied parsing the whole file.
But these days we mmap it, so it really is just an extra
open()/mmap() and a quick read of the header. That doesn't seem
like an outrageous cost to pay when we're already taking the lock.
Signed-off-by: Sun Chao <sunchao9@huawei.com>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Sun Chao <sunchao9@huawei.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-07-31 18:35:44 +00:00
|
|
|
* There is a stat-validity problem might cause `update-ref -d`
|
|
|
|
* lost the newly commit of a ref, because a new `packed-refs`
|
|
|
|
* file might has the same on-disk file attributes such as
|
|
|
|
* timestamp, file size and inode value, but has a changed
|
|
|
|
* ref value.
|
|
|
|
*
|
|
|
|
* This could happen with a very small chance when
|
|
|
|
* `update-ref -d` is called and at the same time another
|
|
|
|
* `pack-refs --all` process is running.
|
|
|
|
*
|
|
|
|
* Now that we hold the `packed-refs` lock, it is important
|
|
|
|
* to make sure we could read the latest version of
|
|
|
|
* `packed-refs` file no matter we have just mmap it or not.
|
|
|
|
* So what need to do is clear the snapshot if we hold it
|
|
|
|
* already.
|
2017-06-23 07:01:37 +00:00
|
|
|
*/
|
pack-refs: always refresh after taking the lock file
When a packed ref is deleted, the whole packed-refs file is
rewritten to omit the ref that no longer exists. However if another
gc command is running and calls `pack-refs --all` simultaneously,
there is a chance that a ref that was just updated lose the newly
created commits.
Through these steps, losing commits on newly updated refs can be
demonstrated:
# step 1: compile git without `USE_NSEC` option
Some kernel releases do enable it by default while some do
not. And if we compile git without `USE_NSEC`, it will be easier
demonstrated by the following steps.
# step 2: setup a repository and add the first commit
git init repo &&
(cd repo &&
git config core.logallrefupdates true &&
git commit --allow-empty -m foo)
# step 3: in one terminal, repack the refs repeatedly
cd repo &&
while true
do
git pack-refs --all
done
# step 4: in another terminal, simultaneously update the
# master with update-ref, and create and delete an
# unrelated ref also with update-ref
cd repo &&
while true
do
us=$(git commit-tree -m foo -p HEAD HEAD^{tree}) &&
git update-ref refs/heads/newbranch $us &&
git update-ref refs/heads/master $us &&
git update-ref -d refs/heads/newbranch &&
them=$(git rev-parse master) &&
if test "$them" != "$us"
then
echo >&2 "lost commit: $us"
exit 1
fi
# eye candy
printf .
done
Though we have the packed-refs lock file and loose refs lock
files to avoid updating conflicts, a ref will lost its newly
commits if racy stat-validity of `packed-refs` file happens
(which is quite same as the racy-git described in
`Documentation/technical/racy-git.txt`), the following
specific set of operations demonstrates the problem:
1. Call `pack-refs --all` to pack all the loose refs to
packed-refs, and let say the modify time of the
packed-refs is DATE_M.
2. Call `update-ref` to update a new commit to master while
it is already packed. the old value (let us call it
OID_A) remains in the packed-refs file and write the new
value (let us call it OID_B) to $GIT_DIR/refs/heads/master.
3. Call `update-ref -d` within the same DATE_M from the 1th
step to delete a different ref newbranch which is packed
in the packed-refs file. It check newbranch's oid from
packed-refs file without locking it.
Meanwhile it keeps a snapshot of the packed-refs file in
memory and record the file's attributes with the snapshot.
The oid of master in the packed-refs's snapshot is OID_A.
4. Call a new `pack-refs --all` to pack the loose refs, the
oid of master in packe-refs file is OID_B, and the loose
refs $GIT_DIR/refs/heads/master is removed. Let's say
the `pack-refs --all` is very quickly done and the new
packed-refs file's modify time is still DATE_M, and it
has the same file size, even the same inode.
5. 3th step now goes on after checking the newbranch, it
begin to rewrite the packed-refs file. After get the
lock file of packed-ref file, it checks it's on-disk
file attributes with the snapshot, suck as the timestamp,
the file size and the inode value. If they are both the
same values, and the snapshot is not refreshed.
Because the loose ref of master is removed by 4th step,
`update-ref -d` will updates the new packed-ref to disk
which contains master with the oid OID_A. So now the
newly commit OID_B of master is lost.
The best path forward is just always refreshing after take
the lock file of `packed-refs` file. Traditionally we avoided
that because refreshing it implied parsing the whole file.
But these days we mmap it, so it really is just an extra
open()/mmap() and a quick read of the header. That doesn't seem
like an outrageous cost to pay when we're already taking the lock.
Signed-off-by: Sun Chao <sunchao9@huawei.com>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Sun Chao <sunchao9@huawei.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-07-31 18:35:44 +00:00
|
|
|
clear_snapshot(refs);
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-08 13:51:43 +00:00
|
|
|
/*
|
|
|
|
* Now make sure that the packed-refs file as it exists in the
|
2017-09-25 08:00:18 +00:00
|
|
|
* locked state is loaded into the snapshot:
|
2017-09-08 13:51:43 +00:00
|
|
|
*/
|
2017-09-25 08:00:18 +00:00
|
|
|
get_snapshot(refs);
|
2017-06-23 07:01:37 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-06-23 07:01:43 +00:00
|
|
|
void packed_refs_unlock(struct ref_store *ref_store)
|
|
|
|
{
|
|
|
|
struct packed_ref_store *refs = packed_downcast(
|
|
|
|
ref_store,
|
|
|
|
REF_STORE_READ | REF_STORE_WRITE,
|
|
|
|
"packed_refs_unlock");
|
|
|
|
|
|
|
|
if (!is_lock_file_locked(&refs->lock))
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("packed_refs_unlock() called when not locked");
|
2017-06-23 07:01:43 +00:00
|
|
|
rollback_lock_file(&refs->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
int packed_refs_is_locked(struct ref_store *ref_store)
|
|
|
|
{
|
|
|
|
struct packed_ref_store *refs = packed_downcast(
|
|
|
|
ref_store,
|
|
|
|
REF_STORE_READ | REF_STORE_WRITE,
|
|
|
|
"packed_refs_is_locked");
|
|
|
|
|
|
|
|
return is_lock_file_locked(&refs->lock);
|
|
|
|
}
|
|
|
|
|
2017-06-23 07:01:37 +00:00
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* The packed-refs header line that we write out. Perhaps other traits
|
|
|
|
* will be added later.
|
2017-09-13 17:16:01 +00:00
|
|
|
*
|
|
|
|
* Note that earlier versions of Git used to parse these traits by
|
|
|
|
* looking for " trait " in the line. For this reason, the space after
|
|
|
|
* the colon and the trailing space are required.
|
2017-06-23 07:01:37 +00:00
|
|
|
*/
|
|
|
|
static const char PACKED_REFS_HEADER[] =
|
read_packed_refs(): ensure that references are ordered when read
It doesn't actually matter now, because the references are only
iterated over to fill the associated `ref_cache`, which itself puts
them in the correct order. But we want to get rid of the `ref_cache`,
so we want to be able to iterate directly over the `packed-refs`
buffer, and then the iteration will need to be ordered correctly.
In fact, we already write the `packed-refs` file sorted, but it is
possible that other Git clients don't get it right. So let's not
assume that a `packed-refs` file is sorted unless it is explicitly
declared to be so via a `sorted` trait in its header line.
If it is *not* declared to be sorted, then scan quickly through the
file to check. If it is found to be out of order, then sort the
records into a new memory-only copy. This checking and sorting is done
quickly, without parsing the full file contents. However, it needs a
little bit of care to avoid reading past the end of the buffer even if
the `packed-refs` file is corrupt.
Since *we* always write the file correctly sorted, include that trait
when we write or rewrite a `packed-refs` file. This means that the
scan described in the previous paragraph should only have to be done
for `packed-refs` files that were written by older versions of the Git
command-line client, or by other clients that haven't yet learned to
write the `sorted` trait.
If `packed-refs` was already sorted, then (if the system allows it) we
can use the mmapped file contents directly. But if the system doesn't
allow a file that is currently mmapped to be replaced using
`rename()`, then it would be bad for us to keep the file mmapped for
any longer than necessary. So, on such systems, always make a copy of
the file contents, either as part of the sorting process, or
afterwards.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-25 08:00:11 +00:00
|
|
|
"# pack-refs with: peeled fully-peeled sorted \n";
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2022-08-25 17:09:48 +00:00
|
|
|
static int packed_init_db(struct ref_store *ref_store UNUSED,
|
|
|
|
struct strbuf *err UNUSED)
|
2017-06-23 07:01:38 +00:00
|
|
|
{
|
|
|
|
/* Nothing to do. */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-06-23 07:01:37 +00:00
|
|
|
/*
|
2017-09-25 08:00:18 +00:00
|
|
|
* Write the packed refs from the current snapshot to the packed-refs
|
|
|
|
* tempfile, incorporating any changes from `updates`. `updates` must
|
|
|
|
* be a sorted string list whose keys are the refnames and whose util
|
2017-09-08 13:51:45 +00:00
|
|
|
* values are `struct ref_update *`. On error, rollback the tempfile,
|
|
|
|
* write an error message to `err`, and return a nonzero value.
|
|
|
|
*
|
|
|
|
* The packfile must be locked before calling this function and will
|
|
|
|
* remain locked when it is done.
|
2017-06-23 07:01:37 +00:00
|
|
|
*/
|
2017-09-08 13:51:45 +00:00
|
|
|
static int write_with_updates(struct packed_ref_store *refs,
|
|
|
|
struct string_list *updates,
|
|
|
|
struct strbuf *err)
|
2017-06-23 07:01:37 +00:00
|
|
|
{
|
2017-09-08 13:51:45 +00:00
|
|
|
struct ref_iterator *iter = NULL;
|
|
|
|
size_t i;
|
2017-06-23 07:01:39 +00:00
|
|
|
int ok;
|
2017-06-23 07:01:37 +00:00
|
|
|
FILE *out;
|
2017-09-08 13:51:45 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2017-07-26 23:39:42 +00:00
|
|
|
char *packed_refs_path;
|
2017-06-23 07:01:37 +00:00
|
|
|
|
|
|
|
if (!is_lock_file_locked(&refs->lock))
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("write_with_updates() called while unlocked");
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-07-26 23:39:42 +00:00
|
|
|
/*
|
|
|
|
* If packed-refs is a symlink, we want to overwrite the
|
|
|
|
* symlinked-to file, not the symlink itself. Also, put the
|
|
|
|
* staging file next to it:
|
|
|
|
*/
|
|
|
|
packed_refs_path = get_locked_file_path(&refs->lock);
|
|
|
|
strbuf_addf(&sb, "%s.new", packed_refs_path);
|
2017-09-08 13:51:45 +00:00
|
|
|
free(packed_refs_path);
|
tempfile: auto-allocate tempfiles on heap
The previous commit taught the tempfile code to give up
ownership over tempfiles that have been renamed or deleted.
That makes it possible to use a stack variable like this:
struct tempfile t;
create_tempfile(&t, ...);
...
if (!err)
rename_tempfile(&t, ...);
else
delete_tempfile(&t);
But doing it this way has a high potential for creating
memory errors. The tempfile we pass to create_tempfile()
ends up on a global linked list, and it's not safe for it to
go out of scope until we've called one of those two
deactivation functions.
Imagine that we add an early return from the function that
forgets to call delete_tempfile(). With a static or heap
tempfile variable, the worst case is that the tempfile hangs
around until the program exits (and some functions like
setup_shallow_temporary rely on this intentionally, creating
a tempfile and then leaving it for later cleanup).
But with a stack variable as above, this is a serious memory
error: the variable goes out of scope and may be filled with
garbage by the time the tempfile code looks at it. Let's
see if we can make it harder to get this wrong.
Since many callers need to allocate arbitrary numbers of
tempfiles, we can't rely on static storage as a general
solution. So we need to turn to the heap. We could just ask
all callers to pass us a heap variable, but that puts the
burden on them to call free() at the right time.
Instead, let's have the tempfile code handle the heap
allocation _and_ the deallocation (when the tempfile is
deactivated and removed from the list).
This changes the return value of all of the creation
functions. For the cleanup functions (delete and rename),
we'll add one extra bit of safety: instead of taking a
tempfile pointer, we'll take a pointer-to-pointer and set it
to NULL after freeing the object. This makes it safe to
double-call functions like delete_tempfile(), as the second
call treats the NULL input as a noop. Several callsites
follow this pattern.
The resulting patch does have a fair bit of noise, as each
caller needs to be converted to handle:
1. Storing a pointer instead of the struct itself.
2. Passing the pointer instead of taking the struct
address.
3. Handling a "struct tempfile *" return instead of a file
descriptor.
We could play games to make this less noisy. For example, by
defining the tempfile like this:
struct tempfile {
struct heap_allocated_part_of_tempfile {
int fd;
...etc
} *actual_data;
}
Callers would continue to have a "struct tempfile", and it
would be "active" only when the inner pointer was non-NULL.
But that just makes things more awkward in the long run.
There aren't that many callers, so we can simply bite
the bullet and adjust all of them. And the compiler makes it
easy for us to find them all.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-05 12:15:08 +00:00
|
|
|
refs->tempfile = create_tempfile(sb.buf);
|
|
|
|
if (!refs->tempfile) {
|
2017-06-23 07:01:40 +00:00
|
|
|
strbuf_addf(err, "unable to create file %s: %s",
|
|
|
|
sb.buf, strerror(errno));
|
|
|
|
strbuf_release(&sb);
|
2017-09-08 13:51:45 +00:00
|
|
|
return -1;
|
2017-06-23 07:01:40 +00:00
|
|
|
}
|
|
|
|
strbuf_release(&sb);
|
|
|
|
|
tempfile: auto-allocate tempfiles on heap
The previous commit taught the tempfile code to give up
ownership over tempfiles that have been renamed or deleted.
That makes it possible to use a stack variable like this:
struct tempfile t;
create_tempfile(&t, ...);
...
if (!err)
rename_tempfile(&t, ...);
else
delete_tempfile(&t);
But doing it this way has a high potential for creating
memory errors. The tempfile we pass to create_tempfile()
ends up on a global linked list, and it's not safe for it to
go out of scope until we've called one of those two
deactivation functions.
Imagine that we add an early return from the function that
forgets to call delete_tempfile(). With a static or heap
tempfile variable, the worst case is that the tempfile hangs
around until the program exits (and some functions like
setup_shallow_temporary rely on this intentionally, creating
a tempfile and then leaving it for later cleanup).
But with a stack variable as above, this is a serious memory
error: the variable goes out of scope and may be filled with
garbage by the time the tempfile code looks at it. Let's
see if we can make it harder to get this wrong.
Since many callers need to allocate arbitrary numbers of
tempfiles, we can't rely on static storage as a general
solution. So we need to turn to the heap. We could just ask
all callers to pass us a heap variable, but that puts the
burden on them to call free() at the right time.
Instead, let's have the tempfile code handle the heap
allocation _and_ the deallocation (when the tempfile is
deactivated and removed from the list).
This changes the return value of all of the creation
functions. For the cleanup functions (delete and rename),
we'll add one extra bit of safety: instead of taking a
tempfile pointer, we'll take a pointer-to-pointer and set it
to NULL after freeing the object. This makes it safe to
double-call functions like delete_tempfile(), as the second
call treats the NULL input as a noop. Several callsites
follow this pattern.
The resulting patch does have a fair bit of noise, as each
caller needs to be converted to handle:
1. Storing a pointer instead of the struct itself.
2. Passing the pointer instead of taking the struct
address.
3. Handling a "struct tempfile *" return instead of a file
descriptor.
We could play games to make this less noisy. For example, by
defining the tempfile like this:
struct tempfile {
struct heap_allocated_part_of_tempfile {
int fd;
...etc
} *actual_data;
}
Callers would continue to have a "struct tempfile", and it
would be "active" only when the inner pointer was non-NULL.
But that just makes things more awkward in the long run.
There aren't that many callers, so we can simply bite
the bullet and adjust all of them. And the compiler makes it
easy for us to find them all.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-05 12:15:08 +00:00
|
|
|
out = fdopen_tempfile(refs->tempfile, "w");
|
2017-06-23 07:01:39 +00:00
|
|
|
if (!out) {
|
|
|
|
strbuf_addf(err, "unable to fdopen packed-refs tempfile: %s",
|
|
|
|
strerror(errno));
|
|
|
|
goto error;
|
|
|
|
}
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-08 13:51:45 +00:00
|
|
|
if (fprintf(out, "%s", PACKED_REFS_HEADER) < 0)
|
|
|
|
goto write_error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We iterate in parallel through the current list of refs and
|
|
|
|
* the list of updates, processing an entry from at least one
|
|
|
|
* of the lists each time through the loop. When the current
|
|
|
|
* list of refs is exhausted, set iter to NULL. When the list
|
|
|
|
* of updates is exhausted, leave i set to updates->nr.
|
|
|
|
*/
|
|
|
|
iter = packed_ref_iterator_begin(&refs->base, "",
|
|
|
|
DO_FOR_EACH_INCLUDE_BROKEN);
|
|
|
|
if ((ok = ref_iterator_advance(iter)) != ITER_OK)
|
|
|
|
iter = NULL;
|
|
|
|
|
|
|
|
i = 0;
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-08 13:51:45 +00:00
|
|
|
while (iter || i < updates->nr) {
|
|
|
|
struct ref_update *update = NULL;
|
|
|
|
int cmp;
|
|
|
|
|
|
|
|
if (i >= updates->nr) {
|
|
|
|
cmp = -1;
|
|
|
|
} else {
|
|
|
|
update = updates->items[i].util;
|
|
|
|
|
|
|
|
if (!iter)
|
|
|
|
cmp = +1;
|
|
|
|
else
|
|
|
|
cmp = strcmp(iter->refname, update->refname);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!cmp) {
|
|
|
|
/*
|
|
|
|
* There is both an old value and an update
|
|
|
|
* for this reference. Check the old value if
|
|
|
|
* necessary:
|
|
|
|
*/
|
|
|
|
if ((update->flags & REF_HAVE_OLD)) {
|
|
|
|
if (is_null_oid(&update->old_oid)) {
|
|
|
|
strbuf_addf(err, "cannot update ref '%s': "
|
|
|
|
"reference already exists",
|
|
|
|
update->refname);
|
|
|
|
goto error;
|
2018-08-28 21:22:48 +00:00
|
|
|
} else if (!oideq(&update->old_oid, iter->oid)) {
|
2017-09-08 13:51:45 +00:00
|
|
|
strbuf_addf(err, "cannot update ref '%s': "
|
|
|
|
"is at %s but expected %s",
|
|
|
|
update->refname,
|
|
|
|
oid_to_hex(iter->oid),
|
|
|
|
oid_to_hex(&update->old_oid));
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now figure out what to use for the new value: */
|
|
|
|
if ((update->flags & REF_HAVE_NEW)) {
|
|
|
|
/*
|
|
|
|
* The update takes precedence. Skip
|
|
|
|
* the iterator over the unneeded
|
|
|
|
* value.
|
|
|
|
*/
|
|
|
|
if ((ok = ref_iterator_advance(iter)) != ITER_OK)
|
|
|
|
iter = NULL;
|
|
|
|
cmp = +1;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* The update doesn't actually want to
|
|
|
|
* change anything. We're done with it.
|
|
|
|
*/
|
|
|
|
i++;
|
|
|
|
cmp = -1;
|
|
|
|
}
|
|
|
|
} else if (cmp > 0) {
|
|
|
|
/*
|
|
|
|
* There is no old value but there is an
|
|
|
|
* update for this reference. Make sure that
|
|
|
|
* the update didn't expect an existing value:
|
|
|
|
*/
|
|
|
|
if ((update->flags & REF_HAVE_OLD) &&
|
|
|
|
!is_null_oid(&update->old_oid)) {
|
|
|
|
strbuf_addf(err, "cannot update ref '%s': "
|
|
|
|
"reference is missing but expected %s",
|
|
|
|
update->refname,
|
|
|
|
oid_to_hex(&update->old_oid));
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cmp < 0) {
|
|
|
|
/* Pass the old reference through. */
|
|
|
|
|
|
|
|
struct object_id peeled;
|
|
|
|
int peel_error = ref_iterator_peel(iter, &peeled);
|
|
|
|
|
|
|
|
if (write_packed_entry(out, iter->refname,
|
2017-11-05 08:42:08 +00:00
|
|
|
iter->oid,
|
|
|
|
peel_error ? NULL : &peeled))
|
2017-09-08 13:51:45 +00:00
|
|
|
goto write_error;
|
|
|
|
|
|
|
|
if ((ok = ref_iterator_advance(iter)) != ITER_OK)
|
|
|
|
iter = NULL;
|
|
|
|
} else if (is_null_oid(&update->new_oid)) {
|
|
|
|
/*
|
|
|
|
* The update wants to delete the reference,
|
|
|
|
* and the reference either didn't exist or we
|
|
|
|
* have already skipped it. So we're done with
|
|
|
|
* the update (and don't have to write
|
|
|
|
* anything).
|
|
|
|
*/
|
|
|
|
i++;
|
|
|
|
} else {
|
|
|
|
struct object_id peeled;
|
2017-10-15 22:07:10 +00:00
|
|
|
int peel_error = peel_object(&update->new_oid,
|
|
|
|
&peeled);
|
2017-09-08 13:51:45 +00:00
|
|
|
|
|
|
|
if (write_packed_entry(out, update->refname,
|
2017-11-05 08:42:08 +00:00
|
|
|
&update->new_oid,
|
|
|
|
peel_error ? NULL : &peeled))
|
2017-09-08 13:51:45 +00:00
|
|
|
goto write_error;
|
|
|
|
|
|
|
|
i++;
|
2017-06-23 07:01:39 +00:00
|
|
|
}
|
2017-06-23 07:01:37 +00:00
|
|
|
}
|
|
|
|
|
2017-06-23 07:01:39 +00:00
|
|
|
if (ok != ITER_DONE) {
|
2017-10-01 14:44:20 +00:00
|
|
|
strbuf_addstr(err, "unable to write packed-refs file: "
|
|
|
|
"error iterating over old contents");
|
2017-06-23 07:01:39 +00:00
|
|
|
goto error;
|
|
|
|
}
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2022-12-20 14:52:14 +00:00
|
|
|
if (fflush(out) ||
|
|
|
|
fsync_component(FSYNC_COMPONENT_REFERENCE, get_tempfile_fd(refs->tempfile)) ||
|
2022-03-11 09:58:59 +00:00
|
|
|
close_tempfile_gently(refs->tempfile)) {
|
2017-09-08 13:51:45 +00:00
|
|
|
strbuf_addf(err, "error closing file %s: %s",
|
2017-09-19 01:47:56 +00:00
|
|
|
get_tempfile_path(refs->tempfile),
|
2017-09-08 13:51:45 +00:00
|
|
|
strerror(errno));
|
|
|
|
strbuf_release(&sb);
|
2017-09-19 01:47:56 +00:00
|
|
|
delete_tempfile(&refs->tempfile);
|
2017-09-08 13:51:45 +00:00
|
|
|
return -1;
|
2017-06-23 07:01:37 +00:00
|
|
|
}
|
2017-06-23 07:01:39 +00:00
|
|
|
|
2017-09-08 13:51:45 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
write_error:
|
|
|
|
strbuf_addf(err, "error writing to %s: %s",
|
2017-09-19 01:47:56 +00:00
|
|
|
get_tempfile_path(refs->tempfile), strerror(errno));
|
2017-06-23 07:01:39 +00:00
|
|
|
|
|
|
|
error:
|
2017-09-08 13:51:45 +00:00
|
|
|
if (iter)
|
|
|
|
ref_iterator_abort(iter);
|
2017-07-26 23:39:42 +00:00
|
|
|
|
2017-09-08 13:51:45 +00:00
|
|
|
delete_tempfile(&refs->tempfile);
|
|
|
|
return -1;
|
2017-06-23 07:01:37 +00:00
|
|
|
}
|
|
|
|
|
files-backend: don't rewrite the `packed-refs` file unnecessarily
Even when we are deleting references, we needn't overwrite the
`packed-refs` file if the references that we are deleting only exist
as loose references. Implement this optimization as follows:
* Add a function `is_packed_transaction_needed()`, which checks
whether a given packed-refs transaction actually needs to be carried
out (i.e., it returns false if the transaction obviously wouldn't
have any effect). This function must be called while holding the
`packed-refs` lock to avoid races.
* Change `files_transaction_prepare()` to check whether the
packed-refs transaction is actually needed. If not, squelch it, but
continue holding the `packed-refs` lock until the end of the
transaction to avoid races.
This fixes a mild regression caused by dc39e09942 (files_ref_store:
use a transaction to update packed refs, 2017-09-08). Before that
commit, unnecessary rewrites of `packed-refs` were suppressed by
`repack_without_refs()`. But the transaction-based writing introduced
by that commit didn't perform that optimization.
Note that the pre-dc39e09942 code still had to *read* the whole
`packed-refs` file to determine that the rewrite could be skipped, so
the performance for the cases that the write could be elided was
`O(N)` in the number of packed references both before and after
dc39e09942. But after that commit the constant factor increased.
This commit reimplements the optimization of eliding unnecessary
`packed-refs` rewrites. That, plus the fact that since
cfa2e29c34 (packed_ref_store: get rid of the `ref_cache` entirely,
2017-03-17) we don't necessarily have to read the whole `packed-refs`
file at all, means that deletes of one or a few loose references can
now be done with `O(n lg N)` effort, where `n` is the number of loose
references being deleted and `N` is the total number of packed
references.
This commit fixes two tests in t1409.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-10-28 09:16:02 +00:00
|
|
|
int is_packed_transaction_needed(struct ref_store *ref_store,
|
|
|
|
struct ref_transaction *transaction)
|
|
|
|
{
|
|
|
|
struct packed_ref_store *refs = packed_downcast(
|
|
|
|
ref_store,
|
|
|
|
REF_STORE_READ,
|
|
|
|
"is_packed_transaction_needed");
|
|
|
|
struct strbuf referent = STRBUF_INIT;
|
|
|
|
size_t i;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!is_lock_file_locked(&refs->lock))
|
|
|
|
BUG("is_packed_transaction_needed() called while unlocked");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We're only going to bother returning false for the common,
|
|
|
|
* trivial case that references are only being deleted, their
|
|
|
|
* old values are not being checked, and the old `packed-refs`
|
|
|
|
* file doesn't contain any of those reference(s). This gives
|
|
|
|
* false positives for some other cases that could
|
|
|
|
* theoretically be optimized away:
|
|
|
|
*
|
|
|
|
* 1. It could be that the old value is being verified without
|
|
|
|
* setting a new value. In this case, we could verify the
|
|
|
|
* old value here and skip the update if it agrees. If it
|
|
|
|
* disagrees, we could either let the update go through
|
|
|
|
* (the actual commit would re-detect and report the
|
|
|
|
* problem), or come up with a way of reporting such an
|
|
|
|
* error to *our* caller.
|
|
|
|
*
|
|
|
|
* 2. It could be that a new value is being set, but that it
|
|
|
|
* is identical to the current packed value of the
|
|
|
|
* reference.
|
|
|
|
*
|
|
|
|
* Neither of these cases will come up in the current code,
|
|
|
|
* because the only caller of this function passes to it a
|
|
|
|
* transaction that only includes `delete` updates with no
|
|
|
|
* `old_id`. Even if that ever changes, false positives only
|
|
|
|
* cause an optimization to be missed; they do not affect
|
|
|
|
* correctness.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Start with the cheap checks that don't require old
|
|
|
|
* reference values to be read:
|
|
|
|
*/
|
|
|
|
for (i = 0; i < transaction->nr; i++) {
|
|
|
|
struct ref_update *update = transaction->updates[i];
|
|
|
|
|
|
|
|
if (update->flags & REF_HAVE_OLD)
|
|
|
|
/* Have to check the old value -> needed. */
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if ((update->flags & REF_HAVE_NEW) && !is_null_oid(&update->new_oid))
|
|
|
|
/* Have to set a new value -> needed. */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The transaction isn't checking any old values nor is it
|
|
|
|
* setting any nonzero new values, so it still might be able
|
|
|
|
* to be skipped. Now do the more expensive check: the update
|
|
|
|
* is needed if any of the updates is a delete, and the old
|
|
|
|
* `packed-refs` file contains a value for that reference.
|
|
|
|
*/
|
|
|
|
ret = 0;
|
|
|
|
for (i = 0; i < transaction->nr; i++) {
|
|
|
|
struct ref_update *update = transaction->updates[i];
|
2021-10-16 09:39:09 +00:00
|
|
|
int failure_errno;
|
files-backend: don't rewrite the `packed-refs` file unnecessarily
Even when we are deleting references, we needn't overwrite the
`packed-refs` file if the references that we are deleting only exist
as loose references. Implement this optimization as follows:
* Add a function `is_packed_transaction_needed()`, which checks
whether a given packed-refs transaction actually needs to be carried
out (i.e., it returns false if the transaction obviously wouldn't
have any effect). This function must be called while holding the
`packed-refs` lock to avoid races.
* Change `files_transaction_prepare()` to check whether the
packed-refs transaction is actually needed. If not, squelch it, but
continue holding the `packed-refs` lock until the end of the
transaction to avoid races.
This fixes a mild regression caused by dc39e09942 (files_ref_store:
use a transaction to update packed refs, 2017-09-08). Before that
commit, unnecessary rewrites of `packed-refs` were suppressed by
`repack_without_refs()`. But the transaction-based writing introduced
by that commit didn't perform that optimization.
Note that the pre-dc39e09942 code still had to *read* the whole
`packed-refs` file to determine that the rewrite could be skipped, so
the performance for the cases that the write could be elided was
`O(N)` in the number of packed references both before and after
dc39e09942. But after that commit the constant factor increased.
This commit reimplements the optimization of eliding unnecessary
`packed-refs` rewrites. That, plus the fact that since
cfa2e29c34 (packed_ref_store: get rid of the `ref_cache` entirely,
2017-03-17) we don't necessarily have to read the whole `packed-refs`
file at all, means that deletes of one or a few loose references can
now be done with `O(n lg N)` effort, where `n` is the number of loose
references being deleted and `N` is the total number of packed
references.
This commit fixes two tests in t1409.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-10-28 09:16:02 +00:00
|
|
|
unsigned int type;
|
|
|
|
struct object_id oid;
|
|
|
|
|
|
|
|
if (!(update->flags & REF_HAVE_NEW))
|
|
|
|
/*
|
|
|
|
* This reference isn't being deleted -> not
|
|
|
|
* needed.
|
|
|
|
*/
|
|
|
|
continue;
|
|
|
|
|
2021-10-16 09:39:09 +00:00
|
|
|
if (!refs_read_raw_ref(ref_store, update->refname, &oid,
|
|
|
|
&referent, &type, &failure_errno) ||
|
|
|
|
failure_errno != ENOENT) {
|
files-backend: don't rewrite the `packed-refs` file unnecessarily
Even when we are deleting references, we needn't overwrite the
`packed-refs` file if the references that we are deleting only exist
as loose references. Implement this optimization as follows:
* Add a function `is_packed_transaction_needed()`, which checks
whether a given packed-refs transaction actually needs to be carried
out (i.e., it returns false if the transaction obviously wouldn't
have any effect). This function must be called while holding the
`packed-refs` lock to avoid races.
* Change `files_transaction_prepare()` to check whether the
packed-refs transaction is actually needed. If not, squelch it, but
continue holding the `packed-refs` lock until the end of the
transaction to avoid races.
This fixes a mild regression caused by dc39e09942 (files_ref_store:
use a transaction to update packed refs, 2017-09-08). Before that
commit, unnecessary rewrites of `packed-refs` were suppressed by
`repack_without_refs()`. But the transaction-based writing introduced
by that commit didn't perform that optimization.
Note that the pre-dc39e09942 code still had to *read* the whole
`packed-refs` file to determine that the rewrite could be skipped, so
the performance for the cases that the write could be elided was
`O(N)` in the number of packed references both before and after
dc39e09942. But after that commit the constant factor increased.
This commit reimplements the optimization of eliding unnecessary
`packed-refs` rewrites. That, plus the fact that since
cfa2e29c34 (packed_ref_store: get rid of the `ref_cache` entirely,
2017-03-17) we don't necessarily have to read the whole `packed-refs`
file at all, means that deletes of one or a few loose references can
now be done with `O(n lg N)` effort, where `n` is the number of loose
references being deleted and `N` is the total number of packed
references.
This commit fixes two tests in t1409.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-10-28 09:16:02 +00:00
|
|
|
/*
|
|
|
|
* We have to actually delete that reference
|
|
|
|
* -> this transaction is needed.
|
|
|
|
*/
|
|
|
|
ret = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_release(&referent);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-09-08 13:51:45 +00:00
|
|
|
struct packed_transaction_backend_data {
|
|
|
|
/* True iff the transaction owns the packed-refs lock. */
|
|
|
|
int own_lock;
|
|
|
|
|
|
|
|
struct string_list updates;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void packed_transaction_cleanup(struct packed_ref_store *refs,
|
|
|
|
struct ref_transaction *transaction)
|
2017-06-23 07:01:37 +00:00
|
|
|
{
|
2017-09-08 13:51:45 +00:00
|
|
|
struct packed_transaction_backend_data *data = transaction->backend_data;
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-08 13:51:45 +00:00
|
|
|
if (data) {
|
|
|
|
string_list_clear(&data->updates, 0);
|
2017-06-23 07:01:37 +00:00
|
|
|
|
2017-09-19 01:47:56 +00:00
|
|
|
if (is_tempfile_active(refs->tempfile))
|
2017-09-08 13:51:45 +00:00
|
|
|
delete_tempfile(&refs->tempfile);
|
2017-07-01 18:31:06 +00:00
|
|
|
|
2017-09-08 13:51:45 +00:00
|
|
|
if (data->own_lock && is_lock_file_locked(&refs->lock)) {
|
|
|
|
packed_refs_unlock(&refs->base);
|
|
|
|
data->own_lock = 0;
|
2017-06-23 07:01:37 +00:00
|
|
|
}
|
|
|
|
|
2017-09-08 13:51:45 +00:00
|
|
|
free(data);
|
|
|
|
transaction->backend_data = NULL;
|
2017-06-23 07:01:37 +00:00
|
|
|
}
|
|
|
|
|
2017-09-08 13:51:45 +00:00
|
|
|
transaction->state = REF_TRANSACTION_CLOSED;
|
2017-06-23 07:01:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int packed_transaction_prepare(struct ref_store *ref_store,
|
|
|
|
struct ref_transaction *transaction,
|
|
|
|
struct strbuf *err)
|
|
|
|
{
|
2017-09-08 13:51:45 +00:00
|
|
|
struct packed_ref_store *refs = packed_downcast(
|
|
|
|
ref_store,
|
|
|
|
REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,
|
|
|
|
"ref_transaction_prepare");
|
|
|
|
struct packed_transaction_backend_data *data;
|
|
|
|
size_t i;
|
|
|
|
int ret = TRANSACTION_GENERIC_ERROR;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note that we *don't* skip transactions with zero updates,
|
|
|
|
* because such a transaction might be executed for the side
|
2017-09-25 08:00:18 +00:00
|
|
|
* effect of ensuring that all of the references are peeled or
|
|
|
|
* ensuring that the `packed-refs` file is sorted. If the
|
|
|
|
* caller wants to optimize away empty transactions, it should
|
|
|
|
* do so itself.
|
2017-09-08 13:51:45 +00:00
|
|
|
*/
|
|
|
|
|
2021-03-13 16:17:22 +00:00
|
|
|
CALLOC_ARRAY(data, 1);
|
2021-07-01 10:51:29 +00:00
|
|
|
string_list_init_nodup(&data->updates);
|
2017-09-08 13:51:45 +00:00
|
|
|
|
|
|
|
transaction->backend_data = data;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Stick the updates in a string list by refname so that we
|
|
|
|
* can sort them:
|
|
|
|
*/
|
|
|
|
for (i = 0; i < transaction->nr; i++) {
|
|
|
|
struct ref_update *update = transaction->updates[i];
|
|
|
|
struct string_list_item *item =
|
|
|
|
string_list_append(&data->updates, update->refname);
|
|
|
|
|
|
|
|
/* Store a pointer to update in item->util: */
|
|
|
|
item->util = update;
|
|
|
|
}
|
|
|
|
string_list_sort(&data->updates);
|
|
|
|
|
|
|
|
if (ref_update_reject_duplicates(&data->updates, err))
|
|
|
|
goto failure;
|
|
|
|
|
|
|
|
if (!is_lock_file_locked(&refs->lock)) {
|
|
|
|
if (packed_refs_lock(ref_store, 0, err))
|
|
|
|
goto failure;
|
|
|
|
data->own_lock = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (write_with_updates(refs, &data->updates, err))
|
|
|
|
goto failure;
|
|
|
|
|
|
|
|
transaction->state = REF_TRANSACTION_PREPARED;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
failure:
|
|
|
|
packed_transaction_cleanup(refs, transaction);
|
|
|
|
return ret;
|
2017-06-23 07:01:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int packed_transaction_abort(struct ref_store *ref_store,
|
|
|
|
struct ref_transaction *transaction,
|
2022-08-25 17:09:48 +00:00
|
|
|
struct strbuf *err UNUSED)
|
2017-06-23 07:01:38 +00:00
|
|
|
{
|
2017-09-08 13:51:45 +00:00
|
|
|
struct packed_ref_store *refs = packed_downcast(
|
|
|
|
ref_store,
|
|
|
|
REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,
|
|
|
|
"ref_transaction_abort");
|
|
|
|
|
|
|
|
packed_transaction_cleanup(refs, transaction);
|
|
|
|
return 0;
|
2017-06-23 07:01:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int packed_transaction_finish(struct ref_store *ref_store,
|
|
|
|
struct ref_transaction *transaction,
|
|
|
|
struct strbuf *err)
|
|
|
|
{
|
2017-09-08 13:51:45 +00:00
|
|
|
struct packed_ref_store *refs = packed_downcast(
|
|
|
|
ref_store,
|
|
|
|
REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,
|
|
|
|
"ref_transaction_finish");
|
|
|
|
int ret = TRANSACTION_GENERIC_ERROR;
|
|
|
|
char *packed_refs_path;
|
|
|
|
|
2017-09-25 08:00:18 +00:00
|
|
|
clear_snapshot(refs);
|
2017-09-25 08:00:10 +00:00
|
|
|
|
2017-09-08 13:51:45 +00:00
|
|
|
packed_refs_path = get_locked_file_path(&refs->lock);
|
|
|
|
if (rename_tempfile(&refs->tempfile, packed_refs_path)) {
|
|
|
|
strbuf_addf(err, "error replacing %s: %s",
|
|
|
|
refs->path, strerror(errno));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
free(packed_refs_path);
|
|
|
|
packed_transaction_cleanup(refs, transaction);
|
|
|
|
return ret;
|
2017-06-23 07:01:38 +00:00
|
|
|
}
|
|
|
|
|
2022-08-25 17:09:48 +00:00
|
|
|
static int packed_initial_transaction_commit(struct ref_store *ref_store UNUSED,
|
2017-06-23 07:01:38 +00:00
|
|
|
struct ref_transaction *transaction,
|
|
|
|
struct strbuf *err)
|
|
|
|
{
|
|
|
|
return ref_transaction_commit(transaction, err);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int packed_delete_refs(struct ref_store *ref_store, const char *msg,
|
|
|
|
struct string_list *refnames, unsigned int flags)
|
|
|
|
{
|
2022-04-13 22:51:33 +00:00
|
|
|
struct packed_ref_store *refs =
|
|
|
|
packed_downcast(ref_store, REF_STORE_WRITE, "delete_refs");
|
2017-09-08 13:51:46 +00:00
|
|
|
struct strbuf err = STRBUF_INIT;
|
|
|
|
struct ref_transaction *transaction;
|
2022-04-13 22:51:33 +00:00
|
|
|
struct string_list_item *item;
|
2017-09-08 13:51:46 +00:00
|
|
|
int ret;
|
|
|
|
|
2022-04-13 22:51:33 +00:00
|
|
|
(void)refs; /* We need the check above, but don't use the variable */
|
|
|
|
|
2017-09-08 13:51:46 +00:00
|
|
|
if (!refnames->nr)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since we don't check the references' old_oids, the
|
|
|
|
* individual updates can't fail, so we can pack all of the
|
|
|
|
* updates into a single transaction.
|
|
|
|
*/
|
|
|
|
|
2022-04-13 22:51:33 +00:00
|
|
|
transaction = ref_store_transaction_begin(ref_store, &err);
|
2017-09-08 13:51:46 +00:00
|
|
|
if (!transaction)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
for_each_string_list_item(item, refnames) {
|
|
|
|
if (ref_transaction_delete(transaction, item->string, NULL,
|
|
|
|
flags, msg, &err)) {
|
|
|
|
warning(_("could not delete reference %s: %s"),
|
|
|
|
item->string, err.buf);
|
|
|
|
strbuf_reset(&err);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ref_transaction_commit(transaction, &err);
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
if (refnames->nr == 1)
|
|
|
|
error(_("could not delete reference %s: %s"),
|
|
|
|
refnames->items[0].string, err.buf);
|
|
|
|
else
|
|
|
|
error(_("could not delete references: %s"), err.buf);
|
|
|
|
}
|
|
|
|
|
2022-04-13 22:51:33 +00:00
|
|
|
ref_transaction_free(transaction);
|
2017-09-08 13:51:46 +00:00
|
|
|
strbuf_release(&err);
|
|
|
|
return ret;
|
2017-06-23 07:01:38 +00:00
|
|
|
}
|
|
|
|
|
2022-08-25 17:09:48 +00:00
|
|
|
static int packed_pack_refs(struct ref_store *ref_store UNUSED,
|
|
|
|
unsigned int flags UNUSED)
|
2017-06-23 07:01:38 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Packed refs are already packed. It might be that loose refs
|
|
|
|
* are packed *into* a packed refs store, but that is done by
|
|
|
|
* updating the packed references via a transaction.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-08-25 17:09:48 +00:00
|
|
|
static struct ref_iterator *packed_reflog_iterator_begin(struct ref_store *ref_store UNUSED)
|
2017-06-23 07:01:38 +00:00
|
|
|
{
|
|
|
|
return empty_ref_iterator_begin();
|
|
|
|
}
|
|
|
|
|
|
|
|
struct ref_storage_be refs_be_packed = {
|
2022-03-17 17:27:15 +00:00
|
|
|
.next = NULL,
|
|
|
|
.name = "packed",
|
|
|
|
.init = packed_ref_store_create,
|
|
|
|
.init_db = packed_init_db,
|
|
|
|
.transaction_prepare = packed_transaction_prepare,
|
|
|
|
.transaction_finish = packed_transaction_finish,
|
|
|
|
.transaction_abort = packed_transaction_abort,
|
|
|
|
.initial_transaction_commit = packed_initial_transaction_commit,
|
|
|
|
|
|
|
|
.pack_refs = packed_pack_refs,
|
2022-03-17 17:27:18 +00:00
|
|
|
.create_symref = NULL,
|
2022-03-17 17:27:15 +00:00
|
|
|
.delete_refs = packed_delete_refs,
|
2022-03-17 17:27:18 +00:00
|
|
|
.rename_ref = NULL,
|
|
|
|
.copy_ref = NULL,
|
2022-03-17 17:27:15 +00:00
|
|
|
|
|
|
|
.iterator_begin = packed_ref_iterator_begin,
|
|
|
|
.read_raw_ref = packed_read_raw_ref,
|
|
|
|
.read_symbolic_ref = NULL,
|
|
|
|
|
|
|
|
.reflog_iterator_begin = packed_reflog_iterator_begin,
|
2022-03-17 17:27:18 +00:00
|
|
|
.for_each_reflog_ent = NULL,
|
|
|
|
.for_each_reflog_ent_reverse = NULL,
|
|
|
|
.reflog_exists = NULL,
|
|
|
|
.create_reflog = NULL,
|
|
|
|
.delete_reflog = NULL,
|
|
|
|
.reflog_expire = NULL,
|
2017-06-23 07:01:38 +00:00
|
|
|
};
|