rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/refdb.c

@@ -24,7 +24,7 @@ int git_refdb_new(git_refdb **out, git_repository *repo)
 	assert(out && repo);
 
 	db = git__calloc(1, sizeof(*db));
-	GIT_ERROR_CHECK_ALLOC(db);
+	GITERR_CHECK_ALLOC(db);
 
 	db->repo = repo;
 
@@ -66,18 +66,6 @@ static void refdb_free_backend(git_refdb *db)
 
 int git_refdb_set_backend(git_refdb *db, git_refdb_backend *backend)
 {
-	GIT_ERROR_CHECK_VERSION(backend, GIT_REFDB_BACKEND_VERSION, "git_refdb_backend");
-
-	if (!backend->exists || !backend->lookup || !backend->iterator ||
-	    !backend->write || !backend->rename || !backend->del ||
-	    !backend->has_log || !backend->ensure_log || !backend->free ||
-	    !backend->reflog_read || !backend->reflog_write ||
-	    !backend->reflog_rename || !backend->reflog_delete ||
-	    (backend->lock && !backend->unlock)) {
-		git_error_set(GIT_ERROR_REFERENCE, "incomplete refdb backend implementation");
-		return GIT_EINVALID;
-	}
-
 	refdb_free_backend(db);
 	db->backend = backend;
 
@@ -139,7 +127,7 @@ int git_refdb_iterator(git_reference_iterator **out, git_refdb *db, const char *
 	int error;
 
 	if (!db->backend || !db->backend->iterator) {
-		git_error_set(GIT_ERROR_REFERENCE, "this backend doesn't support iterators");
+		giterr_set(GITERR_REFERENCE, "this backend doesn't support iterators");
 		return -1;
 	}
 
@@ -257,7 +245,7 @@ int git_refdb_lock(void **payload, git_refdb *db, const char *refname)
 	assert(payload && db && refname);
 
 	if (!db->backend->lock) {
-		git_error_set(GIT_ERROR_REFERENCE, "backend does not support locking");
+		giterr_set(GITERR_REFERENCE, "backend does not support locking");
 		return -1;
 	}
 

data/vendor/libgit2/src/refdb_fs.c

@@ -10,16 +10,14 @@
 #include "refs.h"
 #include "hash.h"
 #include "repository.h"
-#include "futils.h"
+#include "fileops.h"
 #include "filebuf.h"
 #include "pack.h"
-#include "parse.h"
 #include "reflog.h"
 #include "refdb.h"
 #include "iterator.h"
 #include "sortedcache.h"
 #include "signature.h"
-#include "wildmatch.h"
 
 #include <git2/tag.h>
 #include <git2/object.h>
@@ -96,7 +94,7 @@ static int packed_reload(refdb_fs_backend *backend)
 	if (error <= 0) {
 		if (error == GIT_ENOTFOUND) {
 			git_sortedcache_clear(backend->refcache, true);
-			git_error_clear();
+			giterr_clear();
 			error = 0;
 		}
 		return error;
@@ -185,16 +183,16 @@ static int packed_reload(refdb_fs_backend *backend)
 	}
 
 	git_sortedcache_wunlock(backend->refcache);
-	git_buf_dispose(&packedrefs);
+	git_buf_free(&packedrefs);
 
 	return 0;
 
 parse_failed:
-	git_error_set(GIT_ERROR_REFERENCE, "corrupted packed references file");
+	giterr_set(GITERR_REFERENCE, "corrupted packed references file");
 
 	git_sortedcache_clear(backend->refcache, false);
 	git_sortedcache_wunlock(backend->refcache);
-	git_buf_dispose(&packedrefs);
+	git_buf_free(&packedrefs);
 
 	return -1;
 }
@@ -217,7 +215,7 @@ static int loose_parse_oid(
 		return 0;
 
 corrupted:
-	git_error_set(GIT_ERROR_REFERENCE, "corrupted loose reference file: %s", filename);
+	giterr_set(GITERR_REFERENCE, "corrupted loose reference file: %s", filename);
 	return -1;
 }
 
@@ -228,7 +226,7 @@ static int loose_readbuffer(git_buf *buf, const char *base, const char *path)
 	/* build full path to file */
 	if ((error = git_buf_joinpath(buf, base, path)) < 0 ||
 		(error = git_futils_readbuffer(buf, buf->ptr)) < 0)
-		git_buf_dispose(buf);
+		git_buf_free(buf);
 
 	return error;
 }
@@ -244,7 +242,7 @@ static int loose_lookup_to_packfile(refdb_fs_backend *backend, const char *name)
 	 * the filesystem under us and skip it...
 	 */
 	if (loose_readbuffer(&ref_file, backend->gitpath, name) < 0) {
-		git_error_clear();
+		giterr_clear();
 		goto done;
 	}
 
@@ -268,7 +266,7 @@ static int loose_lookup_to_packfile(refdb_fs_backend *backend, const char *name)
 	git_sortedcache_wunlock(backend->refcache);
 
 done:
-	git_buf_dispose(&ref_file);
+	git_buf_free(&ref_file);
 	return error;
 }
 
@@ -285,7 +283,7 @@ static int _dirent_loose_load(void *payload, git_buf *full_path)
 			full_path, backend->direach_flags, _dirent_loose_load, backend);
 		/* Race with the filesystem, ignore it */
 		if (error == GIT_ENOTFOUND) {
-			git_error_clear();
+			giterr_clear();
 			return 0;
 		}
 
@@ -319,7 +317,7 @@ static int packed_loadloose(refdb_fs_backend *backend)
 	error = git_path_direach(
 		&refs_path, backend->direach_flags, _dirent_loose_load, backend);
 
-	git_buf_dispose(&refs_path);
+	git_buf_free(&refs_path);
 
 	return error;
 }
@@ -329,33 +327,21 @@ static int refdb_fs_backend__exists(
 	git_refdb_backend *_backend,
 	const char *ref_name)
 {
-	refdb_fs_backend *backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
+	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	git_buf ref_path = GIT_BUF_INIT;
 	int error;
 
 	assert(backend);
 
-	*exists = 0;
-
-	if ((error = git_buf_joinpath(&ref_path, backend->gitpath, ref_name)) < 0)
-		goto out;
-
-	if (git_path_isfile(ref_path.ptr)) {
-		*exists = 1;
-		goto out;
-	}
-
-	if ((error = packed_reload(backend)) < 0)
-		goto out;
+	if ((error = packed_reload(backend)) < 0 ||
+		(error = git_buf_joinpath(&ref_path, backend->gitpath, ref_name)) < 0)
+		return error;
 
-	if (git_sortedcache_lookup(backend->refcache, ref_name) != NULL) {
-		*exists = 1;
-		goto out;
-	}
+	*exists = git_path_isfile(ref_path.ptr) ||
+		(git_sortedcache_lookup(backend->refcache, ref_name) != NULL);
 
-out:
-	git_buf_dispose(&ref_path);
-	return error;
+	git_buf_free(&ref_path);
+	return 0;
 }
 
 static const char *loose_parse_symbolic(git_buf *file_content)
