[thirdparty/git.git] / refs / debug.c

#include "git-compat-util.h"
#include "hex.h"
#include "refs-internal.h"
#include "string-list.h"
#include "trace.h"

static struct trace_key trace_refs = TRACE_KEY_INIT(REFS);

struct debug_ref_store {
	struct ref_store base;
	struct ref_store *refs;
};

extern struct ref_storage_be refs_be_debug;

struct ref_store *maybe_debug_wrap_ref_store(const char *gitdir, struct ref_store *store)
{
	struct debug_ref_store *res;
	struct ref_storage_be *be_copy;

	if (!trace_want(&trace_refs)) {
		return store;
	}
	res = xmalloc(sizeof(struct debug_ref_store));
	be_copy = xmalloc(sizeof(*be_copy));
	*be_copy = refs_be_debug;
	/* we never deallocate backends, so safe to copy the pointer. */
	be_copy->name = store->be->name;
	trace_printf_key(&trace_refs, "ref_store for %s\n", gitdir);
	res->refs = store;
	base_ref_store_init((struct ref_store *)res, store->repo, gitdir,
			    be_copy);
	return (struct ref_store *)res;
}

static int debug_init_db(struct ref_store *refs, int flags, struct strbuf *err)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)refs;
	int res = drefs->refs->be->init_db(drefs->refs, flags, err);
	trace_printf_key(&trace_refs, "init_db: %d\n", res);
	return res;
}

static int debug_transaction_prepare(struct ref_store *refs,
				     struct ref_transaction *transaction,
				     struct strbuf *err)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)refs;
	int res;
	transaction->ref_store = drefs->refs;
	res = drefs->refs->be->transaction_prepare(drefs->refs, transaction,
						   err);
	trace_printf_key(&trace_refs, "transaction_prepare: %d \"%s\"\n", res,
			 err->buf);
	return res;
}

static void print_update(int i, const char *refname,
			 const struct object_id *old_oid,
			 const struct object_id *new_oid, unsigned int flags,
			 unsigned int type, const char *msg)
{
	char o[GIT_MAX_HEXSZ + 1] = "null";
	char n[GIT_MAX_HEXSZ + 1] = "null";
	if (old_oid)
		oid_to_hex_r(o, old_oid);
	if (new_oid)
		oid_to_hex_r(n, new_oid);

	type &= 0xf; /* see refs.h REF_* */
	flags &= REF_HAVE_NEW | REF_HAVE_OLD | REF_NO_DEREF |
		REF_FORCE_CREATE_REFLOG;
	trace_printf_key(&trace_refs, "%d: %s %s -> %s (F=0x%x, T=0x%x) \"%s\"\n", i, refname,
		o, n, flags, type, msg);
}

static void print_transaction(struct ref_transaction *transaction)
{
	int i;
	trace_printf_key(&trace_refs, "transaction {\n");
	for (i = 0; i < transaction->nr; i++) {
		struct ref_update *u = transaction->updates[i];
		print_update(i, u->refname, &u->old_oid, &u->new_oid, u->flags,
			     u->type, u->msg);
	}
	trace_printf_key(&trace_refs, "}\n");
}

static int debug_transaction_finish(struct ref_store *refs,
				    struct ref_transaction *transaction,
				    struct strbuf *err)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)refs;
	int res;
	transaction->ref_store = drefs->refs;
	res = drefs->refs->be->transaction_finish(drefs->refs, transaction,
						  err);
	print_transaction(transaction);
	trace_printf_key(&trace_refs, "finish: %d\n", res);
	return res;
}

static int debug_transaction_abort(struct ref_store *refs,
				   struct ref_transaction *transaction,
				   struct strbuf *err)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)refs;
	int res;
	transaction->ref_store = drefs->refs;
	res = drefs->refs->be->transaction_abort(drefs->refs, transaction, err);
	return res;
}

static int debug_initial_transaction_commit(struct ref_store *refs,
					    struct ref_transaction *transaction,
					    struct strbuf *err)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)refs;
	int res;
	transaction->ref_store = drefs->refs;
	res = drefs->refs->be->initial_transaction_commit(drefs->refs,
							  transaction, err);
	return res;
}

static int debug_pack_refs(struct ref_store *ref_store, struct pack_refs_opts *opts)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
	int res = drefs->refs->be->pack_refs(drefs->refs, opts);
	trace_printf_key(&trace_refs, "pack_refs: %d\n", res);
	return res;
}

static int debug_create_symref(struct ref_store *ref_store,
			       const char *ref_name, const char *target,
			       const char *logmsg)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
	int res = drefs->refs->be->create_symref(drefs->refs, ref_name, target,
						 logmsg);
	trace_printf_key(&trace_refs, "create_symref: %s -> %s \"%s\": %d\n", ref_name,
		target, logmsg, res);
	return res;
}

