From: Junio C Hamano <gitster@pobox.com>
Date: Tue, 3 Oct 2017 06:42:48 +0000 (+0900)
Subject: Merge branch 'sd/branch-copy'
X-Git-Tag: v2.15.0-rc0~24
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/3b48045c6c73a51834a2f83440a30225485ee431

Merge branch 'sd/branch-copy'

"git branch" learned "-c/-C" to create a new branch by copying an
existing one.

* sd/branch-copy:
branch: fix "copy" to never touch HEAD
branch: add a --copy (-c) option to go with --move (-m)
branch: add test for -m renaming multiple config sections
config: create a function to format section headers
---

3b48045c6c73a51834a2f83440a30225485ee431
diff --cc config.c
index 345d78c2ba,d0d5aa1dc5..4831c12735
--- a/config.c
+++ b/config.c
@@@ -2312,16 -2188,24 +2311,24 @@@ static struct strbuf store_create_secti
  		strbuf_addf(&sb, "[%.*s]\n", store.baselen, key);
  	}
  
- 	ret = write_in_full(fd, sb.buf, sb.len);
+ 	return sb;
+ }
+ 
 -static int store_write_section(int fd, const char *key)
++static ssize_t write_section(int fd, const char *key)
+ {
 -	int success;
 -
+ 	struct strbuf sb = store_create_section(key);
++	ssize_t ret;
+ 
 -	success = write_in_full(fd, sb.buf, sb.len) == sb.len;
++	ret = write_in_full(fd, sb.buf, sb.len) == sb.len;
  	strbuf_release(&sb);
  
 -	return success;
 +	return ret;
  }
  
 -static int store_write_pair(int fd, const char *key, const char *value)
 +static ssize_t write_pair(int fd, const char *key, const char *value)
  {
 -	int i, success;
 +	int i;
 +	ssize_t ret;
  	int length = strlen(key + store.baselen + 1);
  	const char *quote = "";
  	struct strbuf sb = STRBUF_INIT;
@@@ -2804,25 -2715,30 +2830,29 @@@ static int git_config_copy_or_rename_se
  					continue;
  				}
  				store.baselen = strlen(new_name);