@@ -366,7 +352,7 @@ static const char *loose_parse_symbolic(git_buf *file_content)
 	refname_start = (const char *)file_content->ptr;
 
 	if (git_buf_len(file_content) < header_len + 1) {
-		git_error_set(GIT_ERROR_REFERENCE, "corrupted loose reference file");
+		giterr_set(GITERR_REFERENCE, "corrupted loose reference file");
 		return NULL;
 	}
 
@@ -428,13 +414,13 @@ static int loose_lookup(
 			*out = git_reference__alloc(ref_name, &oid, NULL);
 	}
 
-	git_buf_dispose(&ref_file);
+	git_buf_free(&ref_file);
 	return error;
 }
 
 static int ref_error_notfound(const char *name)
 {
-	git_error_set(GIT_ERROR_REFERENCE, "reference '%s' not found", name);
+	giterr_set(GITERR_REFERENCE, "reference '%s' not found", name);
 	return GIT_ENOTFOUND;
 }
 
@@ -471,7 +457,7 @@ static int refdb_fs_backend__lookup(
 	git_refdb_backend *_backend,
 	const char *ref_name)
 {
-	refdb_fs_backend *backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
+	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	int error;
 
 	assert(backend);
@@ -482,7 +468,7 @@ static int refdb_fs_backend__lookup(
 	/* only try to lookup this reference on the packfile if it
 	 * wasn't found on the loose refs; not if there was a critical error */
 	if (error == GIT_ENOTFOUND) {
-		git_error_clear();
+		giterr_clear();
 		error = packed_lookup(out, backend, ref_name);
 	}
 
@@ -504,7 +490,7 @@ typedef struct {
 
 static void refdb_fs_backend__iterator_free(git_reference_iterator *_iter)
 {
-	refdb_fs_iter *iter = GIT_CONTAINER_OF(_iter, refdb_fs_iter, parent);
+	refdb_fs_iter *iter = (refdb_fs_iter *) _iter;
 
 	git_vector_free(&iter->loose);
 	git_pool_clear(&iter->pool);
@@ -519,63 +505,39 @@ static int iter_load_loose_paths(refdb_fs_backend *backend, refdb_fs_iter *iter)
 	git_iterator *fsit = NULL;
 	git_iterator_options fsit_opts = GIT_ITERATOR_OPTIONS_INIT;
 	const git_index_entry *entry = NULL;
-	const char *ref_prefix = GIT_REFS_DIR;
-	size_t ref_prefix_len = strlen(ref_prefix);
 
 	if (!backend->commonpath) /* do nothing if no commonpath for loose refs */
 		return 0;
 
 	fsit_opts.flags = backend->iterator_flags;
 
-	if (iter->glob) {
-		const char *last_sep = NULL;
-		const char *pos;
-		for (pos = iter->glob; *pos; ++pos) {
-			switch (*pos) {
-			case '?':
-			case '*':
-			case '[':
-			case '\\':
-				break;
-			case '/':
-				last_sep = pos;
-				/* FALLTHROUGH */
-			default:
-				continue;
-			}
-			break;
-		}
-		if (last_sep) {
-			ref_prefix = iter->glob;
-			ref_prefix_len = (last_sep - ref_prefix) + 1;
-		}
-	}
-
-	if ((error = git_buf_printf(&path, "%s/", backend->commonpath)) < 0 ||
-		(error = git_buf_put(&path, ref_prefix, ref_prefix_len)) < 0) {
-		git_buf_dispose(&path);
+	if ((error = git_buf_printf(&path, "%s/refs", backend->commonpath)) < 0 ||
+		(error = git_iterator_for_filesystem(&fsit, path.ptr, &fsit_opts)) < 0) {
+		git_buf_free(&path);
 		return error;
 	}
 
-	if ((error = git_iterator_for_filesystem(&fsit, path.ptr, &fsit_opts)) < 0) {
-		git_buf_dispose(&path);
-		return (iter->glob && error == GIT_ENOTFOUND)? 0 : error;
-	}
-
-	error = git_buf_sets(&path, ref_prefix);
+	error = git_buf_sets(&path, GIT_REFS_DIR);
 
 	while (!error && !git_iterator_advance(&entry, fsit)) {
 		const char *ref_name;
+		struct packref *ref;
 		char *ref_dup;
 
-		git_buf_truncate(&path, ref_prefix_len);
+		git_buf_truncate(&path, strlen(GIT_REFS_DIR));
 		git_buf_puts(&path, entry->path);
 		ref_name = git_buf_cstr(&path);
 
 		if (git__suffixcmp(ref_name, ".lock") == 0 ||
-			(iter->glob && wildmatch(iter->glob, ref_name, 0) != 0))
+			(iter->glob && p_fnmatch(iter->glob, ref_name, 0) != 0))
 			continue;
 
+		git_sortedcache_rlock(backend->refcache);
+		ref = git_sortedcache_lookup(backend->refcache, ref_name);
+		if (ref)
+			ref->flags |= PACKREF_SHADOWED;
+		git_sortedcache_runlock(backend->refcache);
+
 		ref_dup = git_pool_strdup(&iter->pool, ref_name);
 		if (!ref_dup)
 			error = -1;
@@ -584,7 +546,7 @@ static int iter_load_loose_paths(refdb_fs_backend *backend, refdb_fs_iter *iter)
 	}
 
 	git_iterator_free(fsit);
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	return error;
 }
@@ -593,22 +555,22 @@ static int refdb_fs_backend__iterator_next(
 	git_reference **out, git_reference_iterator *_iter)
 {
 	int error = GIT_ITEROVER;
-	refdb_fs_iter *iter = GIT_CONTAINER_OF(_iter, refdb_fs_iter, parent);
-	refdb_fs_backend *backend = GIT_CONTAINER_OF(iter->parent.db->backend, refdb_fs_backend, parent);
+	refdb_fs_iter *iter = (refdb_fs_iter *)_iter;
+	refdb_fs_backend *backend = (refdb_fs_backend *)iter->parent.db->backend;
 	struct packref *ref;
 
 	while (iter->loose_pos < iter->loose.length) {
 		const char *path = git_vector_get(&iter->loose, iter->loose_pos++);
 
-		if (loose_lookup(out, backend, path) == 0) {
-			ref = git_sortedcache_lookup(iter->cache, path);
-			if (ref)
-				ref->flags |= PACKREF_SHADOWED;
-
+		if (loose_lookup(out, backend, path) == 0)
 			return 0;
-		}
 
-		git_error_clear();
+		giterr_clear();
+	}
+
+	if (!iter->cache) {
+		if ((error = git_sortedcache_copy(&iter->cache, backend->refcache, 1, NULL, NULL)) < 0)
+			return error;
 	}
 
 	error = GIT_ITEROVER;
@@ -619,7 +581,7 @@ static int refdb_fs_backend__iterator_next(
 
 		if (ref->flags & PACKREF_SHADOWED)
 			continue;
-		if (iter->glob && wildmatch(iter->glob, ref->name, 0) != 0)
+		if (iter->glob && p_fnmatch(iter->glob, ref->name, 0) != 0)
 			continue;
 
 		*out = git_reference__alloc(ref->name, &ref->oid, &ref->peel);
@@ -634,24 +596,24 @@ static int refdb_fs_backend__iterator_next_name(
 	const char **out, git_reference_iterator *_iter)
 {
 	int error = GIT_ITEROVER;
-	refdb_fs_iter *iter = GIT_CONTAINER_OF(_iter, refdb_fs_iter, parent);
-	refdb_fs_backend *backend = GIT_CONTAINER_OF(iter->parent.db->backend, refdb_fs_backend, parent);
+	refdb_fs_iter *iter = (refdb_fs_iter *)_iter;
+	refdb_fs_backend *backend = (refdb_fs_backend *)iter->parent.db->backend;
 	struct packref *ref;
 
 	while (iter->loose_pos < iter->loose.length) {
 		const char *path = git_vector_get(&iter->loose, iter->loose_pos++);
-		struct packref *ref;
 
 		if (loose_lookup(NULL, backend, path) == 0) {
-			ref = git_sortedcache_lookup(iter->cache, path);
-			if (ref)
-				ref->flags |= PACKREF_SHADOWED;
-
 			*out = path;
 			return 0;
 		}
 
-		git_error_clear();
+		giterr_clear();
+	}
+
+	if (!iter->cache) {
+		if ((error = git_sortedcache_copy(&iter->cache, backend->refcache, 1, NULL, NULL)) < 0)
+			return error;
 	}
 
 	error = GIT_ITEROVER;
@@ -662,7 +624,7 @@ static int refdb_fs_backend__iterator_next_name(
 
 		if (ref->flags & PACKREF_SHADOWED)
 			continue;
-		if (iter->glob && wildmatch(iter->glob, ref->name, 0) != 0)
+		if (iter->glob && p_fnmatch(iter->glob, ref->name, 0) != 0)
 			continue;
 
 		*out = ref->name;
@@ -676,44 +638,40 @@ static int refdb_fs_backend__iterator_next_name(
 static int refdb_fs_backend__iterator(
 	git_reference_iterator **out, git_refdb_backend *_backend, const char *glob)
 {
-	refdb_fs_backend *backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
-	refdb_fs_iter *iter = NULL;
 	int error;
+	refdb_fs_iter *iter;
+	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 
 	assert(backend);
 
+	if ((error = packed_reload(backend)) < 0)
+		return error;
+
 	iter = git__calloc(1, sizeof(refdb_fs_iter));
-	GIT_ERROR_CHECK_ALLOC(iter);
+	GITERR_CHECK_ALLOC(iter);
 
 	git_pool_init(&iter->pool, 1);
 
-	if ((error = git_vector_init(&iter->loose, 8, NULL)) < 0)
-		goto out;
+	if (git_vector_init(&iter->loose, 8, NULL) < 0)
+		goto fail;
 
 	if (glob != NULL &&
-	    (iter->glob = git_pool_strdup(&iter->pool, glob)) == NULL) {
-		error = GIT_ERROR_NOMEMORY;
-		goto out;
-	}
-
-	if ((error = iter_load_loose_paths(backend, iter)) < 0)
-		goto out;
-
-	if ((error = packed_reload(backend)) < 0)
-		goto out;
-
-	if ((error = git_sortedcache_copy(&iter->cache, backend->refcache, 1, NULL, NULL)) < 0)
-		goto out;
+		(iter->glob = git_pool_strdup(&iter->pool, glob)) == NULL)
+		goto fail;
 
 	iter->parent.next = refdb_fs_backend__iterator_next;
 	iter->parent.next_name = refdb_fs_backend__iterator_next_name;
 	iter->parent.free = refdb_fs_backend__iterator_free;
 
+	if (iter_load_loose_paths(backend, iter) < 0)
+		goto fail;
+
 	*out = (git_reference_iterator *)iter;
-out:
-	if (error)
-		refdb_fs_backend__iterator_free((git_reference_iterator *)iter);
-	return error;
+	return 0;
+
+fail:
+	refdb_fs_backend__iterator_free((git_reference_iterator *)iter);
+	return -1;
 }
 
 static bool ref_is_available(
@@ -754,7 +712,7 @@ static int reference_path_available(
 		}
 
 		if (exists) {
-			git_error_set(GIT_ERROR_REFERENCE,
+			giterr_set(GITERR_REFERENCE,
 				"failed to write reference '%s': a reference with "
 				"that name already exists.", new_ref);
 			return GIT_EEXISTS;
@@ -768,7 +726,7 @@ static int reference_path_available(
 
 		if (ref && !ref_is_available(old_ref, new_ref, ref->name)) {
 			git_sortedcache_runlock(backend->refcache);
-			git_error_set(GIT_ERROR_REFERENCE,
+			giterr_set(GITERR_REFERENCE,
 				"path to reference '%s' collides with existing one", new_ref);
 			return -1;
 		}
@@ -787,7 +745,7 @@ static int loose_lock(git_filebuf *file, refdb_fs_backend *backend, const char *
 	assert(file && backend && name);
 
 	if (!git_path_isvalid(backend->repo, name, 0, GIT_PATH_REJECT_FILESYSTEM_DEFAULTS)) {
-		git_error_set(GIT_ERROR_INVALID, "invalid reference name '%s'", name);
+		giterr_set(GITERR_INVALID, "invalid reference name '%s'", name);
 		return GIT_EINVALIDSPEC;
 	}
 
@@ -805,16 +763,16 @@ static int loose_lock(git_filebuf *file, refdb_fs_backend *backend, const char *
 	if (git_buf_joinpath(&ref_path, basedir, name) < 0)
 		return -1;
 
-	filebuf_flags = GIT_FILEBUF_CREATE_LEADING_DIRS;
+	filebuf_flags = GIT_FILEBUF_FORCE;
 	if (backend->fsync)
 		filebuf_flags |= GIT_FILEBUF_FSYNC;
 
 	error = git_filebuf_open(file, ref_path.ptr, filebuf_flags, GIT_REFS_FILE_MODE);
 
 	if (error == GIT_EDIRECTORY)
-		git_error_set(GIT_ERROR_REFERENCE, "cannot lock ref '%s', there are refs beneath that folder", name);
+		giterr_set(GITERR_REFERENCE, "cannot lock ref '%s', there are refs beneath that folder", name);
 
-	git_buf_dispose(&ref_path);
+	git_buf_free(&ref_path);
 	return error;
 }
 
@@ -822,12 +780,12 @@ static int loose_commit(git_filebuf *file, const git_reference *ref)
 {
 	assert(file && ref);
 
-	if (ref->type == GIT_REFERENCE_DIRECT) {
+	if (ref->type == GIT_REF_OID) {
 		char oid[GIT_OID_HEXSZ + 1];
 		git_oid_nfmt(oid, sizeof(oid), &ref->target.oid);
 
 		git_filebuf_printf(file, "%s\n", oid);
-	} else if (ref->type == GIT_REFERENCE_SYMBOLIC) {
+	} else if (ref->type == GIT_REF_SYMBOLIC) {
 		git_filebuf_printf(file, GIT_SYMREF "%s\n", ref->target.symbolic);
 	} else {
 		assert(0); /* don't let this happen */
@@ -840,10 +798,10 @@ static int refdb_fs_backend__lock(void **out, git_refdb_backend *_backend, const
 {
 	int error;
 	git_filebuf *lock;
-	refdb_fs_backend *backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
+	refdb_fs_backend *backend = (refdb_fs_backend *) _backend;
 
 	lock = git__calloc(1, sizeof(git_filebuf));
-	GIT_ERROR_CHECK_ALLOC(lock);
+	GITERR_CHECK_ALLOC(lock);
 
 	if ((error = loose_lock(lock, backend, refname)) < 0) {
 		git__free(lock);
@@ -859,17 +817,16 @@ static int refdb_fs_backend__write_tail(
 	const git_reference *ref,
 	git_filebuf *file,
 	int update_reflog,
-	const git_oid *old_id,
-	const char *old_target,
 	const git_signature *who,
-	const char *message);
+	const char *message,
+	const git_oid *old_id,
+	const char *old_target);
 
 static int refdb_fs_backend__delete_tail(
 	git_refdb_backend *_backend,
 	git_filebuf *file,
 	const char *ref_name,
-	const git_oid *old_id,
-	const char *old_target);
+	const git_oid *old_id, const char *old_target);
 
 static int refdb_fs_backend__unlock(git_refdb_backend *backend, void *payload, int success, int update_reflog,
 				    const git_reference *ref, const git_signature *sig, const char *message)
@@ -880,7 +837,7 @@ static int refdb_fs_backend__unlock(git_refdb_backend *backend, void *payload, i
 	if (success == 2)
 		error = refdb_fs_backend__delete_tail(backend, lock, ref->name, NULL, NULL);
 	else if (success)
-		error = refdb_fs_backend__write_tail(backend, ref, lock, update_reflog, NULL, NULL, sig, message);
+		error = refdb_fs_backend__write_tail(backend, ref, lock, update_reflog, sig, message, NULL, NULL);
 	else
 		git_filebuf_cleanup(lock);
 
@@ -906,7 +863,7 @@ static int packed_find_peel(refdb_fs_backend *backend, struct packref *ref)
 	/*
 	 * Find the tagged object in the repository
 	 */
-	if (git_object_lookup(&object, backend->repo, &ref->oid, GIT_OBJECT_ANY) < 0)
+	if (git_object_lookup(&object, backend->repo, &ref->oid, GIT_OBJ_ANY) < 0)
 		return -1;
 
 	/*
@@ -914,7 +871,7 @@ static int packed_find_peel(refdb_fs_backend *backend, struct packref *ref)
 	 * if the ref is actually a 'weak' ref, we don't need to resolve
 	 * anything.
 	 */
-	if (git_object_type(object) == GIT_OBJECT_TAG) {
+	if (git_object_type(object) == GIT_OBJ_TAG) {
 		git_tag *tag = (git_tag *)object;
 
 		/*
@@ -1002,8 +959,8 @@ static int packed_remove_loose(refdb_fs_backend *backend)
 			continue;
 
 		if (error < 0) {
-			git_buf_dispose(&ref_content);
-			git_error_set(GIT_ERROR_REFERENCE, "failed to lock loose reference '%s'", ref->name);
+			git_buf_free(&ref_content);
+			giterr_set(GITERR_REFERENCE, "failed to lock loose reference '%s'", ref->name);
 			return error;
 		}
 
@@ -1033,7 +990,7 @@ static int packed_remove_loose(refdb_fs_backend *backend)
 		p_unlink(lock.path_original);
 	}
 
-	git_buf_dispose(&ref_content);
+	git_buf_free(&ref_content);
 	git_filebuf_cleanup(&lock);
 	return 0;
 }
@@ -1099,43 +1056,15 @@ fail:
 	return error;
 }
 
-static int packed_delete(refdb_fs_backend *backend, const char *ref_name)
-{
-	size_t pack_pos;
-	int error, found = 0;
-
-	if ((error = packed_reload(backend)) < 0)
-		goto cleanup;
-
-	if ((error = git_sortedcache_wlock(backend->refcache)) < 0)
-		goto cleanup;
-
-	/* If a packed reference exists, remove it from the packfile and repack if necessary */
-	error = git_sortedcache_lookup_index(&pack_pos, backend->refcache, ref_name);
-	if (error == 0) {
-		error = git_sortedcache_remove(backend->refcache, pack_pos);
-		found = 1;
-	}
-	if (error == GIT_ENOTFOUND)
-		error = 0;
-
-	git_sortedcache_wunlock(backend->refcache);
-
-	if (found)
-		error = packed_write(backend);
-
-cleanup:
-	return error;
-}
-
 static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, const git_oid *old, const git_oid *new, const git_signature *author, const char *message);
 static int has_reflog(git_repository *repo, const char *name);
 
+/* We only write if it's under heads/, remotes/ or notes/ or if it already has a log */
 static int should_write_reflog(int *write, git_repository *repo, const char *name)
 {
 	int error, logall;
 
-	error = git_repository__configmap_lookup(&logall, repo, GIT_CONFIGMAP_LOGALLREFUPDATES);
+	error = git_repository__cvar(&logall, repo, GIT_CVAR_LOGALLREFUPDATES);
 	if (error < 0)
 		return error;
 
@@ -1143,26 +1072,17 @@ static int should_write_reflog(int *write, git_repository *repo, const char *nam
 	if (logall == GIT_LOGALLREFUPDATES_UNSET)
 		logall = !git_repository_is_bare(repo);
 
-	*write = 0;
-	switch (logall) {
-	case GIT_LOGALLREFUPDATES_FALSE:
+	if (!logall) {
 		*write = 0;
-		break;
-
-	case GIT_LOGALLREFUPDATES_TRUE:
-		/* Only write if it already has a log,
-		 * or if it's under heads/, remotes/ or notes/
-		 */
-		*write = has_reflog(repo, name) ||
-			!git__prefixcmp(name, GIT_REFS_HEADS_DIR) ||
-			!git__strcmp(name, GIT_HEAD_FILE) ||
-			!git__prefixcmp(name, GIT_REFS_REMOTES_DIR) ||
-			!git__prefixcmp(name, GIT_REFS_NOTES_DIR);
-		break;
-
-	case GIT_LOGALLREFUPDATES_ALWAYS:
+	} else if (has_reflog(repo, name)) {
 		*write = 1;
-		break;
+	} else if (!git__prefixcmp(name, GIT_REFS_HEADS_DIR) ||
+		   !git__strcmp(name, GIT_HEAD_FILE) ||
+		   !git__prefixcmp(name, GIT_REFS_REMOTES_DIR) ||
+		   !git__prefixcmp(name, GIT_REFS_NOTES_DIR)) {
+		*write = 1;
+	} else {
+		*write = 0;
 	}
 
 	return 0;
@@ -1183,19 +1103,19 @@ static int cmp_old_ref(int *cmp, git_refdb_backend *backend, const char *name,
 		goto out;
 
 	/* If the types don't match, there's no way the values do */
-	if (old_id && old_ref->type != GIT_REFERENCE_DIRECT) {
+	if (old_id && old_ref->type != GIT_REF_OID) {
 		*cmp = -1;
 		goto out;
 	}
-	if (old_target && old_ref->type != GIT_REFERENCE_SYMBOLIC) {
+	if (old_target && old_ref->type != GIT_REF_SYMBOLIC) {
 		*cmp = 1;
 		goto out;
 	}
 
-	if (old_id && old_ref->type == GIT_REFERENCE_DIRECT)
+	if (old_id && old_ref->type == GIT_REF_OID)
 		*cmp = git_oid_cmp(old_id, &old_ref->target.oid);
 
-	if (old_target && old_ref->type == GIT_REFERENCE_SYMBOLIC)
+	if (old_target && old_ref->type == GIT_REF_SYMBOLIC)
 		*cmp = git__strcmp(old_target, old_ref->target.symbolic);
 
 out:
@@ -1225,7 +1145,7 @@ static int maybe_append_head(refdb_fs_backend *backend, const git_reference *ref
 	git_reference *tmp = NULL, *head = NULL, *peeled = NULL;
 	const char *name;
 
-	if (ref->type == GIT_REFERENCE_SYMBOLIC)
+	if (ref->type == GIT_REF_SYMBOLIC)
 		return 0;
 
 	/* if we can't resolve, we use {0}*40 as old id */
@@ -1235,14 +1155,14 @@ static int maybe_append_head(refdb_fs_backend *backend, const git_reference *ref
 	if ((error = git_reference_lookup(&head, backend->repo, GIT_HEAD_FILE)) < 0)
 		return error;
 
-	if (git_reference_type(head) == GIT_REFERENCE_DIRECT)
+	if (git_reference_type(head) == GIT_REF_OID)
 		goto cleanup;
 
 	if ((error = git_reference_lookup(&tmp, backend->repo, GIT_HEAD_FILE)) < 0)
 		goto cleanup;
 
 	/* Go down the symref chain until we find the branch */
-	while (git_reference_type(tmp) == GIT_REFERENCE_SYMBOLIC) {
+	while (git_reference_type(tmp) == GIT_REF_SYMBOLIC) {
 		error = git_reference_lookup(&peeled, backend->repo, git_reference_symbolic_target(tmp));
 		if (error < 0)
 			break;
@@ -1280,7 +1200,7 @@ static int refdb_fs_backend__write(
 	const git_oid *old_id,
 	const char *old_target)
 {
-	refdb_fs_backend *backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
+	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	git_filebuf file = GIT_FILEBUF_INIT;
 	int error = 0;
 
@@ -1293,7 +1213,7 @@ static int refdb_fs_backend__write(
 	if ((error = loose_lock(&file, backend, ref->name)) < 0)
 		return error;
 
-	return refdb_fs_backend__write_tail(_backend, ref, &file, true, old_id, old_target, who, message);
+	return refdb_fs_backend__write_tail(_backend, ref, &file, true, who, message, old_id, old_target);
 }
 
 static int refdb_fs_backend__write_tail(
@@ -1301,12 +1221,12 @@ static int refdb_fs_backend__write_tail(
 	const git_reference *ref,
 	git_filebuf *file,
 	int update_reflog,
-	const git_oid *old_id,
-	const char *old_target,
 	const git_signature *who,
-	const char *message)
+	const char *message,
+	const git_oid *old_id,
+	const char *old_target)
 {
-	refdb_fs_backend *backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
+	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	int error = 0, cmp = 0, should_write;
 	const char *new_target = NULL;
 	const git_oid *new_id = NULL;
@@ -1315,12 +1235,12 @@ static int refdb_fs_backend__write_tail(
 		goto on_error;
 
 	if (cmp) {
-		git_error_set(GIT_ERROR_REFERENCE, "old reference value does not match");
+		giterr_set(GITERR_REFERENCE, "old reference value does not match");
 		error = GIT_EMODIFIED;
 		goto on_error;
 	}
 
-	if (ref->type == GIT_REFERENCE_SYMBOLIC)
+	if (ref->type == GIT_REF_SYMBOLIC)
 		new_target = ref->target.symbolic;
 	else
 		new_id = &ref->target.oid;
@@ -1354,49 +1274,12 @@ on_error:
         return error;
 }
 
-static void refdb_fs_backend__prune_refs(
-	refdb_fs_backend *backend,
-	const char *ref_name,
-	const char *prefix)
-{
-	git_buf relative_path = GIT_BUF_INIT;
-	git_buf base_path = GIT_BUF_INIT;
-	size_t commonlen;
-
-	assert(backend && ref_name);
-
-	if (git_buf_sets(&relative_path, ref_name) < 0)
-		goto cleanup;
-
-	git_path_squash_slashes(&relative_path);
-	if ((commonlen = git_path_common_dirlen("refs/heads/", git_buf_cstr(&relative_path))) == strlen("refs/heads/") ||
-		(commonlen = git_path_common_dirlen("refs/tags/", git_buf_cstr(&relative_path))) == strlen("refs/tags/") ||
-		(commonlen = git_path_common_dirlen("refs/remotes/", git_buf_cstr(&relative_path))) == strlen("refs/remotes/")) {
-
-		git_buf_truncate(&relative_path, commonlen);
-
-		if (prefix) {
-			if (git_buf_join3(&base_path, '/', backend->commonpath, prefix, git_buf_cstr(&relative_path)) < 0)
-				goto cleanup;
-		} else {
-			if (git_buf_joinpath(&base_path, backend->commonpath, git_buf_cstr(&relative_path)) < 0)
-				goto cleanup;
-		}
-
-		git_futils_rmdir_r(ref_name + commonlen, git_buf_cstr(&base_path), GIT_RMDIR_EMPTY_PARENTS | GIT_RMDIR_SKIP_ROOT);
-	}
-
-cleanup:
-	git_buf_dispose(&relative_path);
-	git_buf_dispose(&base_path);
-}
-
 static int refdb_fs_backend__delete(
 	git_refdb_backend *_backend,
 	const char *ref_name,
 	const git_oid *old_id, const char *old_target)
 {
-	refdb_fs_backend *backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
+	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	git_filebuf file = GIT_FILEBUF_INIT;
 	int error = 0;
 
@@ -1413,80 +1296,65 @@ static int refdb_fs_backend__delete(
 	return refdb_fs_backend__delete_tail(_backend, &file, ref_name, old_id, old_target);
 }
 
-static int loose_delete(refdb_fs_backend *backend, const char *ref_name)
-{
-	git_buf loose_path = GIT_BUF_INIT;
-	int error = 0;
-
-	if (git_buf_joinpath(&loose_path, backend->commonpath, ref_name) < 0)
-		return -1;
-
-	error = p_unlink(loose_path.ptr);
-	if (error < 0 && errno == ENOENT)
-		error = GIT_ENOTFOUND;
-	else if (error != 0)
-		error = -1;
-
-	git_buf_dispose(&loose_path);
-
-	return error;
-}
-
 static int refdb_fs_backend__delete_tail(
 	git_refdb_backend *_backend,
 	git_filebuf *file,
 	const char *ref_name,
 	const git_oid *old_id, const char *old_target)
 {
-	refdb_fs_backend *backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
+	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
+	git_buf loose_path = GIT_BUF_INIT;
+	size_t pack_pos;
 	int error = 0, cmp = 0;
-	bool packed_deleted = 0;
+	bool loose_deleted = 0;
 
 	error = cmp_old_ref(&cmp, _backend, ref_name, old_id, old_target);
 	if (error < 0)
 		goto cleanup;
 
 	if (cmp) {
-		git_error_set(GIT_ERROR_REFERENCE, "old reference value does not match");
+		giterr_set(GITERR_REFERENCE, "old reference value does not match");
 		error = GIT_EMODIFIED;
 		goto cleanup;
 	}
 
-	/*
-	 * To ensure that an external observer will see either the current ref value
-	 * (because the loose ref still exists), or a missing ref (after the packed-file is
-	 * unlocked, there will be nothing left), we must ensure things happen in the
-	 * following order:
-	 *
-	 * - the packed-ref file is locked and loaded, as well as a loose one, if it exists
-	 * - we optimistically delete a packed ref, keeping track of whether it existed
-	 * - we delete the loose ref, note that we have its .lock
-	 * - the loose ref is "unlocked", then the packed-ref file is rewritten and unlocked
-	 * - we should prune the path components if a loose ref was deleted
-	 *
-	 * Note that, because our packed backend doesn't expose its filesystem lock,
-	 * we might not be able to guarantee that this is what actually happens (ie.
-	 * as our current code never write packed-refs.lock, nothing stops observers
-	 * from grabbing a "stale" value from there).
-	 */
-	if ((error = packed_delete(backend, ref_name)) < 0 && error != GIT_ENOTFOUND)
+	/* If a loose reference exists, remove it from the filesystem */
+	if (git_buf_joinpath(&loose_path, backend->gitpath, ref_name) < 0)
+		return -1;
+
+
+	error = p_unlink(loose_path.ptr);
+	if (error < 0 && errno == ENOENT)
+		error = 0;
+	else if (error < 0)
 		goto cleanup;
+	else if (error == 0)
+		loose_deleted = 1;
 
-	if (error == 0)
-		packed_deleted = 1;
+	if ((error = packed_reload(backend)) < 0)
+		goto cleanup;
 
-	if ((error = loose_delete(backend, ref_name)) < 0 && error != GIT_ENOTFOUND)
+	/* If a packed reference exists, remove it from the packfile and repack */
+	if ((error = git_sortedcache_wlock(backend->refcache)) < 0)
 		goto cleanup;
 
+	if (!(error = git_sortedcache_lookup_index(
+			&pack_pos, backend->refcache, ref_name)))
+		error = git_sortedcache_remove(backend->refcache, pack_pos);
+
+	git_sortedcache_wunlock(backend->refcache);
+
 	if (error == GIT_ENOTFOUND) {
-		error = packed_deleted ? 0 : ref_error_notfound(ref_name);
+		error = loose_deleted ? 0 : ref_error_notfound(ref_name);
 		goto cleanup;
 	}
 
+	error = packed_write(backend);
+
 cleanup:
+	git_buf_free(&loose_path);
 	git_filebuf_cleanup(file);
-	if (error == 0)
-		refdb_fs_backend__prune_refs(backend, ref_name, "");
+
 	return error;
 }
 
@@ -1501,7 +1369,7 @@ static int refdb_fs_backend__rename(
 	const git_signature *who,
 	const char *message)
 {
-	refdb_fs_backend *backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
+	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	git_reference *old, *new;
 	git_filebuf file = GIT_FILEBUF_INIT;
 	int error;
@@ -1557,7 +1425,7 @@ static int refdb_fs_backend__rename(
 static int refdb_fs_backend__compress(git_refdb_backend *_backend)
 {
 	int error;
-	refdb_fs_backend *backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
+	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 
 	assert(backend);
 
@@ -1571,7 +1439,7 @@ static int refdb_fs_backend__compress(git_refdb_backend *_backend)
 
 static void refdb_fs_backend__free(git_refdb_backend *_backend)
 {
-	refdb_fs_backend *backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
+	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 
 	assert(backend);
 
@@ -1623,7 +1491,7 @@ static char *setup_namespace(git_repository *repo, const char *in)
 	out = git_buf_detach(&path);
 
 done:
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 	return out;
 }
 
@@ -1634,10 +1502,10 @@ static int reflog_alloc(git_reflog **reflog, const char *name)
 	*reflog = NULL;
 
 	log = git__calloc(1, sizeof(git_reflog));
-	GIT_ERROR_CHECK_ALLOC(log);
+	GITERR_CHECK_ALLOC(log);
 
 	log->ref_name = git__strdup(name);
-	GIT_ERROR_CHECK_ALLOC(log->ref_name);
+	GITERR_CHECK_ALLOC(log->ref_name);
 
 	if (git_vector_init(&log->entries, 0, NULL) < 0) {
 		git__free(log->ref_name);
@@ -1652,57 +1520,70 @@ static int reflog_alloc(git_reflog **reflog, const char *name)
 
 static int reflog_parse(git_reflog *log, const char *buf, size_t buf_size)
 {
-	git_parse_ctx parser = GIT_PARSE_CTX_INIT;
+	const char *ptr;
+	git_reflog_entry *entry;
 
-	if ((git_parse_ctx_init(&parser, buf, buf_size)) < 0)
-		return -1;
+#define seek_forward(_increase) do { \
+	if (_increase >= buf_size) { \
+		giterr_set(GITERR_INVALID, "ran out of data while parsing reflog"); \
+		goto fail; \
+	} \
+	buf += _increase; \
+	buf_size -= _increase; \
+	} while (0)
 
-	for (; parser.remain_len; git_parse_advance_line(&parser)) {
-		git_reflog_entry *entry;
-		const char *sig;
-		char c;
+	while (buf_size > GIT_REFLOG_SIZE_MIN) {
+		entry = git__calloc(1, sizeof(git_reflog_entry));
+		GITERR_CHECK_ALLOC(entry);
 
-		entry = git__calloc(1, sizeof(*entry));
-		GIT_ERROR_CHECK_ALLOC(entry);
-		entry->committer = git__calloc(1, sizeof(*entry->committer));
-		GIT_ERROR_CHECK_ALLOC(entry->committer);
+		entry->committer = git__calloc(1, sizeof(git_signature));
+		GITERR_CHECK_ALLOC(entry->committer);
 
-		if (git_parse_advance_oid(&entry->oid_old, &parser) < 0 ||
-		    git_parse_advance_expected(&parser, " ", 1) < 0 ||
-		    git_parse_advance_oid(&entry->oid_cur, &parser) < 0)
-			goto next;
+		if (git_oid_fromstrn(&entry->oid_old, buf, GIT_OID_HEXSZ) < 0)
+			goto fail;
+		seek_forward(GIT_OID_HEXSZ + 1);
 
-		sig = parser.line;
-		while (git_parse_peek(&c, &parser, 0) == 0 && c != '\t' && c != '\n')
-			git_parse_advance_chars(&parser, 1);
+		if (git_oid_fromstrn(&entry->oid_cur, buf, GIT_OID_HEXSZ) < 0)
+			goto fail;
+		seek_forward(GIT_OID_HEXSZ + 1);
 
-		if (git_signature__parse(entry->committer, &sig, parser.line, NULL, 0) < 0)
-			goto next;
+		ptr = buf;
 
-		if (c == '\t') {
-			size_t len;
-			git_parse_advance_chars(&parser, 1);
+		/* Seek forward to the end of the signature. */
+		while (*buf && *buf != '\t' && *buf != '\n')
+			seek_forward(1);
 
-			len = parser.line_len;
-			if (parser.line[len - 1] == '\n')
-				len--;
+		if (git_signature__parse(entry->committer, &ptr, buf + 1, NULL, *buf) < 0)
+			goto fail;
 
-			entry->msg = git__strndup(parser.line, len);
-			GIT_ERROR_CHECK_ALLOC(entry->msg);
-		}
+		if (*buf == '\t') {
+			/* We got a message. Read everything till we reach LF. */
+			seek_forward(1);
+			ptr = buf;
 
-		if ((git_vector_insert(&log->entries, entry)) < 0) {
-			git_reflog_entry__free(entry);
-			return -1;
-		}
+			while (*buf && *buf != '\n')
+				seek_forward(1);
 
-		continue;
+			entry->msg = git__strndup(ptr, buf - ptr);
+			GITERR_CHECK_ALLOC(entry->msg);
+		} else
+			entry->msg = NULL;
 
-next:
-		git_reflog_entry__free(entry);
+		while (*buf && *buf == '\n' && buf_size > 1)
+			seek_forward(1);
+
+		if (git_vector_insert(&log->entries, entry) < 0)
+			goto fail;
 	}
 
 	return 0;
+
+#undef seek_forward
+
+fail:
+	git_reflog_entry__free(entry);
+
+	return -1;
 }
 
 static int create_new_reflog_file(const char *filepath)
@@ -1736,14 +1617,14 @@ static int refdb_reflog_fs__ensure_log(git_refdb_backend *_backend, const char *
 
 	assert(_backend && name);
 
-	backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
+	backend = (refdb_fs_backend *) _backend;
 	repo = backend->repo;
 
 	if ((error = retrieve_reflog_path(&path, repo, name)) < 0)
 		return error;
 
 	error = create_new_reflog_file(git_buf_cstr(&path));
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	return error;
 }
@@ -1759,7 +1640,7 @@ static int has_reflog(git_repository *repo, const char *name)
 	ret = git_path_isfile(git_buf_cstr(&path));
 
 cleanup:
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 	return ret;
 }
 
@@ -1769,7 +1650,7 @@ static int refdb_reflog_fs__has_log(git_refdb_backend *_backend, const char *nam
 
 	assert(_backend && name);
 
-	backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
+	backend = (refdb_fs_backend *) _backend;
 
 	return has_reflog(backend->repo, name);
 }
@@ -1785,7 +1666,7 @@ static int refdb_reflog_fs__read(git_reflog **out, git_refdb_backend *_backend,
 
 	assert(out && _backend && name);
 
-	backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
+	backend = (refdb_fs_backend *) _backend;
 	repo = backend->repo;
 
 	if (reflog_alloc(&log, name) < 0)
@@ -1801,7 +1682,7 @@ static int refdb_reflog_fs__read(git_reflog **out, git_refdb_backend *_backend,
 	if ((error == GIT_ENOTFOUND) &&
 		((error = create_new_reflog_file(git_buf_cstr(&log_path))) < 0))
 		goto cleanup;
-
+ 
 	if ((error = reflog_parse(log,
 		git_buf_cstr(&log_file), git_buf_len(&log_file))) < 0)
 		goto cleanup;
@@ -1813,8 +1694,8 @@ cleanup:
 	git_reflog_free(log);
 
 success:
-	git_buf_dispose(&log_file);
-	git_buf_dispose(&log_path);
+	git_buf_free(&log_file);
+	git_buf_free(&log_path);
 
 	return error;
 }
@@ -1844,15 +1725,8 @@ static int serialize_reflog_entry(
 	git_buf_rtrim(buf);
 
 	if (msg) {
-		size_t i;
-
 		git_buf_putc(buf, '\t');
 		git_buf_puts(buf, msg);
-
-		for (i = 0; i < buf->size - 2; i++)
-			if (buf->ptr[i] == '\n')
-				buf->ptr[i] = ' ';
-		git_buf_rtrim(buf);
 	}
 
 	git_buf_putc(buf, '\n');
@@ -1869,7 +1743,7 @@ static int lock_reflog(git_filebuf *file, refdb_fs_backend *backend, const char
 	repo = backend->repo;
 
 	if (!git_path_isvalid(backend->repo, refname, 0, GIT_PATH_REJECT_FILESYSTEM_DEFAULTS)) {
-		git_error_set(GIT_ERROR_INVALID, "invalid reference name '%s'", refname);
+		giterr_set(GITERR_INVALID, "invalid reference name '%s'", refname);
 		return GIT_EINVALIDSPEC;
 	}
 
@@ -1877,7 +1751,7 @@ static int lock_reflog(git_filebuf *file, refdb_fs_backend *backend, const char
 		return -1;
 
 	if (!git_path_isfile(git_buf_cstr(&log_path))) {
-		git_error_set(GIT_ERROR_INVALID,
+		giterr_set(GITERR_INVALID,
 			"log file for reference '%s' doesn't exist", refname);
 		error = -1;
 		goto cleanup;
@@ -1886,7 +1760,7 @@ static int lock_reflog(git_filebuf *file, refdb_fs_backend *backend, const char
 	error = git_filebuf_open(file, git_buf_cstr(&log_path), 0, GIT_REFLOG_FILE_MODE);
 
 cleanup:
-	git_buf_dispose(&log_path);
+	git_buf_free(&log_path);
 
 	return error;
 }
@@ -1902,7 +1776,7 @@ static int refdb_reflog_fs__write(git_refdb_backend *_backend, git_reflog *reflo
 
 	assert(_backend && reflog);
 
-	backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
+	backend = (refdb_fs_backend *) _backend;
 
 	if ((error = lock_reflog(&fbuf, backend, reflog->ref_name)) < 0)
 		return -1;
@@ -1922,7 +1796,7 @@ cleanup:
 	git_filebuf_cleanup(&fbuf);
 
 success:
-	git_buf_dispose(&log);
+	git_buf_free(&log);
 
 	return error;
 }
@@ -1935,7 +1809,7 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co
 	git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT;
 	git_repository *repo = backend->repo;
 
-	is_symbolic = ref->type == GIT_REFERENCE_SYMBOLIC;
+	is_symbolic = ref->type == GIT_REF_SYMBOLIC;
 
 	/* "normal" symbolic updates do not write */
 	if (is_symbolic &&
@@ -1943,7 +1817,7 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co
 	    !(old && new))
 		return 0;
 
-	/* From here on is_symbolic also means that it's HEAD */
+	/* From here on is_symoblic also means that it's HEAD */
 
 	if (old) {
 		git_oid_cpy(&old_id, old);
@@ -1966,7 +1840,7 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co
 			if (error == GIT_ENOTFOUND)
 				return 0;
 
-			git_error_clear();
+			giterr_clear();
 		}
 	}
 
@@ -1989,7 +1863,7 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co
 			if (error == GIT_ENOTFOUND)
 				error = 0;
 		} else if (git_path_isdir(git_buf_cstr(&path))) {
-			git_error_set(GIT_ERROR_REFERENCE, "cannot create reflog at '%s', there are reflogs beneath that folder",
+			giterr_set(GITERR_REFERENCE, "cannot create reflog at '%s', there are reflogs beneath that folder",
 				ref->name);
 			error = GIT_EDIRECTORY;
 		}
@@ -2006,8 +1880,8 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co
 	error = git_futils_writebuffer(&buf, git_buf_cstr(&path), open_flags, GIT_REFLOG_FILE_MODE);
 
 cleanup:
-	git_buf_dispose(&buf);
-	git_buf_dispose(&path);
+	git_buf_free(&buf);
+	git_buf_free(&path);
 
 	return error;
 }
@@ -2024,11 +1898,11 @@ static int refdb_reflog_fs__rename(git_refdb_backend *_backend, const char *old_
 
 	assert(_backend && old_name && new_name);
 
-	backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
+	backend = (refdb_fs_backend *) _backend;
 	repo = backend->repo;
 
 	if ((error = git_reference__normalize_name(
-		&normalized, new_name, GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL)) < 0)
+		&normalized, new_name, GIT_REF_FORMAT_ALLOW_ONELEVEL)) < 0)
 			return error;
 
 	if (git_buf_joinpath(&temp_path, repo->gitdir, GIT_REFLOG_DIR) < 0)
@@ -2063,12 +1937,12 @@ static int refdb_reflog_fs__rename(git_refdb_backend *_backend, const char *old_
 	p_close(fd);
 
 	if (p_rename(git_buf_cstr(&old_path), git_buf_cstr(&temp_path)) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to rename reflog for %s", new_name);
+		giterr_set(GITERR_OS, "failed to rename reflog for %s", new_name);
 		error = -1;
 		goto cleanup;
 	}
 
-	if (git_path_isdir(git_buf_cstr(&new_path)) &&
+	if (git_path_isdir(git_buf_cstr(&new_path)) && 
 		(git_futils_rmdir_r(git_buf_cstr(&new_path), NULL, GIT_RMDIR_SKIP_NONEMPTY) < 0)) {
 		error = -1;
 		goto cleanup;
@@ -2080,42 +1954,41 @@ static int refdb_reflog_fs__rename(git_refdb_backend *_backend, const char *old_
 	}
 
 	if (p_rename(git_buf_cstr(&temp_path), git_buf_cstr(&new_path)) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to rename reflog for %s", new_name);
+		giterr_set(GITERR_OS, "failed to rename reflog for %s", new_name);
 		error = -1;
 	}
 
 cleanup:
-	git_buf_dispose(&temp_path);
-	git_buf_dispose(&old_path);
-	git_buf_dispose(&new_path);
-	git_buf_dispose(&normalized);
+	git_buf_free(&temp_path);
+	git_buf_free(&old_path);
+	git_buf_free(&new_path);
+	git_buf_free(&normalized);
 
 	return error;
 }
 
 static int refdb_reflog_fs__delete(git_refdb_backend *_backend, const char *name)
 {
-	refdb_fs_backend *backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent);
-	git_buf path = GIT_BUF_INIT;
 	int error;
+	git_buf path = GIT_BUF_INIT;
 
-	assert(_backend && name);
+	git_repository *repo;
+	refdb_fs_backend *backend;
 
-	if ((error = retrieve_reflog_path(&path, backend->repo, name)) < 0)
-		goto out;
+	assert(_backend && name);
 
-	if (!git_path_exists(path.ptr))
-		goto out;
+	backend = (refdb_fs_backend *) _backend;
+	repo = backend->repo;
 
-	if ((error = p_unlink(path.ptr)) < 0)
-		goto out;
+	error = retrieve_reflog_path(&path, repo, name);
 
-	refdb_fs_backend__prune_refs(backend, name, GIT_REFLOG_DIR);
+	if (!error && git_path_exists(path.ptr))
+		error = p_unlink(path.ptr);
 
-out:
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	return error;
+
 }
 
 int git_refdb_backend_fs(
@@ -2127,7 +2000,7 @@ int git_refdb_backend_fs(
 	refdb_fs_backend *backend;
 
 	backend = git__calloc(1, sizeof(refdb_fs_backend));
-	GIT_ERROR_CHECK_ALLOC(backend);
+	GITERR_CHECK_ALLOC(backend);
 
 	backend->repo = repository;
 
@@ -2151,17 +2024,17 @@ int git_refdb_backend_fs(
 			NULL, NULL, packref_cmp, git_buf_cstr(&gitpath)) < 0)
 		goto fail;
 
-	git_buf_dispose(&gitpath);
+	git_buf_free(&gitpath);
 
-	if (!git_repository__configmap_lookup(&t, backend->repo, GIT_CONFIGMAP_IGNORECASE) && t) {
+	if (!git_repository__cvar(&t, backend->repo, GIT_CVAR_IGNORECASE) && t) {
 		backend->iterator_flags |= GIT_ITERATOR_IGNORE_CASE;
 		backend->direach_flags  |= GIT_PATH_DIR_IGNORE_CASE;
 	}
-	if (!git_repository__configmap_lookup(&t, backend->repo, GIT_CONFIGMAP_PRECOMPOSE) && t) {
+	if (!git_repository__cvar(&t, backend->repo, GIT_CVAR_PRECOMPOSE) && t) {
 		backend->iterator_flags |= GIT_ITERATOR_PRECOMPOSE_UNICODE;
 		backend->direach_flags  |= GIT_PATH_DIR_PRECOMPOSE_UNICODE;
 	}
-	if ((!git_repository__configmap_lookup(&t, backend->repo, GIT_CONFIGMAP_FSYNCOBJECTFILES) && t) ||
+	if ((!git_repository__cvar(&t, backend->repo, GIT_CVAR_FSYNCOBJECTFILES) && t) ||
 		git_repository__fsync_gitdir)
 		backend->fsync = 1;
 	backend->iterator_flags |= GIT_ITERATOR_DESCEND_SYMLINKS;
@@ -2187,7 +2060,7 @@ int git_refdb_backend_fs(
 	return 0;
 
 fail:
-	git_buf_dispose(&gitpath);
+	git_buf_free(&gitpath);
 	git__free(backend->gitpath);
 	git__free(backend->commonpath);
 	git__free(backend);