static int debug_rename_ref(struct ref_store *ref_store, const char *oldref,
			    const char *newref, const char *logmsg)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
	int res = drefs->refs->be->rename_ref(drefs->refs, oldref, newref,
					      logmsg);
	trace_printf_key(&trace_refs, "rename_ref: %s -> %s \"%s\": %d\n", oldref, newref,
		logmsg, res);
	return res;
}

static int debug_copy_ref(struct ref_store *ref_store, const char *oldref,
			  const char *newref, const char *logmsg)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
	int res =
		drefs->refs->be->copy_ref(drefs->refs, oldref, newref, logmsg);
	trace_printf_key(&trace_refs, "copy_ref: %s -> %s \"%s\": %d\n", oldref, newref,
		logmsg, res);
	return res;
}

struct debug_ref_iterator {
	struct ref_iterator base;
	struct ref_iterator *iter;
};

static int debug_ref_iterator_advance(struct ref_iterator *ref_iterator)
{
	struct debug_ref_iterator *diter =
		(struct debug_ref_iterator *)ref_iterator;
	int res = diter->iter->vtable->advance(diter->iter);
	if (res)
		trace_printf_key(&trace_refs, "iterator_advance: (%d)\n", res);
	else
		trace_printf_key(&trace_refs, "iterator_advance: %s (0)\n",
			diter->iter->refname);

	diter->base.refname = diter->iter->refname;
	diter->base.oid = diter->iter->oid;
	diter->base.flags = diter->iter->flags;
	return res;
}

static int debug_ref_iterator_peel(struct ref_iterator *ref_iterator,
				   struct object_id *peeled)
{
	struct debug_ref_iterator *diter =
		(struct debug_ref_iterator *)ref_iterator;
	int res = diter->iter->vtable->peel(diter->iter, peeled);
	trace_printf_key(&trace_refs, "iterator_peel: %s: %d\n", diter->iter->refname, res);
	return res;
}

static int debug_ref_iterator_abort(struct ref_iterator *ref_iterator)
{
	struct debug_ref_iterator *diter =
		(struct debug_ref_iterator *)ref_iterator;
	int res = diter->iter->vtable->abort(diter->iter);
	trace_printf_key(&trace_refs, "iterator_abort: %d\n", res);
	return res;
}

static struct ref_iterator_vtable debug_ref_iterator_vtable = {
	.advance = debug_ref_iterator_advance,
	.peel = debug_ref_iterator_peel,
	.abort = debug_ref_iterator_abort,
};

static struct ref_iterator *
debug_ref_iterator_begin(struct ref_store *ref_store, const char *prefix,
			 const char **exclude_patterns, unsigned int flags)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
	struct ref_iterator *res =
		drefs->refs->be->iterator_begin(drefs->refs, prefix,
						exclude_patterns, flags);
	struct debug_ref_iterator *diter = xcalloc(1, sizeof(*diter));
	base_ref_iterator_init(&diter->base, &debug_ref_iterator_vtable);
	diter->iter = res;
	trace_printf_key(&trace_refs, "ref_iterator_begin: \"%s\" (0x%x)\n",
			 prefix, flags);
	return &diter->base;
}

static int debug_read_raw_ref(struct ref_store *ref_store, const char *refname,
			      struct object_id *oid, struct strbuf *referent,
			      unsigned int *type, int *failure_errno)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
	int res = 0;

	oidcpy(oid, null_oid());
	res = drefs->refs->be->read_raw_ref(drefs->refs, refname, oid, referent,
					    type, failure_errno);

	if (res == 0) {
		trace_printf_key(&trace_refs, "read_raw_ref: %s: %s (=> %s) type %x: %d\n",
			refname, oid_to_hex(oid), referent->buf, *type, res);
	} else {
		trace_printf_key(&trace_refs,
				 "read_raw_ref: %s: %d (errno %d)\n", refname,
				 res, *failure_errno);
	}
	return res;
}

static int debug_read_symbolic_ref(struct ref_store *ref_store, const char *refname,
				   struct strbuf *referent)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
	struct ref_store *refs = drefs->refs;
	int res;

	res = refs->be->read_symbolic_ref(refs, refname, referent);
	if (!res)
		trace_printf_key(&trace_refs, "read_symbolic_ref: %s: (%s)\n",
				 refname, referent->buf);
	else
		trace_printf_key(&trace_refs,
				 "read_symbolic_ref: %s: %d\n", refname, res);
	return res;

}

static struct ref_iterator *
debug_reflog_iterator_begin(struct ref_store *ref_store)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
	struct ref_iterator *res =
		drefs->refs->be->reflog_iterator_begin(drefs->refs);
	trace_printf_key(&trace_refs, "for_each_reflog_iterator_begin\n");
	return res;
}