- 				if (write_section(out_fd, new_name) < 0) {
- 					ret = write_error(get_lock_file_path(lock));
- 					goto out;
- 				}
- 				/*
- 				 * We wrote out the new section, with
- 				 * a newline, now skip the old
- 				 * section's length
- 				 */
- 				output += offset + i;
- 				if (strlen(output) > 0) {
+ 				if (!copy) {
 -					if (!store_write_section(out_fd, new_name)) {
++					if (write_section(out_fd, new_name) < 0) {
+ 						ret = write_error(get_lock_file_path(lock));
+ 						goto out;
+ 					}
 -
  					/*
- 					 * More content means there's
- 					 * a declaration to put on the
- 					 * next line; indent with a
- 					 * tab
+ 					 * We wrote out the new section, with
+ 					 * a newline, now skip the old
+ 					 * section's length
  					 */
- 					output -= 1;
- 					output[0] = '\t';
+ 					output += offset + i;
+ 					if (strlen(output) > 0) {
+ 						/*
+ 						 * More content means there's
+ 						 * a declaration to put on the
+ 						 * next line; indent with a
+ 						 * tab
+ 						 */
+ 						output -= 1;
+ 						output[0] = '\t';
+ 					}
+ 				} else {
+ 					copystr = store_create_section(new_name);
  				}
  			}
  			remove = 0;
@@@ -2830,7 -2746,12 +2860,12 @@@
  		if (remove)
  			continue;
  		length = strlen(output);
+ 
+ 		if (!is_section && copystr.len > 0) {
+ 			strbuf_add(&copystr, output, length);
+ 		}
+ 
 -		if (write_in_full(out_fd, output, length) != length) {
 +		if (write_in_full(out_fd, output, length) < 0) {
  			ret = write_error(get_lock_file_path(lock));
  			goto out;
  		}
diff --cc config.h
index 456b3d134d,0000000000..a49d264416
mode 100644,000000..100644
--- a/config.h
+++ b/config.h
@@@ -1,230 -1,0 +1,232 @@@
 +#ifndef CONFIG_H
 +#define CONFIG_H
 +
 +/* git_config_parse_key() returns these negated: */
 +#define CONFIG_INVALID_KEY 1
 +#define CONFIG_NO_SECTION_OR_NAME 2
 +/* git_config_set_gently(), git_config_set_multivar_gently() return the above or these: */
 +#define CONFIG_NO_LOCK -1
 +#define CONFIG_INVALID_FILE 3
 +#define CONFIG_NO_WRITE 4
 +#define CONFIG_NOTHING_SET 5
 +#define CONFIG_INVALID_PATTERN 6
 +#define CONFIG_GENERIC_ERROR 7
 +
 +#define CONFIG_REGEX_NONE ((void *)1)
 +
 +struct git_config_source {
 +	unsigned int use_stdin:1;
 +	const char *file;
 +	const char *blob;
 +};
 +
 +enum config_origin_type {
 +	CONFIG_ORIGIN_BLOB,
 +	CONFIG_ORIGIN_FILE,
 +	CONFIG_ORIGIN_STDIN,
 +	CONFIG_ORIGIN_SUBMODULE_BLOB,
 +	CONFIG_ORIGIN_CMDLINE
 +};
 +
 +struct config_options {
 +	unsigned int respect_includes : 1;
 +	const char *commondir;
 +	const char *git_dir;
 +};
 +
 +typedef int (*config_fn_t)(const char *, const char *, void *);
 +extern int git_default_config(const char *, const char *, void *);
 +extern int git_config_from_file(config_fn_t fn, const char *, void *);
 +extern int git_config_from_mem(config_fn_t fn, const enum config_origin_type,
 +					const char *name, const char *buf, size_t len, void *data);
 +extern int git_config_from_blob_oid(config_fn_t fn, const char *name,
 +				    const struct object_id *oid, void *data);
 +extern void git_config_push_parameter(const char *text);
 +extern int git_config_from_parameters(config_fn_t fn, void *data);
 +extern void read_early_config(config_fn_t cb, void *data);
 +extern void git_config(config_fn_t fn, void *);
 +extern int config_with_options(config_fn_t fn, void *,
 +			       struct git_config_source *config_source,
 +			       const struct config_options *opts);
 +extern int git_parse_ulong(const char *, unsigned long *);
 +extern int git_parse_maybe_bool(const char *);
 +extern int git_config_int(const char *, const char *);
 +extern int64_t git_config_int64(const char *, const char *);
 +extern unsigned long git_config_ulong(const char *, const char *);
 +extern ssize_t git_config_ssize_t(const char *, const char *);
 +extern int git_config_bool_or_int(const char *, const char *, int *);
 +extern int git_config_bool(const char *, const char *);
 +extern int git_config_string(const char **, const char *, const char *);
 +extern int git_config_pathname(const char **, const char *, const char *);
 +extern int git_config_set_in_file_gently(const char *, const char *, const char *);
 +extern void git_config_set_in_file(const char *, const char *, const char *);
 +extern int git_config_set_gently(const char *, const char *);
 +extern void git_config_set(const char *, const char *);
 +extern int git_config_parse_key(const char *, char **, int *);
 +extern int git_config_key_is_valid(const char *key);
 +extern int git_config_set_multivar_gently(const char *, const char *, const char *, int);
 +extern void git_config_set_multivar(const char *, const char *, const char *, int);
 +extern int git_config_set_multivar_in_file_gently(const char *, const char *, const char *, const char *, int);
 +extern void git_config_set_multivar_in_file(const char *, const char *, const char *, const char *, int);
 +extern int git_config_rename_section(const char *, const char *);
 +extern int git_config_rename_section_in_file(const char *, const char *, const char *);
++extern int git_config_copy_section(const char *, const char *);
++extern int git_config_copy_section_in_file(const char *, const char *, const char *);
 +extern const char *git_etc_gitconfig(void);
 +extern int git_env_bool(const char *, int);
 +extern unsigned long git_env_ulong(const char *, unsigned long);
 +extern int git_config_system(void);
 +extern int config_error_nonbool(const char *);
 +#if defined(__GNUC__)
 +#define config_error_nonbool(s) (config_error_nonbool(s), const_error())
 +#endif
 +
 +extern int git_config_parse_parameter(const char *, config_fn_t fn, void *data);
 +
 +enum config_scope {
 +	CONFIG_SCOPE_UNKNOWN = 0,
 +	CONFIG_SCOPE_SYSTEM,
 +	CONFIG_SCOPE_GLOBAL,
 +	CONFIG_SCOPE_REPO,
 +	CONFIG_SCOPE_CMDLINE,
 +};
 +
 +extern enum config_scope current_config_scope(void);
 +extern const char *current_config_origin_type(void);
 +extern const char *current_config_name(void);
 +
 +struct config_include_data {
 +	int depth;
 +	config_fn_t fn;
 +	void *data;
 +	const struct config_options *opts;
 +};
 +#define CONFIG_INCLUDE_INIT { 0 }
 +extern int git_config_include(const char *name, const char *value, void *data);
 +
 +/*
 + * Match and parse a config key of the form:
 + *
 + *   section.(subsection.)?key
 + *
 + * (i.e., what gets handed to a config_fn_t). The caller provides the section;
 + * we return -1 if it does not match, 0 otherwise. The subsection and key
 + * out-parameters are filled by the function (and *subsection is NULL if it is
 + * missing).
 + *
 + * If the subsection pointer-to-pointer passed in is NULL, returns 0 only if
 + * there is no subsection at all.
 + */
 +extern int parse_config_key(const char *var,
 +			    const char *section,
 +			    const char **subsection, int *subsection_len,
 +			    const char **key);
 +
 +struct config_set_element {
 +	struct hashmap_entry ent;
 +	char *key;
 +	struct string_list value_list;
 +};
 +
 +struct configset_list_item {
 +	struct config_set_element *e;
 +	int value_index;
 +};
 +
 +/*
 + * the contents of the list are ordered according to their
 + * position in the config files and order of parsing the files.
 + * (i.e. key-value pair at the last position of .git/config will
 + * be at the last item of the list)
 + */
 +struct configset_list {
 +	struct configset_list_item *items;
 +	unsigned int nr, alloc;
 +};
 +
 +struct config_set {
 +	struct hashmap config_hash;
 +	int hash_initialized;
 +	struct configset_list list;
 +};
 +
 +extern void git_configset_init(struct config_set *cs);
 +extern int git_configset_add_file(struct config_set *cs, const char *filename);
 +extern int git_configset_get_value(struct config_set *cs, const char *key, const char **value);
 +extern const struct string_list *git_configset_get_value_multi(struct config_set *cs, const char *key);
 +extern void git_configset_clear(struct config_set *cs);
 +extern int git_configset_get_string_const(struct config_set *cs, const char *key, const char **dest);
 +extern int git_configset_get_string(struct config_set *cs, const char *key, char **dest);
 +extern int git_configset_get_int(struct config_set *cs, const char *key, int *dest);
 +extern int git_configset_get_ulong(struct config_set *cs, const char *key, unsigned long *dest);
 +extern int git_configset_get_bool(struct config_set *cs, const char *key, int *dest);
 +extern int git_configset_get_bool_or_int(struct config_set *cs, const char *key, int *is_bool, int *dest);
 +extern int git_configset_get_maybe_bool(struct config_set *cs, const char *key, int *dest);
 +extern int git_configset_get_pathname(struct config_set *cs, const char *key, const char **dest);
 +
 +/* Functions for reading a repository's config */
 +struct repository;
 +extern void repo_config(struct repository *repo, config_fn_t fn, void *data);
 +extern int repo_config_get_value(struct repository *repo,
 +				 const char *key, const char **value);
 +extern const struct string_list *repo_config_get_value_multi(struct repository *repo,
 +							     const char *key);
 +extern int repo_config_get_string_const(struct repository *repo,
 +					const char *key, const char **dest);
 +extern int repo_config_get_string(struct repository *repo,
 +				  const char *key, char **dest);
 +extern int repo_config_get_int(struct repository *repo,
 +			       const char *key, int *dest);
 +extern int repo_config_get_ulong(struct repository *repo,
 +				 const char *key, unsigned long *dest);
 +extern int repo_config_get_bool(struct repository *repo,
 +				const char *key, int *dest);
 +extern int repo_config_get_bool_or_int(struct repository *repo,
 +				       const char *key, int *is_bool, int *dest);
 +extern int repo_config_get_maybe_bool(struct repository *repo,
 +				      const char *key, int *dest);
 +extern int repo_config_get_pathname(struct repository *repo,
 +				    const char *key, const char **dest);
 +
 +/*
 + * Note: This function exists solely to maintain backward compatibility with
 + * 'fetch' and 'update_clone' storing configuration in '.gitmodules' and should
 + * NOT be used anywhere else.
 + *
 + * Runs the provided config function on the '.gitmodules' file found in the
 + * working directory.
 + */
 +extern void config_from_gitmodules(config_fn_t fn, void *data);
 +
 +extern int git_config_get_value(const char *key, const char **value);
 +extern const struct string_list *git_config_get_value_multi(const char *key);
 +extern void git_config_clear(void);
 +extern int git_config_get_string_const(const char *key, const char **dest);
 +extern int git_config_get_string(const char *key, char **dest);
 +extern int git_config_get_int(const char *key, int *dest);
 +extern int git_config_get_ulong(const char *key, unsigned long *dest);
 +extern int git_config_get_bool(const char *key, int *dest);
 +extern int git_config_get_bool_or_int(const char *key, int *is_bool, int *dest);
 +extern int git_config_get_maybe_bool(const char *key, int *dest);
 +extern int git_config_get_pathname(const char *key, const char **dest);
 +extern int git_config_get_untracked_cache(void);
 +extern int git_config_get_split_index(void);
 +extern int git_config_get_max_percent_split_change(void);
 +
 +/* This dies if the configured or default date is in the future */
 +extern int git_config_get_expiry(const char *key, const char **output);
 +
 +/* parse either "this many days" integer, or "5.days.ago" approxidate */
 +extern int git_config_get_expiry_in_days(const char *key, timestamp_t *, timestamp_t now);
 +
 +struct key_value_info {
 +	const char *filename;
 +	int linenr;
 +	enum config_origin_type origin_type;
 +	enum config_scope scope;
 +};
 +
 +extern NORETURN void git_die_config(const char *key, const char *err, ...) __attribute__((format(printf, 2, 3)));
 +extern NORETURN void git_die_config_linenr(const char *key, const char *filename, int linenr);
 +
 +#endif /* CONFIG_H */
diff --cc refs/files-backend.c
index fec77744b4,fcaf4f7191..38d16a13a8
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@@ -1402,9 -1890,25 +1415,25 @@@ static int files_copy_or_rename_ref(str
  	return ret;
  }
  
+ static int files_rename_ref(struct ref_store *ref_store,
+ 			    const char *oldrefname, const char *newrefname,
+ 			    const char *logmsg)
+ {
+ 	return files_copy_or_rename_ref(ref_store, oldrefname,
+ 				 newrefname, logmsg, 0);
+ }
+ 
+ static int files_copy_ref(struct ref_store *ref_store,
+ 			    const char *oldrefname, const char *newrefname,
+ 			    const char *logmsg)
+ {
+ 	return files_copy_or_rename_ref(ref_store, oldrefname,
+ 				 newrefname, logmsg, 1);
+ }
+ 
 -static int close_ref(struct ref_lock *lock)
 +static int close_ref_gently(struct ref_lock *lock)
  {
 -	if (close_lock_file(lock->lk))
 +	if (close_lock_file_gently(&lock->lk))
  		return -1;
  	return 0;
  }
diff --cc refs/packed-backend.c
index 3bc47ffd5e,0000000000..9c0d685c7f
mode 100644,000000..100644
--- a/refs/packed-backend.c
+++ b/refs/packed-backend.c
@@@ -1,1045 -1,0 +1,1053 @@@
 +#include "../cache.h"
 +#include "../config.h"
 +#include "../refs.h"
 +#include "refs-internal.h"
 +#include "ref-cache.h"
 +#include "packed-backend.h"
 +#include "../iterator.h"
 +#include "../lockfile.h"
 +
 +struct packed_ref_cache {
 +	struct ref_cache *cache;
 +
 +	/*
 +	 * Count of references to the data structure in this instance,
 +	 * including the pointer from files_ref_store::packed if any.
 +	 * The data will not be freed as long as the reference count
 +	 * is nonzero.
 +	 */
 +	unsigned int referrers;
 +
 +	/* The metadata from when this packed-refs cache was read */
 +	struct stat_validity validity;
 +};
 +
 +/*
 + * Increment the reference count of *packed_refs.
 + */
 +static void acquire_packed_ref_cache(struct packed_ref_cache *packed_refs)
 +{
 +	packed_refs->referrers++;
 +}
 +
 +/*
 + * Decrease the reference count of *packed_refs.  If it goes to zero,
 + * free *packed_refs and return true; otherwise return false.
 + */
 +static int release_packed_ref_cache(struct packed_ref_cache *packed_refs)
 +{
 +	if (!--packed_refs->referrers) {
 +		free_ref_cache(packed_refs->cache);
 +		stat_validity_clear(&packed_refs->validity);
 +		free(packed_refs);
 +		return 1;
 +	} else {
 +		return 0;
 +	}
 +}
 +
 +/*
 + * A container for `packed-refs`-related data. It is not (yet) a
 + * `ref_store`.
 + */
 +struct packed_ref_store {
 +	struct ref_store base;
 +
 +	unsigned int store_flags;
 +
 +	/* The path of the "packed-refs" file: */
 +	char *path;
 +
 +	/*
 +	 * A cache of the values read from the `packed-refs` file, if
 +	 * it might still be current; otherwise, NULL.
 +	 */
 +	struct packed_ref_cache *cache;
 +
 +	/*
 +	 * Lock used for the "packed-refs" file. Note that this (and
 +	 * thus the enclosing `packed_ref_store`) must not be freed.
 +	 */
 +	struct lock_file lock;
 +
 +	/*
 +	 * Temporary file used when rewriting new contents to the
 +	 * "packed-refs" file. Note that this (and thus the enclosing
 +	 * `packed_ref_store`) must not be freed.
 +	 */
 +	struct tempfile *tempfile;
 +};
 +
 +struct ref_store *packed_ref_store_create(const char *path,
 +					  unsigned int store_flags)
 +{
 +	struct packed_ref_store *refs = xcalloc(1, sizeof(*refs));
 +	struct ref_store *ref_store = (struct ref_store *)refs;
 +
 +	base_ref_store_init(ref_store, &refs_be_packed);
 +	refs->store_flags = store_flags;
 +
 +	refs->path = xstrdup(path);
 +	return ref_store;
 +}
 +
 +/*
 + * Downcast `ref_store` to `packed_ref_store`. Die if `ref_store` is
 + * not a `packed_ref_store`. Also die if `packed_ref_store` doesn't
 + * support at least the flags specified in `required_flags`. `caller`
 + * is used in any necessary error messages.
 + */
 +static struct packed_ref_store *packed_downcast(struct ref_store *ref_store,
 +						unsigned int required_flags,
 +						const char *caller)
 +{
 +	struct packed_ref_store *refs;
 +
 +	if (ref_store->be != &refs_be_packed)
 +		die("BUG: ref_store is type \"%s\" not \"packed\" in %s",
 +		    ref_store->be->name, caller);
 +
 +	refs = (struct packed_ref_store *)ref_store;
 +
 +	if ((refs->store_flags & required_flags) != required_flags)
 +		die("BUG: unallowed operation (%s), requires %x, has %x\n",
 +		    caller, required_flags, refs->store_flags);
 +
 +	return refs;
 +}
 +
 +static void clear_packed_ref_cache(struct packed_ref_store *refs)
 +{
 +	if (refs->cache) {
 +		struct packed_ref_cache *cache = refs->cache;
 +
 +		refs->cache = NULL;
 +		release_packed_ref_cache(cache);
 +	}
 +}
 +
 +/* The length of a peeled reference line in packed-refs, including EOL: */
 +#define PEELED_LINE_LENGTH 42
 +
 +/*
 + * Parse one line from a packed-refs file.  Write the SHA1 to sha1.
 + * Return a pointer to the refname within the line (null-terminated),
 + * or NULL if there was a problem.
 + */
 +static const char *parse_ref_line(struct strbuf *line, struct object_id *oid)
 +{
 +	const char *ref;
 +
 +	if (parse_oid_hex(line->buf, oid, &ref) < 0)
 +		return NULL;
 +	if (!isspace(*ref++))
 +		return NULL;
 +
 +	if (isspace(*ref))
 +		return NULL;
 +
 +	if (line->buf[line->len - 1] != '\n')
 +		return NULL;
 +	line->buf[--line->len] = 0;
 +
 +	return ref;
 +}
 +
 +/*
 + * Read from `packed_refs_file` into a newly-allocated
 + * `packed_ref_cache` and return it. The return value will already
 + * have its reference count incremented.
 + *
 + * A comment line of the form "# pack-refs with: " may contain zero or
 + * more traits. We interpret the traits as follows:
 + *
 + *   No traits:
 + *
 + *      Probably no references are peeled. But if the file contains a
 + *      peeled value for a reference, we will use it.
 + *
 + *   peeled:
 + *
 + *      References under "refs/tags/", if they *can* be peeled, *are*
 + *      peeled in this file. References outside of "refs/tags/" are
 + *      probably not peeled even if they could have been, but if we find
 + *      a peeled value for such a reference we will use it.
 + *
 + *   fully-peeled:
 + *
 + *      All references in the file that can be peeled are peeled.
 + *      Inversely (and this is more important), any references in the
 + *      file for which no peeled value is recorded is not peelable. This
 + *      trait should typically be written alongside "peeled" for
 + *      compatibility with older clients, but we do not require it
 + *      (i.e., "peeled" is a no-op if "fully-peeled" is set).
 + */
 +static struct packed_ref_cache *read_packed_refs(const char *packed_refs_file)
 +{
 +	FILE *f;
 +	struct packed_ref_cache *packed_refs = xcalloc(1, sizeof(*packed_refs));
 +	struct ref_entry *last = NULL;
 +	struct strbuf line = STRBUF_INIT;
 +	enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled = PEELED_NONE;
 +	struct ref_dir *dir;
 +
 +	acquire_packed_ref_cache(packed_refs);
 +	packed_refs->cache = create_ref_cache(NULL, NULL);
 +	packed_refs->cache->root->flag &= ~REF_INCOMPLETE;
 +
 +	f = fopen(packed_refs_file, "r");
 +	if (!f) {
 +		if (errno == ENOENT) {
 +			/*
 +			 * This is OK; it just means that no
 +			 * "packed-refs" file has been written yet,
 +			 * which is equivalent to it being empty.
 +			 */
 +			return packed_refs;
 +		} else {
 +			die_errno("couldn't read %s", packed_refs_file);
 +		}
 +	}
 +
 +	stat_validity_update(&packed_refs->validity, fileno(f));
 +
 +	dir = get_ref_dir(packed_refs->cache->root);
 +	while (strbuf_getwholeline(&line, f, '\n') != EOF) {
 +		struct object_id oid;
 +		const char *refname;
 +		const char *traits;
 +
 +		if (!line.len || line.buf[line.len - 1] != '\n')
 +			die("unterminated line in %s: %s", packed_refs_file, line.buf);
 +
 +		if (skip_prefix(line.buf, "# pack-refs with:", &traits)) {
 +			if (strstr(traits, " fully-peeled "))
 +				peeled = PEELED_FULLY;
 +			else if (strstr(traits, " peeled "))
 +				peeled = PEELED_TAGS;
 +			/* perhaps other traits later as well */
 +			continue;
 +		}
 +
 +		refname = parse_ref_line(&line, &oid);
 +		if (refname) {
 +			int flag = REF_ISPACKED;
 +
 +			if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
 +				if (!refname_is_safe(refname))
 +					die("packed refname is dangerous: %s", refname);
 +				oidclr(&oid);
 +				flag |= REF_BAD_NAME | REF_ISBROKEN;
 +			}
 +			last = create_ref_entry(refname, &oid, flag);
 +			if (peeled == PEELED_FULLY ||
 +			    (peeled == PEELED_TAGS && starts_with(refname, "refs/tags/")))
 +				last->flag |= REF_KNOWS_PEELED;
 +			add_ref_entry(dir, last);
 +		} else if (last &&
 +		    line.buf[0] == '^' &&
 +		    line.len == PEELED_LINE_LENGTH &&
 +		    line.buf[PEELED_LINE_LENGTH - 1] == '\n' &&
 +		    !get_oid_hex(line.buf + 1, &oid)) {
 +			oidcpy(&last->u.value.peeled, &oid);
 +			/*
 +			 * Regardless of what the file header said,
 +			 * we definitely know the value of *this*
 +			 * reference:
 +			 */
 +			last->flag |= REF_KNOWS_PEELED;
 +		} else {
 +			strbuf_setlen(&line, line.len - 1);
 +			die("unexpected line in %s: %s", packed_refs_file, line.buf);
 +		}
 +	}
 +
 +	fclose(f);
 +	strbuf_release(&line);
 +
 +	return packed_refs;
 +}
 +
 +/*
 + * Check that the packed refs cache (if any) still reflects the
 + * contents of the file. If not, clear the cache.
 + */
 +static void validate_packed_ref_cache(struct packed_ref_store *refs)
 +{
 +	if (refs->cache &&
 +	    !stat_validity_check(&refs->cache->validity, refs->path))
 +		clear_packed_ref_cache(refs);
 +}
 +
 +/*
 + * Get the packed_ref_cache for the specified packed_ref_store,
 + * creating and populating it if it hasn't been read before or if the
 + * file has been changed (according to its `validity` field) since it
 + * was last read. On the other hand, if we hold the lock, then assume
 + * that the file hasn't been changed out from under us, so skip the
 + * extra `stat()` call in `stat_validity_check()`.
 + */
 +static struct packed_ref_cache *get_packed_ref_cache(struct packed_ref_store *refs)
 +{
 +	if (!is_lock_file_locked(&refs->lock))
 +		validate_packed_ref_cache(refs);
 +
 +	if (!refs->cache)
 +		refs->cache = read_packed_refs(refs->path);
 +
 +	return refs->cache;
 +}
 +
 +static struct ref_dir *get_packed_ref_dir(struct packed_ref_cache *packed_ref_cache)
 +{
 +	return get_ref_dir(packed_ref_cache->cache->root);
 +}
 +
 +static struct ref_dir *get_packed_refs(struct packed_ref_store *refs)
 +{
 +	return get_packed_ref_dir(get_packed_ref_cache(refs));
 +}
 +
 +/*
 + * Return the ref_entry for the given refname from the packed
 + * references.  If it does not exist, return NULL.
 + */
 +static struct ref_entry *get_packed_ref(struct packed_ref_store *refs,
 +					const char *refname)
 +{
 +	return find_ref_entry(get_packed_refs(refs), refname);
 +}
 +
 +static int packed_read_raw_ref(struct ref_store *ref_store,
 +			       const char *refname, unsigned char *sha1,
 +			       struct strbuf *referent, unsigned int *type)
 +{
 +	struct packed_ref_store *refs =
 +		packed_downcast(ref_store, REF_STORE_READ, "read_raw_ref");
 +
 +	struct ref_entry *entry;
 +
 +	*type = 0;
 +
 +	entry = get_packed_ref(refs, refname);
 +	if (!entry) {
 +		errno = ENOENT;
 +		return -1;
 +	}
 +
 +	hashcpy(sha1, entry->u.value.oid.hash);
 +	*type = REF_ISPACKED;
 +	return 0;
 +}
 +
 +static int packed_peel_ref(struct ref_store *ref_store,
 +			   const char *refname, unsigned char *sha1)
 +{
 +	struct packed_ref_store *refs =
 +		packed_downcast(ref_store, REF_STORE_READ | REF_STORE_ODB,
 +				"peel_ref");
 +	struct ref_entry *r = get_packed_ref(refs, refname);
 +
 +	if (!r || peel_entry(r, 0))
 +		return -1;
 +
 +	hashcpy(sha1, r->u.value.peeled.hash);
 +	return 0;
 +}
 +
 +struct packed_ref_iterator {
 +	struct ref_iterator base;
 +
 +	struct packed_ref_cache *cache;
 +	struct ref_iterator *iter0;
 +	unsigned int flags;
 +};
 +
 +static int packed_ref_iterator_advance(struct ref_iterator *ref_iterator)
 +{
 +	struct packed_ref_iterator *iter =
 +		(struct packed_ref_iterator *)ref_iterator;
 +	int ok;
 +
 +	while ((ok = ref_iterator_advance(iter->iter0)) == ITER_OK) {
 +		if (iter->flags & DO_FOR_EACH_PER_WORKTREE_ONLY &&
 +		    ref_type(iter->iter0->refname) != REF_TYPE_PER_WORKTREE)
 +			continue;
 +
 +		if (!(iter->flags & DO_FOR_EACH_INCLUDE_BROKEN) &&
 +		    !ref_resolves_to_object(iter->iter0->refname,
 +					    iter->iter0->oid,
 +					    iter->iter0->flags))
 +			continue;
 +
 +		iter->base.refname = iter->iter0->refname;
 +		iter->base.oid = iter->iter0->oid;
 +		iter->base.flags = iter->iter0->flags;
 +		return ITER_OK;
 +	}
 +
 +	iter->iter0 = NULL;
 +	if (ref_iterator_abort(ref_iterator) != ITER_DONE)
 +		ok = ITER_ERROR;
 +
 +	return ok;
 +}
 +
 +static int packed_ref_iterator_peel(struct ref_iterator *ref_iterator,
 +				   struct object_id *peeled)
 +{
 +	struct packed_ref_iterator *iter =
 +		(struct packed_ref_iterator *)ref_iterator;
 +
 +	return ref_iterator_peel(iter->iter0, peeled);
 +}
 +
 +static int packed_ref_iterator_abort(struct ref_iterator *ref_iterator)
 +{
 +	struct packed_ref_iterator *iter =
 +		(struct packed_ref_iterator *)ref_iterator;
 +	int ok = ITER_DONE;
 +
 +	if (iter->iter0)
 +		ok = ref_iterator_abort(iter->iter0);
 +
 +	release_packed_ref_cache(iter->cache);
 +	base_ref_iterator_free(ref_iterator);
 +	return ok;
 +}
 +
 +static struct ref_iterator_vtable packed_ref_iterator_vtable = {
 +	packed_ref_iterator_advance,
 +	packed_ref_iterator_peel,
 +	packed_ref_iterator_abort
 +};
 +
 +static struct ref_iterator *packed_ref_iterator_begin(
 +		struct ref_store *ref_store,
 +		const char *prefix, unsigned int flags)
 +{
 +	struct packed_ref_store *refs;
 +	struct packed_ref_iterator *iter;
 +	struct ref_iterator *ref_iterator;
 +	unsigned int required_flags = REF_STORE_READ;
 +
 +	if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN))
 +		required_flags |= REF_STORE_ODB;
 +	refs = packed_downcast(ref_store, required_flags, "ref_iterator_begin");
 +
 +	iter = xcalloc(1, sizeof(*iter));
 +	ref_iterator = &iter->base;
 +	base_ref_iterator_init(ref_iterator, &packed_ref_iterator_vtable);
 +
 +	/*
 +	 * Note that get_packed_ref_cache() internally checks whether
 +	 * the packed-ref cache is up to date with what is on disk,
 +	 * and re-reads it if not.
 +	 */
 +
 +	iter->cache = get_packed_ref_cache(refs);
 +	acquire_packed_ref_cache(iter->cache);
 +	iter->iter0 = cache_ref_iterator_begin(iter->cache->cache, prefix, 0);
 +
 +	iter->flags = flags;
 +
 +	return ref_iterator;
 +}
 +
 +/*
 + * Write an entry to the packed-refs file for the specified refname.
 + * If peeled is non-NULL, write it as the entry's peeled value. On
 + * error, return a nonzero value and leave errno set at the value left
 + * by the failing call to `fprintf()`.
 + */
 +static int write_packed_entry(FILE *fh, const char *refname,
 +			      const unsigned char *sha1,
 +			      const unsigned char *peeled)
 +{
 +	if (fprintf(fh, "%s %s\n", sha1_to_hex(sha1), refname) < 0 ||
 +	    (peeled && fprintf(fh, "^%s\n", sha1_to_hex(peeled)) < 0))
 +		return -1;
 +
 +	return 0;
 +}
 +
 +int packed_refs_lock(struct ref_store *ref_store, int flags, struct strbuf *err)
 +{
 +	struct packed_ref_store *refs =
 +		packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN,
 +				"packed_refs_lock");
 +	static int timeout_configured = 0;
 +	static int timeout_value = 1000;
 +
 +	if (!timeout_configured) {
 +		git_config_get_int("core.packedrefstimeout", &timeout_value);
 +		timeout_configured = 1;
 +	}
 +
 +	/*
 +	 * Note that we close the lockfile immediately because we
 +	 * don't write new content to it, but rather to a separate
 +	 * tempfile.
 +	 */
 +	if (hold_lock_file_for_update_timeout(
 +			    &refs->lock,
 +			    refs->path,
 +			    flags, timeout_value) < 0) {
 +		unable_to_lock_message(refs->path, errno, err);
 +		return -1;
 +	}
 +
 +	if (close_lock_file_gently(&refs->lock)) {
 +		strbuf_addf(err, "unable to close %s: %s", refs->path, strerror(errno));
 +		rollback_lock_file(&refs->lock);
 +		return -1;
 +	}
 +
 +	/*
 +	 * Now that we hold the `packed-refs` lock, make sure that our
 +	 * cache matches the current version of the file. Normally
 +	 * `get_packed_ref_cache()` does that for us, but that
 +	 * function assumes that when the file is locked, any existing
 +	 * cache is still valid. We've just locked the file, but it
 +	 * might have changed the moment *before* we locked it.
 +	 */
 +	validate_packed_ref_cache(refs);
 +
 +	/*
 +	 * Now make sure that the packed-refs file as it exists in the
 +	 * locked state is loaded into the cache:
 +	 */
 +	get_packed_ref_cache(refs);
 +	return 0;
 +}
 +
 +void packed_refs_unlock(struct ref_store *ref_store)
 +{
 +	struct packed_ref_store *refs = packed_downcast(
 +			ref_store,
 +			REF_STORE_READ | REF_STORE_WRITE,
 +			"packed_refs_unlock");
 +
 +	if (!is_lock_file_locked(&refs->lock))
 +		die("BUG: packed_refs_unlock() called when not locked");
 +	rollback_lock_file(&refs->lock);
 +}
 +
 +int packed_refs_is_locked(struct ref_store *ref_store)
 +{
 +	struct packed_ref_store *refs = packed_downcast(
 +			ref_store,
 +			REF_STORE_READ | REF_STORE_WRITE,
 +			"packed_refs_is_locked");
 +
 +	return is_lock_file_locked(&refs->lock);
 +}
 +
 +/*
 + * The packed-refs header line that we write out.  Perhaps other
 + * traits will be added later.  The trailing space is required.
 + */
 +static const char PACKED_REFS_HEADER[] =
 +	"# pack-refs with: peeled fully-peeled \n";
 +
 +static int packed_init_db(struct ref_store *ref_store, struct strbuf *err)
 +{
 +	/* Nothing to do. */
 +	return 0;
 +}
 +
 +/*
 + * Write the packed-refs from the cache to the packed-refs tempfile,
 + * incorporating any changes from `updates`. `updates` must be a
 + * sorted string list whose keys are the refnames and whose util
 + * values are `struct ref_update *`. On error, rollback the tempfile,
 + * write an error message to `err`, and return a nonzero value.
 + *
 + * The packfile must be locked before calling this function and will
 + * remain locked when it is done.
 + */
 +static int write_with_updates(struct packed_ref_store *refs,
 +			      struct string_list *updates,
 +			      struct strbuf *err)
 +{
 +	struct ref_iterator *iter = NULL;
 +	size_t i;
 +	int ok;
 +	FILE *out;
 +	struct strbuf sb = STRBUF_INIT;
 +	char *packed_refs_path;
 +
 +	if (!is_lock_file_locked(&refs->lock))
 +		die("BUG: write_with_updates() called while unlocked");
 +
 +	/*
 +	 * If packed-refs is a symlink, we want to overwrite the
 +	 * symlinked-to file, not the symlink itself. Also, put the
 +	 * staging file next to it:
 +	 */
 +	packed_refs_path = get_locked_file_path(&refs->lock);
 +	strbuf_addf(&sb, "%s.new", packed_refs_path);
 +	free(packed_refs_path);
 +	refs->tempfile = create_tempfile(sb.buf);
 +	if (!refs->tempfile) {
 +		strbuf_addf(err, "unable to create file %s: %s",
 +			    sb.buf, strerror(errno));
 +		strbuf_release(&sb);
 +		return -1;
 +	}
 +	strbuf_release(&sb);
 +
 +	out = fdopen_tempfile(refs->tempfile, "w");
 +	if (!out) {
 +		strbuf_addf(err, "unable to fdopen packed-refs tempfile: %s",
 +			    strerror(errno));
 +		goto error;
 +	}
 +
 +	if (fprintf(out, "%s", PACKED_REFS_HEADER) < 0)
 +		goto write_error;
 +
 +	/*
 +	 * We iterate in parallel through the current list of refs and
 +	 * the list of updates, processing an entry from at least one
 +	 * of the lists each time through the loop. When the current
 +	 * list of refs is exhausted, set iter to NULL. When the list
 +	 * of updates is exhausted, leave i set to updates->nr.
 +	 */
 +	iter = packed_ref_iterator_begin(&refs->base, "",
 +					 DO_FOR_EACH_INCLUDE_BROKEN);
 +	if ((ok = ref_iterator_advance(iter)) != ITER_OK)
 +		iter = NULL;
 +
 +	i = 0;
 +
 +	while (iter || i < updates->nr) {
 +		struct ref_update *update = NULL;
 +		int cmp;
 +
 +		if (i >= updates->nr) {
 +			cmp = -1;
 +		} else {
 +			update = updates->items[i].util;
 +
 +			if (!iter)
 +				cmp = +1;
 +			else
 +				cmp = strcmp(iter->refname, update->refname);
 +		}
 +
 +		if (!cmp) {
 +			/*
 +			 * There is both an old value and an update
 +			 * for this reference. Check the old value if
 +			 * necessary:
 +			 */
 +			if ((update->flags & REF_HAVE_OLD)) {
 +				if (is_null_oid(&update->old_oid)) {
 +					strbuf_addf(err, "cannot update ref '%s': "
 +						    "reference already exists",
 +						    update->refname);
 +					goto error;
 +				} else if (oidcmp(&update->old_oid, iter->oid)) {
 +					strbuf_addf(err, "cannot update ref '%s': "
 +						    "is at %s but expected %s",
 +						    update->refname,
 +						    oid_to_hex(iter->oid),
 +						    oid_to_hex(&update->old_oid));
 +					goto error;
 +				}
 +			}
 +
 +			/* Now figure out what to use for the new value: */
 +			if ((update->flags & REF_HAVE_NEW)) {
 +				/*
 +				 * The update takes precedence. Skip
 +				 * the iterator over the unneeded
 +				 * value.
 +				 */
 +				if ((ok = ref_iterator_advance(iter)) != ITER_OK)
 +					iter = NULL;
 +				cmp = +1;
 +			} else {
 +				/*
 +				 * The update doesn't actually want to
 +				 * change anything. We're done with it.
 +				 */
 +				i++;
 +				cmp = -1;
 +			}
 +		} else if (cmp > 0) {
 +			/*
 +			 * There is no old value but there is an
 +			 * update for this reference. Make sure that
 +			 * the update didn't expect an existing value:
 +			 */
 +			if ((update->flags & REF_HAVE_OLD) &&
 +			    !is_null_oid(&update->old_oid)) {
 +				strbuf_addf(err, "cannot update ref '%s': "
 +					    "reference is missing but expected %s",
 +					    update->refname,
 +					    oid_to_hex(&update->old_oid));
 +				goto error;
 +			}
 +		}
 +
 +		if (cmp < 0) {
 +			/* Pass the old reference through. */
 +
 +			struct object_id peeled;
 +			int peel_error = ref_iterator_peel(iter, &peeled);
 +
 +			if (write_packed_entry(out, iter->refname,
 +					       iter->oid->hash,
 +					       peel_error ? NULL : peeled.hash))
 +				goto write_error;
 +
 +			if ((ok = ref_iterator_advance(iter)) != ITER_OK)
 +				iter = NULL;
 +		} else if (is_null_oid(&update->new_oid)) {
 +			/*
 +			 * The update wants to delete the reference,
 +			 * and the reference either didn't exist or we
 +			 * have already skipped it. So we're done with
 +			 * the update (and don't have to write
 +			 * anything).
 +			 */
 +			i++;
 +		} else {
 +			struct object_id peeled;
 +			int peel_error = peel_object(update->new_oid.hash,
 +						     peeled.hash);
 +
 +			if (write_packed_entry(out, update->refname,
 +					       update->new_oid.hash,
 +					       peel_error ? NULL : peeled.hash))
 +				goto write_error;
 +
 +			i++;
 +		}
 +	}
 +
 +	if (ok != ITER_DONE) {
 +		strbuf_addf(err, "unable to write packed-refs file: "
 +			    "error iterating over old contents");
 +		goto error;
 +	}
 +
 +	if (close_tempfile_gently(refs->tempfile)) {
 +		strbuf_addf(err, "error closing file %s: %s",
 +			    get_tempfile_path(refs->tempfile),
 +			    strerror(errno));
 +		strbuf_release(&sb);
 +		delete_tempfile(&refs->tempfile);
 +		return -1;
 +	}
 +
 +	return 0;
 +
 +write_error:
 +	strbuf_addf(err, "error writing to %s: %s",
 +		    get_tempfile_path(refs->tempfile), strerror(errno));
 +
 +error:
 +	if (iter)
 +		ref_iterator_abort(iter);
 +
 +	delete_tempfile(&refs->tempfile);
 +	return -1;
 +}
 +
 +struct packed_transaction_backend_data {
 +	/* True iff the transaction owns the packed-refs lock. */
 +	int own_lock;
 +
 +	struct string_list updates;
 +};
 +
 +static void packed_transaction_cleanup(struct packed_ref_store *refs,
 +				       struct ref_transaction *transaction)
 +{
 +	struct packed_transaction_backend_data *data = transaction->backend_data;
 +
 +	if (data) {
 +		string_list_clear(&data->updates, 0);
 +
 +		if (is_tempfile_active(refs->tempfile))
 +			delete_tempfile(&refs->tempfile);
 +
 +		if (data->own_lock && is_lock_file_locked(&refs->lock)) {
 +			packed_refs_unlock(&refs->base);
 +			data->own_lock = 0;
 +		}
 +
 +		free(data);
 +		transaction->backend_data = NULL;
 +	}
 +
 +	transaction->state = REF_TRANSACTION_CLOSED;
 +}
 +
 +static int packed_transaction_prepare(struct ref_store *ref_store,
 +				      struct ref_transaction *transaction,
 +				      struct strbuf *err)
 +{
 +	struct packed_ref_store *refs = packed_downcast(
 +			ref_store,
 +			REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,
 +			"ref_transaction_prepare");
 +	struct packed_transaction_backend_data *data;
 +	size_t i;
 +	int ret = TRANSACTION_GENERIC_ERROR;
 +
 +	/*
 +	 * Note that we *don't* skip transactions with zero updates,
 +	 * because such a transaction might be executed for the side
 +	 * effect of ensuring that all of the references are peeled.
 +	 * If the caller wants to optimize away empty transactions, it
 +	 * should do so itself.
 +	 */
 +
 +	data = xcalloc(1, sizeof(*data));
 +	string_list_init(&data->updates, 0);
 +
 +	transaction->backend_data = data;
 +
 +	/*
 +	 * Stick the updates in a string list by refname so that we
 +	 * can sort them:
 +	 */
 +	for (i = 0; i < transaction->nr; i++) {
 +		struct ref_update *update = transaction->updates[i];
 +		struct string_list_item *item =
 +			string_list_append(&data->updates, update->refname);
 +
 +		/* Store a pointer to update in item->util: */
 +		item->util = update;
 +	}
 +	string_list_sort(&data->updates);
 +
 +	if (ref_update_reject_duplicates(&data->updates, err))
 +		goto failure;
 +
 +	if (!is_lock_file_locked(&refs->lock)) {
 +		if (packed_refs_lock(ref_store, 0, err))
 +			goto failure;
 +		data->own_lock = 1;
 +	}
 +
 +	if (write_with_updates(refs, &data->updates, err))
 +		goto failure;
 +
 +	transaction->state = REF_TRANSACTION_PREPARED;
 +	return 0;
 +
 +failure:
 +	packed_transaction_cleanup(refs, transaction);
 +	return ret;
 +}
 +
 +static int packed_transaction_abort(struct ref_store *ref_store,
 +				    struct ref_transaction *transaction,
 +				    struct strbuf *err)
 +{
 +	struct packed_ref_store *refs = packed_downcast(
 +			ref_store,
 +			REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,
 +			"ref_transaction_abort");
 +
 +	packed_transaction_cleanup(refs, transaction);
 +	return 0;
 +}
 +
 +static int packed_transaction_finish(struct ref_store *ref_store,
 +				     struct ref_transaction *transaction,
 +				     struct strbuf *err)
 +{
 +	struct packed_ref_store *refs = packed_downcast(
 +			ref_store,
 +			REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,
 +			"ref_transaction_finish");
 +	int ret = TRANSACTION_GENERIC_ERROR;
 +	char *packed_refs_path;
 +
 +	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;
 +	}
 +
 +	clear_packed_ref_cache(refs);
 +	ret = 0;
 +
 +cleanup:
 +	free(packed_refs_path);
 +	packed_transaction_cleanup(refs, transaction);
 +	return ret;
 +}
 +
 +static int packed_initial_transaction_commit(struct ref_store *ref_store,
 +					    struct ref_transaction *transaction,
 +					    struct strbuf *err)
 +{
 +	return ref_transaction_commit(transaction, err);
 +}
 +
 +static int packed_delete_refs(struct ref_store *ref_store, const char *msg,
 +			     struct string_list *refnames, unsigned int flags)
 +{
 +	struct packed_ref_store *refs =
 +		packed_downcast(ref_store, REF_STORE_WRITE, "delete_refs");
 +	struct strbuf err = STRBUF_INIT;
 +	struct ref_transaction *transaction;
 +	struct string_list_item *item;
 +	int ret;
 +
 +	(void)refs; /* We need the check above, but don't use the variable */
 +
 +	if (!refnames->nr)
 +		return 0;
 +
 +	/*
 +	 * Since we don't check the references' old_oids, the
 +	 * individual updates can't fail, so we can pack all of the
 +	 * updates into a single transaction.
 +	 */
 +
 +	transaction = ref_store_transaction_begin(ref_store, &err);
 +	if (!transaction)
 +		return -1;
 +
 +	for_each_string_list_item(item, refnames) {
 +		if (ref_transaction_delete(transaction, item->string, NULL,
 +					   flags, msg, &err)) {
 +			warning(_("could not delete reference %s: %s"),
 +				item->string, err.buf);
 +			strbuf_reset(&err);
 +		}
 +	}
 +
 +	ret = ref_transaction_commit(transaction, &err);
 +
 +	if (ret) {
 +		if (refnames->nr == 1)
 +			error(_("could not delete reference %s: %s"),
 +			      refnames->items[0].string, err.buf);
 +		else
 +			error(_("could not delete references: %s"), err.buf);
 +	}
 +
 +	ref_transaction_free(transaction);
 +	strbuf_release(&err);
 +	return ret;
 +}
 +
 +static int packed_pack_refs(struct ref_store *ref_store, unsigned int flags)
 +{
 +	/*
 +	 * Packed refs are already packed. It might be that loose refs
 +	 * are packed *into* a packed refs store, but that is done by
 +	 * updating the packed references via a transaction.
 +	 */
 +	return 0;
 +}
 +
 +static int packed_create_symref(struct ref_store *ref_store,
 +			       const char *refname, const char *target,
 +			       const char *logmsg)
 +{
 +	die("BUG: packed reference store does not support symrefs");
 +}
 +
 +static int packed_rename_ref(struct ref_store *ref_store,
 +			    const char *oldrefname, const char *newrefname,
 +			    const char *logmsg)
 +{
 +	die("BUG: packed reference store does not support renaming references");
 +}
 +