struct debug_reflog {
	const char *refname;
	each_reflog_ent_fn *fn;
	void *cb_data;
};

static int debug_print_reflog_ent(struct object_id *old_oid,
				  struct object_id *new_oid,
				  const char *committer, timestamp_t timestamp,
				  int tz, const char *msg, void *cb_data)
{
	struct debug_reflog *dbg = (struct debug_reflog *)cb_data;
	int ret;
	char o[GIT_MAX_HEXSZ + 1] = "null";
	char n[GIT_MAX_HEXSZ + 1] = "null";
	char *msgend = strchrnul(msg, '\n');
	if (old_oid)
		oid_to_hex_r(o, old_oid);
	if (new_oid)
		oid_to_hex_r(n, new_oid);

	ret = dbg->fn(old_oid, new_oid, committer, timestamp, tz, msg,
		      dbg->cb_data);
	trace_printf_key(&trace_refs,
			 "reflog_ent %s (ret %d): %s -> %s, %s %ld \"%.*s\"\n",
			 dbg->refname, ret, o, n, committer,
			 (long int)timestamp, (int)(msgend - msg), msg);
	return ret;
}

static int debug_for_each_reflog_ent(struct ref_store *ref_store,
				     const char *refname, each_reflog_ent_fn fn,
				     void *cb_data)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
	struct debug_reflog dbg = {
		.refname = refname,
		.fn = fn,
		.cb_data = cb_data,
	};

	int res = drefs->refs->be->for_each_reflog_ent(
		drefs->refs, refname, &debug_print_reflog_ent, &dbg);
	trace_printf_key(&trace_refs, "for_each_reflog: %s: %d\n", refname, res);
	return res;
}

static int debug_for_each_reflog_ent_reverse(struct ref_store *ref_store,
					     const char *refname,
					     each_reflog_ent_fn fn,
					     void *cb_data)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
	struct debug_reflog dbg = {
		.refname = refname,
		.fn = fn,
		.cb_data = cb_data,
	};
	int res = drefs->refs->be->for_each_reflog_ent_reverse(
		drefs->refs, refname, &debug_print_reflog_ent, &dbg);
	trace_printf_key(&trace_refs, "for_each_reflog_reverse: %s: %d\n", refname, res);
	return res;
}

static int debug_reflog_exists(struct ref_store *ref_store, const char *refname)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
	int res = drefs->refs->be->reflog_exists(drefs->refs, refname);
	trace_printf_key(&trace_refs, "reflog_exists: %s: %d\n", refname, res);
	return res;
}

static int debug_create_reflog(struct ref_store *ref_store, const char *refname,
			       struct strbuf *err)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
	int res = drefs->refs->be->create_reflog(drefs->refs, refname, err);
	trace_printf_key(&trace_refs, "create_reflog: %s: %d\n", refname, res);
	return res;
}

static int debug_delete_reflog(struct ref_store *ref_store, const char *refname)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
	int res = drefs->refs->be->delete_reflog(drefs->refs, refname);
	trace_printf_key(&trace_refs, "delete_reflog: %s: %d\n", refname, res);
	return res;
}

struct debug_reflog_expiry_should_prune {
	reflog_expiry_prepare_fn *prepare;
	reflog_expiry_should_prune_fn *should_prune;
	reflog_expiry_cleanup_fn *cleanup;
	void *cb_data;
};

static void debug_reflog_expiry_prepare(const char *refname,
					const struct object_id *oid,
					void *cb_data)
{
	struct debug_reflog_expiry_should_prune *prune = cb_data;
	trace_printf_key(&trace_refs, "reflog_expire_prepare: %s\n", refname);
	prune->prepare(refname, oid, prune->cb_data);
}

static int debug_reflog_expiry_should_prune_fn(struct object_id *ooid,
					       struct object_id *noid,
					       const char *email,
					       timestamp_t timestamp, int tz,
					       const char *message, void *cb_data) {
	struct debug_reflog_expiry_should_prune *prune = cb_data;

	int result = prune->should_prune(ooid, noid, email, timestamp, tz, message, prune->cb_data);
	trace_printf_key(&trace_refs, "reflog_expire_should_prune: %s %ld: %d\n", message, (long int) timestamp, result);
	return result;
}

static void debug_reflog_expiry_cleanup(void *cb_data)
{
	struct debug_reflog_expiry_should_prune *prune = cb_data;
	prune->cleanup(prune->cb_data);
}

static int debug_reflog_expire(struct ref_store *ref_store, const char *refname,
			       unsigned int flags,
			       reflog_expiry_prepare_fn prepare_fn,
			       reflog_expiry_should_prune_fn should_prune_fn,
			       reflog_expiry_cleanup_fn cleanup_fn,
			       void *policy_cb_data)
{
	struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
	struct debug_reflog_expiry_should_prune prune = {
		.prepare = prepare_fn,
		.cleanup = cleanup_fn,
		.should_prune = should_prune_fn,
		.cb_data = policy_cb_data,
	};
	int res = drefs->refs->be->reflog_expire(drefs->refs, refname,
						 flags, &debug_reflog_expiry_prepare,
						 &debug_reflog_expiry_should_prune_fn,
						 &debug_reflog_expiry_cleanup,
						 &prune);
	trace_printf_key(&trace_refs, "reflog_expire: %s: %d\n", refname, res);
	return res;
}

struct ref_storage_be refs_be_debug = {
	.name = "debug",
	.init = NULL,
	.init_db = debug_init_db,

	/*
	 * None of these should be NULL. If the "files" backend (in
	 * "struct ref_storage_be refs_be_files" in files-backend.c)
	 * has a function we should also have a wrapper for it here.
	 * Test the output with "GIT_TRACE_REFS=1".
	 */
	.transaction_prepare = debug_transaction_prepare,
	.transaction_finish = debug_transaction_finish,
	.transaction_abort = debug_transaction_abort,
	.initial_transaction_commit = debug_initial_transaction_commit,

	.pack_refs = debug_pack_refs,
	.create_symref = debug_create_symref,
	.rename_ref = debug_rename_ref,
	.copy_ref = debug_copy_ref,

	.iterator_begin = debug_ref_iterator_begin,
	.read_raw_ref = debug_read_raw_ref,
	.read_symbolic_ref = debug_read_symbolic_ref,

	.reflog_iterator_begin = debug_reflog_iterator_begin,
	.for_each_reflog_ent = debug_for_each_reflog_ent,
	.for_each_reflog_ent_reverse = debug_for_each_reflog_ent_reverse,
	.reflog_exists = debug_reflog_exists,
	.create_reflog = debug_create_reflog,
	.delete_reflog = debug_delete_reflog,
	.reflog_expire = debug_reflog_expire,
};
Commit	Line	Data
8bff5ca0	1	#include "git-compat-util.h"
41771fa4	2	#include "hex.h"
4441f427	3	#include "refs-internal.h"
d4a4f929	4	#include "string-list.h"
4441f427 HWN	5	#include "trace.h"
	6
	7	static struct trace_key trace_refs = TRACE_KEY_INIT(REFS);
	8
	9	struct debug_ref_store {
	10	struct ref_store base;
	11	struct ref_store *refs;
	12	};
	13
	14	extern struct ref_storage_be refs_be_debug;
	15
	16	struct ref_store maybe_debug_wrap_ref_store(const char gitdir, struct ref_store *store)
	17	{
	18	struct debug_ref_store *res;
	19	struct ref_storage_be *be_copy;
	20
	21	if (!trace_want(&trace_refs)) {
	22	return store;
	23	}
	24	res = xmalloc(sizeof(struct debug_ref_store));
	25	be_copy = xmalloc(sizeof(*be_copy));
	26	*be_copy = refs_be_debug;
	27	/* we never deallocate backends, so safe to copy the pointer. */
	28	be_copy->name = store->be->name;
	29	trace_printf_key(&trace_refs, "ref_store for %s\n", gitdir);
	30	res->refs = store;
f9f7fd3b HWN	31	base_ref_store_init((struct ref_store *)res, store->repo, gitdir,
f9f7fd3b HWN	32	be_copy);
4441f427 HWN	33	return (struct ref_store *)res;
	34	}
	35