++static int packed_copy_ref(struct ref_store *ref_store,
++			   const char *oldrefname, const char *newrefname,
++			   const char *logmsg)
++{
++	die("BUG: packed reference store does not support copying references");
++}
++
 +static struct ref_iterator *packed_reflog_iterator_begin(struct ref_store *ref_store)
 +{
 +	return empty_ref_iterator_begin();
 +}
 +
 +static int packed_for_each_reflog_ent(struct ref_store *ref_store,
 +				      const char *refname,
 +				      each_reflog_ent_fn fn, void *cb_data)
 +{
 +	return 0;
 +}
 +
 +static int packed_for_each_reflog_ent_reverse(struct ref_store *ref_store,
 +					      const char *refname,
 +					      each_reflog_ent_fn fn,
 +					      void *cb_data)
 +{
 +	return 0;
 +}
 +
 +static int packed_reflog_exists(struct ref_store *ref_store,
 +			       const char *refname)
 +{
 +	return 0;
 +}
 +
 +static int packed_create_reflog(struct ref_store *ref_store,
 +			       const char *refname, int force_create,
 +			       struct strbuf *err)
 +{
 +	die("BUG: packed reference store does not support reflogs");
 +}
 +
 +static int packed_delete_reflog(struct ref_store *ref_store,
 +			       const char *refname)
 +{
 +	return 0;
 +}
 +
 +static int packed_reflog_expire(struct ref_store *ref_store,
 +				const char *refname, const unsigned char *sha1,
 +				unsigned int flags,
 +				reflog_expiry_prepare_fn prepare_fn,
 +				reflog_expiry_should_prune_fn should_prune_fn,
 +				reflog_expiry_cleanup_fn cleanup_fn,
 +				void *policy_cb_data)
 +{
 +	return 0;
 +}
 +
 +struct ref_storage_be refs_be_packed = {
 +	NULL,
 +	"packed",
 +	packed_ref_store_create,
 +	packed_init_db,
 +	packed_transaction_prepare,
 +	packed_transaction_finish,
 +	packed_transaction_abort,
 +	packed_initial_transaction_commit,
 +
 +	packed_pack_refs,
 +	packed_peel_ref,
 +	packed_create_symref,
 +	packed_delete_refs,
 +	packed_rename_ref,
++	packed_copy_ref,
 +
 +	packed_ref_iterator_begin,
 +	packed_read_raw_ref,
 +
 +	packed_reflog_iterator_begin,
 +	packed_for_each_reflog_ent,
 +	packed_for_each_reflog_ent_reverse,
 +	packed_reflog_exists,
 +	packed_create_reflog,
 +	packed_delete_reflog,
 +	packed_reflog_expire
 +};