2e573d61	36	static int debug_init_db(struct ref_store refs, int flags, struct strbuf err)
4441f427 HWN	37	{
4441f427 HWN	38	struct debug_ref_store drefs = (struct debug_ref_store )refs;
2e573d61	39	int res = drefs->refs->be->init_db(drefs->refs, flags, err);
4441f427 HWN	40	trace_printf_key(&trace_refs, "init_db: %d\n", res);
	41	return res;
	42	}
	43
	44	static int debug_transaction_prepare(struct ref_store *refs,
	45	struct ref_transaction *transaction,
	46	struct strbuf *err)
	47	{
	48	struct debug_ref_store drefs = (struct debug_ref_store )refs;
	49	int res;
	50	transaction->ref_store = drefs->refs;
	51	res = drefs->refs->be->transaction_prepare(drefs->refs, transaction,
	52	err);
a6db572a HWN	53	trace_printf_key(&trace_refs, "transaction_prepare: %d \"%s\"\n", res,
a6db572a HWN	54	err->buf);
4441f427 HWN	55	return res;
	56	}
	57
	58	static void print_update(int i, const char *refname,
	59	const struct object_id *old_oid,
	60	const struct object_id *new_oid, unsigned int flags,
	61	unsigned int type, const char *msg)
	62	{
	63	char o[GIT_MAX_HEXSZ + 1] = "null";
	64	char n[GIT_MAX_HEXSZ + 1] = "null";
	65	if (old_oid)
	66	oid_to_hex_r(o, old_oid);
	67	if (new_oid)
	68	oid_to_hex_r(n, new_oid);
	69
	70	type &= 0xf; /* see refs.h REF_* */
	71	flags &= REF_HAVE_NEW \| REF_HAVE_OLD \| REF_NO_DEREF \|
	72	REF_FORCE_CREATE_REFLOG;
	73	trace_printf_key(&trace_refs, "%d: %s %s -> %s (F=0x%x, T=0x%x) \"%s\"\n", i, refname,
	74	o, n, flags, type, msg);
	75	}
	76
	77	static void print_transaction(struct ref_transaction *transaction)
	78	{
	79	int i;
	80	trace_printf_key(&trace_refs, "transaction {\n");
	81	for (i = 0; i < transaction->nr; i++) {
	82	struct ref_update *u = transaction->updates[i];
	83	print_update(i, u->refname, &u->old_oid, &u->new_oid, u->flags,
	84	u->type, u->msg);
	85	}
	86	trace_printf_key(&trace_refs, "}\n");
	87	}
	88
	89	static int debug_transaction_finish(struct ref_store *refs,
	90	struct ref_transaction *transaction,
	91	struct strbuf *err)
	92	{
	93	struct debug_ref_store drefs = (struct debug_ref_store )refs;
	94	int res;
	95	transaction->ref_store = drefs->refs;
	96	res = drefs->refs->be->transaction_finish(drefs->refs, transaction,
	97	err);
	98	print_transaction(transaction);
	99	trace_printf_key(&trace_refs, "finish: %d\n", res);
	100	return res;
	101	}
	102
	103	static int debug_transaction_abort(struct ref_store *refs,
	104	struct ref_transaction *transaction,
	105	struct strbuf *err)
	106	{
	107	struct debug_ref_store drefs = (struct debug_ref_store )refs;
	108	int res;
	109	transaction->ref_store = drefs->refs;
	110	res = drefs->refs->be->transaction_abort(drefs->refs, transaction, err);
	111	return res;
	112	}
	113
	114	static int debug_initial_transaction_commit(struct ref_store *refs,
	115	struct ref_transaction *transaction,
	116	struct strbuf *err)
	117	{
	118	struct debug_ref_store drefs = (struct debug_ref_store )refs;
119	int res;
120	transaction->ref_store = drefs->refs;
121	res = drefs->refs->be->initial_transaction_commit(drefs->refs,
122	transaction, err);
123	return res;
124	}
125
826ae79f	126	static int debug_pack_refs(struct ref_store ref_store, struct pack_refs_opts opts)
4441f427 HWN	127	{
4441f427 HWN	128	struct debug_ref_store drefs = (struct debug_ref_store )ref_store;
826ae79f	129	int res = drefs->refs->be->pack_refs(drefs->refs, opts);
4441f427 HWN	130	trace_printf_key(&trace_refs, "pack_refs: %d\n", res);
	131	return res;
	132	}
	133
	134	static int debug_create_symref(struct ref_store *ref_store,
	135	const char ref_name, const char target,
	136	const char *logmsg)
	137	{
	138	struct debug_ref_store drefs = (struct debug_ref_store )ref_store;
	139	int res = drefs->refs->be->create_symref(drefs->refs, ref_name, target,
	140	logmsg);
	141	trace_printf_key(&trace_refs, "create_symref: %s -> %s \"%s\": %d\n", ref_name,
	142	target, logmsg, res);
	143	return res;
	144	}
	145
4441f427 HWN	146	static int debug_rename_ref(struct ref_store ref_store, const char oldref,
	147	const char newref, const char logmsg)
	148	{
	149	struct debug_ref_store drefs = (struct debug_ref_store )ref_store;
	150	int res = drefs->refs->be->rename_ref(drefs->refs, oldref, newref,
	151	logmsg);
	152	trace_printf_key(&trace_refs, "rename_ref: %s -> %s \"%s\": %d\n", oldref, newref,
	153	logmsg, res);
	154	return res;
	155	}
	156
	157	static int debug_copy_ref(struct ref_store ref_store, const char oldref,
	158	const char newref, const char logmsg)
	159	{
	160	struct debug_ref_store drefs = (struct debug_ref_store )ref_store;
	161	int res =
	162	drefs->refs->be->copy_ref(drefs->refs, oldref, newref, logmsg);
	163	trace_printf_key(&trace_refs, "copy_ref: %s -> %s \"%s\": %d\n", oldref, newref,
	164	logmsg, res);
	165	return res;
	166	}
	167
	168	struct debug_ref_iterator {
	169	struct ref_iterator base;
	170	struct ref_iterator *iter;
	171	};
	172
	173	static int debug_ref_iterator_advance(struct ref_iterator *ref_iterator)
	174	{
	175	struct debug_ref_iterator *diter =
	176	(struct debug_ref_iterator *)ref_iterator;
	177	int res = diter->iter->vtable->advance(diter->iter);
	178	if (res)
	179	trace_printf_key(&trace_refs, "iterator_advance: (%d)\n", res);
	180	else
	181	trace_printf_key(&trace_refs, "iterator_advance: %s (0)\n",
	182	diter->iter->refname);
	183
4441f427 HWN	184	diter->base.refname = diter->iter->refname;
	185	diter->base.oid = diter->iter->oid;
	186	diter->base.flags = diter->iter->flags;
	187	return res;
	188	}
	189
	190	static int debug_ref_iterator_peel(struct ref_iterator *ref_iterator,
	191	struct object_id *peeled)
	192	{
	193	struct debug_ref_iterator *diter =
	194	(struct debug_ref_iterator *)ref_iterator;
	195	int res = diter->iter->vtable->peel(diter->iter, peeled);
	196	trace_printf_key(&trace_refs, "iterator_peel: %s: %d\n", diter->iter->refname, res);
	197	return res;
	198	}
	199
	200	static int debug_ref_iterator_abort(struct ref_iterator *ref_iterator)
	201	{
	202	struct debug_ref_iterator *diter =
	203	(struct debug_ref_iterator *)ref_iterator;
	204	int res = diter->iter->vtable->abort(diter->iter);
	205	trace_printf_key(&trace_refs, "iterator_abort: %d\n", res);
	206	return res;
	207	}
	208
	209	static struct ref_iterator_vtable debug_ref_iterator_vtable = {
e2f8acb6 ÆAB	210	.advance = debug_ref_iterator_advance,
	211	.peel = debug_ref_iterator_peel,
	212	.abort = debug_ref_iterator_abort,
4441f427 HWN	213	};
	214
	215	static struct ref_iterator *
	216	debug_ref_iterator_begin(struct ref_store ref_store, const char prefix,
b269ac53	217	const char **exclude_patterns, unsigned int flags)
4441f427 HWN	218	{
	219	struct debug_ref_store drefs = (struct debug_ref_store )ref_store;
	220	struct ref_iterator *res =
b269ac53 TB	221	drefs->refs->be->iterator_begin(drefs->refs, prefix,
b269ac53 TB	222	exclude_patterns, flags);
4441f427	223	struct debug_ref_iterator diter = xcalloc(1, sizeof(diter));
5e01d838	224	base_ref_iterator_init(&diter->base, &debug_ref_iterator_vtable);
4441f427	225	diter->iter = res;
c510928a HWN	226	trace_printf_key(&trace_refs, "ref_iterator_begin: \"%s\" (0x%x)\n",
c510928a HWN	227	prefix, flags);
4441f427 HWN	228	return &diter->base;
	229	}
	230
	231	static int debug_read_raw_ref(struct ref_store ref_store, const char refname,
	232	struct object_id oid, struct strbuf referent,
5b12e16b	233	unsigned int type, int failure_errno)
4441f427 HWN	234	{
	235	struct debug_ref_store drefs = (struct debug_ref_store )ref_store;
	236	int res = 0;
	237
14228447	238	oidcpy(oid, null_oid());
4441f427	239	res = drefs->refs->be->read_raw_ref(drefs->refs, refname, oid, referent,
5b12e16b	240	type, failure_errno);
4441f427 HWN	241
	242	if (res == 0) {
	243	trace_printf_key(&trace_refs, "read_raw_ref: %s: %s (=> %s) type %x: %d\n",
	244	refname, oid_to_hex(oid), referent->buf, *type, res);
	245	} else {
2a2112a4 HWN	246	trace_printf_key(&trace_refs,
2a2112a4 HWN	247	"read_raw_ref: %s: %d (errno %d)\n", refname,
5b12e16b	248	res, *failure_errno);
4441f427 HWN	249	}
	250	return res;
	251	}
	252
5b875404 ÆAB	253	static int debug_read_symbolic_ref(struct ref_store ref_store, const char refname,
	254	struct strbuf *referent)
	255	{
	256	struct debug_ref_store drefs = (struct debug_ref_store )ref_store;
	257	struct ref_store *refs = drefs->refs;
	258	int res;
	259
	260	res = refs->be->read_symbolic_ref(refs, refname, referent);
	261	if (!res)
	262	trace_printf_key(&trace_refs, "read_symbolic_ref: %s: (%s)\n",
	263	refname, referent->buf);
	264	else
	265	trace_printf_key(&trace_refs,
	266	"read_symbolic_ref: %s: %d\n", refname, res);
	267	return res;
	268
	269	}
	270
4441f427 HWN	271	static struct ref_iterator *
	272	debug_reflog_iterator_begin(struct ref_store *ref_store)
	273	{
	274	struct debug_ref_store drefs = (struct debug_ref_store )ref_store;
	275	struct ref_iterator *res =
	276	drefs->refs->be->reflog_iterator_begin(drefs->refs);
	277	trace_printf_key(&trace_refs, "for_each_reflog_iterator_begin\n");
	278	return res;
	279	}
	280
	281	struct debug_reflog {
	282	const char *refname;
	283	each_reflog_ent_fn *fn;
	284	void *cb_data;
	285	};
	286
	287	static int debug_print_reflog_ent(struct object_id *old_oid,
	288	struct object_id *new_oid,
	289	const char *committer, timestamp_t timestamp,
	290	int tz, const char msg, void cb_data)
	291	{
	292	struct debug_reflog dbg = (struct debug_reflog )cb_data;
	293	int ret;
	294	char o[GIT_MAX_HEXSZ + 1] = "null";
	295	char n[GIT_MAX_HEXSZ + 1] = "null";
65279256	296	char *msgend = strchrnul(msg, '\n');
4441f427 HWN	297	if (old_oid)
	298	oid_to_hex_r(o, old_oid);
	299	if (new_oid)
	300	oid_to_hex_r(n, new_oid);
	301
	302	ret = dbg->fn(old_oid, new_oid, committer, timestamp, tz, msg,
	303	dbg->cb_data);
65279256 HWN	304	trace_printf_key(&trace_refs,
	305	"reflog_ent %s (ret %d): %s -> %s, %s %ld \"%.*s\"\n",
	306	dbg->refname, ret, o, n, committer,
	307	(long int)timestamp, (int)(msgend - msg), msg);
4441f427 HWN	308	return ret;
	309	}
	310
	311	static int debug_for_each_reflog_ent(struct ref_store *ref_store,
	312	const char *refname, each_reflog_ent_fn fn,
	313	void *cb_data)
	314	{
	315	struct debug_ref_store drefs = (struct debug_ref_store )ref_store;
	316	struct debug_reflog dbg = {
	317	.refname = refname,
	318	.fn = fn,
	319	.cb_data = cb_data,
	320	};
	321
	322	int res = drefs->refs->be->for_each_reflog_ent(
	323	drefs->refs, refname, &debug_print_reflog_ent, &dbg);
	324	trace_printf_key(&trace_refs, "for_each_reflog: %s: %d\n", refname, res);
	325	return res;
	326	}
	327
	328	static int debug_for_each_reflog_ent_reverse(struct ref_store *ref_store,
	329	const char *refname,
	330	each_reflog_ent_fn fn,
	331	void *cb_data)
	332	{
	333	struct debug_ref_store drefs = (struct debug_ref_store )ref_store;
	334	struct debug_reflog dbg = {
	335	.refname = refname,
	336	.fn = fn,
	337	.cb_data = cb_data,
	338	};
	339	int res = drefs->refs->be->for_each_reflog_ent_reverse(
	340	drefs->refs, refname, &debug_print_reflog_ent, &dbg);
	341	trace_printf_key(&trace_refs, "for_each_reflog_reverse: %s: %d\n", refname, res);
	342	return res;
	343	}
	344
	345	static int debug_reflog_exists(struct ref_store ref_store, const char refname)
	346	{
	347	struct debug_ref_store drefs = (struct debug_ref_store )ref_store;
	348	int res = drefs->refs->be->reflog_exists(drefs->refs, refname);
	349	trace_printf_key(&trace_refs, "reflog_exists: %s: %d\n", refname, res);
	350	return res;
	351	}
	352
	353	static int debug_create_reflog(struct ref_store ref_store, const char refname,
7b089120	354	struct strbuf *err)
4441f427 HWN	355	{
4441f427 HWN	356	struct debug_ref_store drefs = (struct debug_ref_store )ref_store;
7b089120	357	int res = drefs->refs->be->create_reflog(drefs->refs, refname, err);
4441f427 HWN	358	trace_printf_key(&trace_refs, "create_reflog: %s: %d\n", refname, res);
	359	return res;
	360	}
	361
	362	static int debug_delete_reflog(struct ref_store ref_store, const char refname)
	363	{
	364	struct debug_ref_store drefs = (struct debug_ref_store )ref_store;
	365	int res = drefs->refs->be->delete_reflog(drefs->refs, refname);
	366	trace_printf_key(&trace_refs, "delete_reflog: %s: %d\n", refname, res);
	367	return res;
	368	}
	369
34c31997 HWN	370	struct debug_reflog_expiry_should_prune {
	371	reflog_expiry_prepare_fn *prepare;
	372	reflog_expiry_should_prune_fn *should_prune;
	373	reflog_expiry_cleanup_fn *cleanup;
	374	void *cb_data;
	375	};
	376
	377	static void debug_reflog_expiry_prepare(const char *refname,
81bc1225 ÆAB	378	const struct object_id *oid,
81bc1225 ÆAB	379	void *cb_data)
34c31997 HWN	380	{
	381	struct debug_reflog_expiry_should_prune *prune = cb_data;
	382	trace_printf_key(&trace_refs, "reflog_expire_prepare: %s\n", refname);
	383	prune->prepare(refname, oid, prune->cb_data);
	384	}
	385
	386	static int debug_reflog_expiry_should_prune_fn(struct object_id *ooid,
	387	struct object_id *noid,
	388	const char *email,
	389	timestamp_t timestamp, int tz,
	390	const char message, void cb_data) {
	391	struct debug_reflog_expiry_should_prune *prune = cb_data;
	392
	393	int result = prune->should_prune(ooid, noid, email, timestamp, tz, message, prune->cb_data);
	394	trace_printf_key(&trace_refs, "reflog_expire_should_prune: %s %ld: %d\n", message, (long int) timestamp, result);
	395	return result;
	396	}
	397
	398	static void debug_reflog_expiry_cleanup(void *cb_data)
	399	{
	400	struct debug_reflog_expiry_should_prune *prune = cb_data;
	401	prune->cleanup(prune->cb_data);
	402	}
	403
4441f427	404	static int debug_reflog_expire(struct ref_store ref_store, const char refname,
cc40b5ce	405	unsigned int flags,
4441f427 HWN	406	reflog_expiry_prepare_fn prepare_fn,
	407	reflog_expiry_should_prune_fn should_prune_fn,
	408	reflog_expiry_cleanup_fn cleanup_fn,
	409	void *policy_cb_data)
	410	{
	411	struct debug_ref_store drefs = (struct debug_ref_store )ref_store;
34c31997 HWN	412	struct debug_reflog_expiry_should_prune prune = {
	413	.prepare = prepare_fn,
	414	.cleanup = cleanup_fn,
	415	.should_prune = should_prune_fn,
	416	.cb_data = policy_cb_data,
	417	};
cc40b5ce	418	int res = drefs->refs->be->reflog_expire(drefs->refs, refname,
34c31997 HWN	419	flags, &debug_reflog_expiry_prepare,
	420	&debug_reflog_expiry_should_prune_fn,
	421	&debug_reflog_expiry_cleanup,
	422	&prune);
4441f427 HWN	423	trace_printf_key(&trace_refs, "reflog_expire: %s: %d\n", refname, res);
	424	return res;
	425	}
	426
	427	struct ref_storage_be refs_be_debug = {
32bff617 ÆAB	428	.name = "debug",
	429	.init = NULL,
	430	.init_db = debug_init_db,
5b875404 ÆAB	431
	432	/*
	433	* None of these should be NULL. If the "files" backend (in
	434	* "struct ref_storage_be refs_be_files" in files-backend.c)
	435	* has a function we should also have a wrapper for it here.
	436	* Test the output with "GIT_TRACE_REFS=1".
	437	*/
32bff617 ÆAB	438	.transaction_prepare = debug_transaction_prepare,
	439	.transaction_finish = debug_transaction_finish,
	440	.transaction_abort = debug_transaction_abort,
	441	.initial_transaction_commit = debug_initial_transaction_commit,
	442
	443	.pack_refs = debug_pack_refs,
	444	.create_symref = debug_create_symref,
32bff617 ÆAB	445	.rename_ref = debug_rename_ref,
	446	.copy_ref = debug_copy_ref,
	447
	448	.iterator_begin = debug_ref_iterator_begin,
	449	.read_raw_ref = debug_read_raw_ref,
5b875404	450	.read_symbolic_ref = debug_read_symbolic_ref,
32bff617 ÆAB	451
	452	.reflog_iterator_begin = debug_reflog_iterator_begin,
	453	.for_each_reflog_ent = debug_for_each_reflog_ent,
	454	.for_each_reflog_ent_reverse = debug_for_each_reflog_ent_reverse,
	455	.reflog_exists = debug_reflog_exists,
	456	.create_reflog = debug_create_reflog,
	457	.delete_reflog = debug_delete_reflog,
	458	.reflog_expire = debug_reflog_expire,
4441f427	459	};