rugged 1.7.2 → 1.9.0

data/vendor/libgit2/src/libgit2/pack.c

@@ -13,6 +13,7 @@
 #include "odb.h"
 #include "oid.h"
 #include "oidarray.h"
+#include "hashmap_oid.h"
 
 /* Option to bypass checking existence of '.keep' files */
 bool git_disable_pack_keep_file_checks = false;
@@ -41,6 +42,12 @@ static int pack_entry_find_offset(
 		const git_oid *short_oid,
 		size_t len);
 
+#define off64_hash(key) (uint32_t)((key)>>33^(key)^(key)<<11)
+#define off64_equal(a, b) ((a) == (b))
+
+GIT_HASHMAP_FUNCTIONS(git_pack_offsetmap, GIT_HASHMAP_INLINE, off64_t, git_pack_cache_entry *, off64_hash, off64_equal);
+GIT_HASHMAP_OID_FUNCTIONS(git_pack_oidmap, , struct git_pack_entry *);
+
 static int packfile_error(const char *message)
 {
 	git_error_set(GIT_ERROR_ODB, "invalid pack file - %s", message);
@@ -75,31 +82,21 @@ static void free_cache_object(void *o)
 
 static void cache_free(git_pack_cache *cache)
 {
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 	git_pack_cache_entry *entry;
 
-	if (cache->entries) {
-		git_offmap_foreach_value(cache->entries, entry, {
-			free_cache_object(entry);
-		});
+	while (git_pack_offsetmap_iterate(&iter, NULL, &entry, &cache->entries) == 0)
+		free_cache_object(entry);
 
-		git_offmap_free(cache->entries);
-		cache->entries = NULL;
-	}
+	git_pack_offsetmap_dispose(&cache->entries);
 }
 
 static int cache_init(git_pack_cache *cache)
 {
-	if (git_offmap_new(&cache->entries) < 0)
-		return -1;
-
 	cache->memory_limit = GIT_PACK_CACHE_MEMORY_LIMIT;
 
 	if (git_mutex_init(&cache->lock)) {
 		git_error_set(GIT_ERROR_OS, "failed to initialize pack cache mutex");
-
-		git__free(cache->entries);
-		cache->entries = NULL;
-
 		return -1;
 	}
 
@@ -108,15 +105,16 @@ static int cache_init(git_pack_cache *cache)
 
 static git_pack_cache_entry *cache_get(git_pack_cache *cache, off64_t offset)
 {
-	git_pack_cache_entry *entry;
+	git_pack_cache_entry *entry = NULL;
 
 	if (git_mutex_lock(&cache->lock) < 0)
 		return NULL;
 
-	if ((entry = git_offmap_get(cache->entries, offset)) != NULL) {
+	if (git_pack_offsetmap_get(&entry, &cache->entries, offset) == 0) {
 		git_atomic32_inc(&entry->refcount);
 		entry->last_usage = cache->use_ctr++;
 	}
+
 	git_mutex_unlock(&cache->lock);
 
 	return entry;
@@ -125,16 +123,17 @@ static git_pack_cache_entry *cache_get(git_pack_cache *cache, off64_t offset)
 /* Run with the cache lock held */
 static void free_lowest_entry(git_pack_cache *cache)
 {
-	off64_t offset;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 	git_pack_cache_entry *entry;
+	off64_t offset;
 
-	git_offmap_foreach(cache->entries, offset, entry, {
+	while (git_pack_offsetmap_iterate(&iter, &offset, &entry, &cache->entries) == 0) {
 		if (entry && git_atomic32_get(&entry->refcount) == 0) {
 			cache->memory_used -= entry->raw.len;
-			git_offmap_delete(cache->entries, offset);
+			git_pack_offsetmap_remove(&cache->entries, offset);
 			free_cache_object(entry);
 		}
-	});
+	}
 }
 
 static int cache_add(
@@ -157,12 +156,12 @@ static int cache_add(
 			return -1;
 		}
 		/* Add it to the cache if nobody else has */
-		exists = git_offmap_exists(cache->entries, offset);
+		exists = git_pack_offsetmap_contains(&cache->entries, offset);
 		if (!exists) {
 			while (cache->memory_used + base->len > cache->memory_limit)
 				free_lowest_entry(cache);
 
-			git_offmap_set(cache->entries, offset, entry);
+			git_pack_offsetmap_put(&cache->entries, offset, entry);
 			cache->memory_used += entry->raw.len;
 
 			*cached_out = entry;
@@ -1009,7 +1008,7 @@ int get_delta_base(
 		if (p->has_cache) {
 			struct git_pack_entry *entry;
 
-			if ((entry = git_oidmap_get(p->idx_cache, &base_oid)) != NULL) {
+			if (git_pack_oidmap_get(&entry, &p->idx_cache, &base_oid) == 0) {
 				if (entry->offset == 0)
 					return packfile_error("delta offset is zero");
 
@@ -1351,7 +1350,7 @@ int git_pack_foreach_entry(
 				git_vector_insert(&oids, (void*)&current[4]);
 		}
 
-		git_vector_free(&offsets);
+		git_vector_dispose(&offsets);
 		p->ids = (unsigned char **)git_vector_detach(NULL, NULL, &oids);
 	}
 
@@ -1499,6 +1498,7 @@ static int pack_entry_find_offset(
 	size_t len)
 {
 	const uint32_t *level1_ofs;
+	size_t ofs_delta = 0;
 	const unsigned char *index;
 	unsigned hi, lo, stride;
 	int pos, found = 0;
@@ -1524,9 +1524,15 @@ static int pack_entry_find_offset(
 
 	if (p->index_version > 1) {
 		level1_ofs += 2;
+		ofs_delta = 2;
 		index += 8;
 	}
 
+	if ((size_t)short_oid->id[0] + ofs_delta >= p->index_map.len) {
+		git_error_set(GIT_ERROR_INTERNAL, "internal error: p->short_oid->[0] out of bounds");
+		goto cleanup;
+	}
+
 	index += 4 * 256;
 	hi = ntohl(level1_ofs[(int)short_oid->id[0]]);
 	lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(level1_ofs[(int)short_oid->id[0] - 1]));

data/vendor/libgit2/src/libgit2/pack.h

@@ -16,10 +16,9 @@
 #include "map.h"
 #include "mwindow.h"
 #include "odb.h"
-#include "offmap.h"
-#include "oidmap.h"
 #include "zstream.h"
 #include "oid.h"
+#include "hashmap_oid.h"
 
 /**
  * Function type for callbacks from git_pack_foreach_entry_offset.
@@ -83,12 +82,23 @@ typedef git_array_t(struct pack_chain_elem) git_dependency_chain;
 #define GIT_PACK_CACHE_MEMORY_LIMIT 16 * 1024 * 1024
 #define GIT_PACK_CACHE_SIZE_LIMIT 1024 * 1024 /* don't bother caching anything over 1MB */
 
+struct git_pack_entry {
+	off64_t offset;
+	git_oid id;
+	struct git_pack_file *p;
+};
+
+GIT_HASHMAP_STRUCT(git_pack_offsetmap, off64_t, git_pack_cache_entry *);
+
+GIT_HASHMAP_OID_STRUCT(git_pack_oidmap, struct git_pack_entry *);
+GIT_HASHMAP_OID_PROTOTYPES(git_pack_oidmap, struct git_pack_entry *);
+
 typedef struct {
 	size_t memory_used;
 	size_t memory_limit;
 	size_t use_ctr;
 	git_mutex lock;
-	git_offmap *entries;
+	git_pack_offsetmap entries;
 } git_pack_cache;
 
 struct git_pack_file {
@@ -110,7 +120,8 @@ struct git_pack_file {
 
 	int index_version;
 	git_time_t mtime;
-	git_oidmap *idx_cache;
+
+	git_pack_oidmap idx_cache;
 	unsigned char **ids;
 
 	git_pack_cache bases; /* delta base cache */
@@ -139,12 +150,6 @@ int git_pack__lookup_id(
 	const unsigned char *id_prefix,
 	const git_oid_t oid_type);
 
-struct git_pack_entry {
-	off64_t offset;
-	git_oid id;
-	struct git_pack_file *p;
-};
-
 typedef struct git_packfile_stream {
 	off64_t curpos;
 	int done;

data/vendor/libgit2/src/libgit2/patch_parse.c

@@ -562,9 +562,9 @@ fail:
 
 static int eof_for_origin(int origin) {
 	if (origin == GIT_DIFF_LINE_ADDITION)
-		return GIT_DIFF_LINE_ADD_EOFNL;
-	if (origin == GIT_DIFF_LINE_DELETION)
 		return GIT_DIFF_LINE_DEL_EOFNL;
+	if (origin == GIT_DIFF_LINE_DELETION)
+		return GIT_DIFF_LINE_ADD_EOFNL;
 	return GIT_DIFF_LINE_CONTEXT_EOFNL;
 }
 

data/vendor/libgit2/src/libgit2/path.c

@@ -202,7 +202,7 @@ GIT_INLINE(size_t) common_prefix_icase(const char *str, size_t len, const char *
 {
 	size_t count = 0;
 
-	while (len > 0 && tolower(*str) == tolower(*prefix)) {
+	while (len > 0 && git__tolower(*str) == git__tolower(*prefix)) {
 		count++;
 		str++;
 		prefix++;

data/vendor/libgit2/src/libgit2/pathspec.c

@@ -105,7 +105,7 @@ int git_pathspec__vinit(
 /* free data from the pathspec vector */
 void git_pathspec__vfree(git_vector *vspec)
 {
-	git_vector_free_deep(vspec);
+	git_vector_dispose_deep(vspec);
 }
 
 struct pathspec_match_context {

data/vendor/libgit2/src/libgit2/push.c

@@ -56,14 +56,22 @@ int git_push_new(git_push **out, git_remote *remote, const git_push_options *opt
 	}
 
 	if (git_vector_init(&p->status, 0, push_status_ref_cmp) < 0) {
-		git_vector_free(&p->specs);
+		git_vector_dispose(&p->specs);
 		git__free(p);
 		return -1;
 	}
 
 	if (git_vector_init(&p->updates, 0, NULL) < 0) {
-		git_vector_free(&p->status);
-		git_vector_free(&p->specs);
+		git_vector_dispose(&p->status);
+		git_vector_dispose(&p->specs);
+		git__free(p);
+		return -1;
+	}
+
+	if (git_vector_init(&p->remote_push_options, 0, git__strcmp_cb) < 0) {
+		git_vector_dispose(&p->status);
+		git_vector_dispose(&p->specs);
+		git_vector_dispose(&p->updates);
 		git__free(p);
 		return -1;
 	}
@@ -213,12 +221,25 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks)
 			fire_callback = 0;
 		}
 
-		if (fire_callback && callbacks && callbacks->update_tips) {
-			error = callbacks->update_tips(git_str_cstr(&remote_ref_name),
-						&push_spec->roid, &push_spec->loid, callbacks->payload);
+		if (!fire_callback || !callbacks)
+			continue;
 
-			if (error < 0)
-				goto on_error;
+		if (callbacks->update_refs)
+			error = callbacks->update_refs(
+				git_str_cstr(&remote_ref_name),
+				&push_spec->roid, &push_spec->loid,
+				&push_spec->refspec, callbacks->payload);
+#ifndef GIT_DEPRECATE_HARD
+		else if (callbacks->update_tips)
+			error = callbacks->update_tips(
+				git_str_cstr(&remote_ref_name),
+				&push_spec->roid, &push_spec->loid,
+				callbacks->payload);
+#endif
+
+		if (error < 0) {
+			git_error_set_after_callback_function(error, "git_remote_push");
+			goto on_error;
 		}
 	}
 
@@ -275,6 +296,7 @@ static int queue_objects(git_push *push)
 
 	git_vector_foreach(&push->specs, i, spec) {
 		git_object_t type;
+		git_oid id;
 		size_t size;
 
 		if (git_oid_is_zero(&spec->loid))
@@ -296,20 +318,20 @@ static int queue_objects(git_push *push)
 			if ((error = enqueue_tag(&target, push, &spec->loid)) < 0)
 				goto on_error;
 
-			if (git_object_type(target) == GIT_OBJECT_COMMIT) {
-				if ((error = git_revwalk_push(rw, git_object_id(target))) < 0) {
-					git_object_free(target);
-					goto on_error;
-				}
-			} else {
-				if ((error = git_packbuilder_insert(
-					push->pb, git_object_id(target), NULL)) < 0) {
-					git_object_free(target);
-					goto on_error;
-				}
-			}
+			type = git_object_type(target);
+			git_oid_cpy(&id, git_object_id(target));
+
 			git_object_free(target);
-		} else if ((error = git_revwalk_push(rw, &spec->loid)) < 0)
+		} else {
+			git_oid_cpy(&id, &spec->loid);
+		}
+
+		if (type == GIT_OBJECT_COMMIT)
+			error = git_revwalk_push(rw, &id);
+		else
+			error = git_packbuilder_insert(push->pb, &id, NULL);
+
+		if (error < 0)
 			goto on_error;
 
 		if (!spec->refspec.force) {
@@ -444,10 +466,21 @@ static int do_push(git_push *push)
 	if ((error = calculate_work(push)) < 0)
 		goto on_error;
 
-	if (callbacks && callbacks->push_negotiation &&
-	    (error = callbacks->push_negotiation((const git_push_update **) push->updates.contents,
-					  push->updates.length, callbacks->payload)) < 0)
-	    goto on_error;
+	if (callbacks && callbacks->push_negotiation) {
+		git_error_clear();
+
+		error = callbacks->push_negotiation(
+			(const git_push_update **) push->updates.contents,
+			push->updates.length, callbacks->payload);
+
+		if (error < 0) {
+			git_error_set_after_callback_function(error,
+				"push_negotiation");
+			goto on_error;
+		}
+
+		error = 0;
+	}
 
 	if ((error = queue_objects(push)) < 0 ||
 	    (error = transport->push(transport, push)) < 0)
@@ -479,12 +512,24 @@ static int filter_refs(git_remote *remote)
 int git_push_finish(git_push *push)
 {
 	int error;
+	unsigned int remote_caps;
 
 	if (!git_remote_connected(push->remote)) {
 		git_error_set(GIT_ERROR_NET, "remote is disconnected");
 		return -1;
 	}
 
+	if ((error = git_remote_capabilities(&remote_caps, push->remote)) < 0) {
+		git_error_set(GIT_ERROR_INVALID, "remote capabilities not available");
+		return -1;
+	}
+
+	if (git_vector_length(&push->remote_push_options) > 0 &&
+	    !(remote_caps & GIT_REMOTE_CAPABILITY_PUSH_OPTIONS)) {
+		git_error_set(GIT_ERROR_INVALID, "push-options not supported by remote");
+		return -1;
+	}
+
 	if ((error = filter_refs(push->remote)) < 0 ||
 	    (error = do_push(push)) < 0)
 		return error;
@@ -528,6 +573,7 @@ void git_push_free(git_push *push)
 	push_spec *spec;
 	push_status *status;
 	git_push_update *update;
+	char *option;
 	unsigned int i;
 
 	if (push == NULL)
@@ -536,19 +582,24 @@ void git_push_free(git_push *push)
 	git_vector_foreach(&push->specs, i, spec) {
 		free_refspec(spec);
 	}
-	git_vector_free(&push->specs);
+	git_vector_dispose(&push->specs);
 
 	git_vector_foreach(&push->status, i, status) {
 		git_push_status_free(status);
 	}
-	git_vector_free(&push->status);
+	git_vector_dispose(&push->status);
 
 	git_vector_foreach(&push->updates, i, update) {
 		git__free(update->src_refname);
 		git__free(update->dst_refname);
 		git__free(update);
 	}
-	git_vector_free(&push->updates);
+	git_vector_dispose(&push->updates);
+
+	git_vector_foreach(&push->remote_push_options, i, option) {
+		git__free(option);
+	}
+	git_vector_dispose(&push->remote_push_options);
 
 	git__free(push);
 }

data/vendor/libgit2/src/libgit2/push.h

@@ -34,6 +34,7 @@ struct git_push {
 	git_vector specs;
 	git_vector updates;
 	bool report_status;
+	git_vector remote_push_options;
 
 	/* report-status */
 	bool unpack_ok;

data/vendor/libgit2/src/libgit2/refdb_fs.c

@@ -26,7 +26,6 @@
 #include <git2/branch.h>
 #include <git2/sys/refdb_backend.h>
 #include <git2/sys/refs.h>
-#include <git2/sys/reflog.h>
 
 #define DEFAULT_NESTING_LEVEL	5
 #define MAX_NESTING_LEVEL		10
@@ -62,8 +61,8 @@ typedef struct refdb_fs_backend {
 
 	git_oid_t oid_type;
 
-	int fsync : 1,
-	    sorted : 1;
+	unsigned int fsync : 1,
+	             sorted : 1;
 	int peeling_mode;
 	git_iterator_flag_t iterator_flags;
 	uint32_t direach_flags;
@@ -410,7 +409,9 @@ static const char *loose_parse_symbolic(git_str *file_content)
 static bool is_per_worktree_ref(const char *ref_name)
 {
 	return git__prefixcmp(ref_name, "refs/") != 0 ||
-	    git__prefixcmp(ref_name, "refs/bisect/") == 0;
+	       git__prefixcmp(ref_name, "refs/bisect/") == 0 ||
+	       git__prefixcmp(ref_name, "refs/worktree/") == 0 ||
+	       git__prefixcmp(ref_name, "refs/rewritten/") == 0;
 }
 
 static int loose_lookup(
@@ -799,89 +800,155 @@ static void refdb_fs_backend__iterator_free(git_reference_iterator *_iter)
 {
 	refdb_fs_iter *iter = GIT_CONTAINER_OF(_iter, refdb_fs_iter, parent);
 
-	git_vector_free(&iter->loose);
+	git_vector_dispose(&iter->loose);
 	git_pool_clear(&iter->pool);
 	git_sortedcache_free(iter->cache);
 	git__free(iter);
 }
 
-static int iter_load_loose_paths(
-	refdb_fs_backend *backend,
-	refdb_fs_iter *iter)
+struct iter_load_context {
+	refdb_fs_backend *backend;
+	refdb_fs_iter *iter;
+
+	/*
+	 * If we have a glob with a prefix (eg `refs/heads/ *`) then we can
+	 * optimize our prefix to avoid walking refs that we know won't
+	 * match. This is that prefix.
+	 */
+	const char *ref_prefix;
+	size_t ref_prefix_len;
+
+	/* Temporary variables to avoid unnecessary allocations */
+	git_str ref_name;
+	git_str path;
+};
+
+static void iter_load_optimize_prefix(struct iter_load_context *ctx)
 {
-	int error = 0;
-	git_str path = GIT_STR_INIT;
-	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);
+	const char *pos, *last_sep = NULL;
 
-	if (!backend->commonpath) /* do nothing if no commonpath for loose refs */
-		return 0;
+	if (!ctx->iter->glob)
+		return;
 
-	fsit_opts.flags = backend->iterator_flags;
-	fsit_opts.oid_type = backend->oid_type;
-
-	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;
-			}
+	for (pos = ctx->iter->glob; *pos; pos++) {
+		switch (*pos) {
+		case '?':
+		case '*':
+		case '[':
+		case '\\':
 			break;
+		case '/':
+			last_sep = pos;
+			/* FALLTHROUGH */
+		default:
+			continue;
 		}
-		if (last_sep) {
-			ref_prefix = iter->glob;
-			ref_prefix_len = (last_sep - ref_prefix) + 1;
-		}
+		break;
 	}
 
-	if ((error = git_str_puts(&path, backend->commonpath)) < 0 ||
-		(error = git_str_put(&path, ref_prefix, ref_prefix_len)) < 0) {
-		git_str_dispose(&path);
-		return error;
+	if (last_sep) {
+		ctx->ref_prefix = ctx->iter->glob;
+		ctx->ref_prefix_len = (last_sep - ctx->ref_prefix) + 1;
 	}
+}
+
+static int iter_load_paths(
+	struct iter_load_context *ctx,
+	const char *root_path,
+	bool worktree)
+{
+	git_iterator *fsit = NULL;
+	git_iterator_options fsit_opts = GIT_ITERATOR_OPTIONS_INIT;
+	const git_index_entry *entry;
+	int error = 0;
+
+	fsit_opts.flags = ctx->backend->iterator_flags;
+
+	git_str_clear(&ctx->path);
+	git_str_puts(&ctx->path, root_path);
+	git_str_put(&ctx->path, ctx->ref_prefix, ctx->ref_prefix_len);
+
+	fsit_opts.flags = ctx->backend->iterator_flags;
+	fsit_opts.oid_type = ctx->backend->oid_type;
+
+	if ((error = git_iterator_for_filesystem(&fsit, ctx->path.ptr, &fsit_opts)) < 0) {
+		/*
+		 * Subdirectories - either glob provided or per-worktree refs - need
+		 * not exist.
+		 */
+		if ((worktree || ctx->iter->glob) && error == GIT_ENOTFOUND)
+			error = 0;
 
-	if ((error = git_iterator_for_filesystem(&fsit, path.ptr, &fsit_opts)) < 0) {
-		git_str_dispose(&path);
-		return (iter->glob && error == GIT_ENOTFOUND)? 0 : error;
+		goto done;
 	}
 
-	error = git_str_sets(&path, ref_prefix);
+	git_str_clear(&ctx->ref_name);
+	git_str_put(&ctx->ref_name, ctx->ref_prefix, ctx->ref_prefix_len);
 
-	while (!error && !git_iterator_advance(&entry, fsit)) {
-		const char *ref_name;
+	while (git_iterator_advance(&entry, fsit) == 0) {
 		char *ref_dup;
 
-		git_str_truncate(&path, ref_prefix_len);
-		git_str_puts(&path, entry->path);
-		ref_name = git_str_cstr(&path);
+		git_str_truncate(&ctx->ref_name, ctx->ref_prefix_len);
+		git_str_puts(&ctx->ref_name, entry->path);
 
-		if (git__suffixcmp(ref_name, ".lock") == 0 ||
-			(iter->glob && wildmatch(iter->glob, ref_name, 0) != 0))
+		if (worktree) {
+			if (!is_per_worktree_ref(ctx->ref_name.ptr))
+				continue;
+		} else {
+			if (git_repository_is_worktree(ctx->backend->repo) &&
+			    is_per_worktree_ref(ctx->ref_name.ptr))
+				continue;
+		}
+
+		if (git__suffixcmp(ctx->ref_name.ptr, ".lock") == 0)
 			continue;
 
-		ref_dup = git_pool_strdup(&iter->pool, ref_name);
-		if (!ref_dup)
-			error = -1;
-		else
-			error = git_vector_insert(&iter->loose, ref_dup);
+		if (ctx->iter->glob && wildmatch(ctx->iter->glob, ctx->ref_name.ptr, 0))
+			continue;
+
+		ref_dup = git_pool_strdup(&ctx->iter->pool, ctx->ref_name.ptr);
+		GIT_ERROR_CHECK_ALLOC(ref_dup);
+
+		if ((error = git_vector_insert(&ctx->iter->loose, ref_dup)) < 0)
+			goto done;
 	}
 
+done:
 	git_iterator_free(fsit);
-	git_str_dispose(&path);
+	return error;
+}
 
+#define iter_load_context_init(b, i) { b, i, GIT_REFS_DIR, CONST_STRLEN(GIT_REFS_DIR) }
+#define iter_load_context_dispose(ctx) do {  \
+	git_str_dispose(&((ctx)->path));     \
+	git_str_dispose(&((ctx)->ref_name)); \
+} while(0)
+
+static int iter_load_loose_paths(
+	refdb_fs_backend *backend,
+	refdb_fs_iter *iter)
+{
+	struct iter_load_context ctx = iter_load_context_init(backend, iter);
+
+	int error = 0;
+
+	if (!backend->commonpath)
+		return 0;
+
+	iter_load_optimize_prefix(&ctx);
+
+	if ((error = iter_load_paths(&ctx,
+			backend->commonpath, false)) < 0)
+		goto done;
+
+	if (git_repository_is_worktree(backend->repo)) {
+		if ((error = iter_load_paths(&ctx,
+				backend->gitpath, true)) < 0)
+			goto done;
+	}
+
+done:
+	iter_load_context_dispose(&ctx);
 	return error;
 }
 

data/vendor/libgit2/src/libgit2/reflog.c

@@ -13,7 +13,6 @@
 #include "refdb.h"
 
 #include "git2/sys/refdb_backend.h"
-#include "git2/sys/reflog.h"
 
 void git_reflog_entry__free(git_reflog_entry *entry)
 {
@@ -40,7 +39,7 @@ void git_reflog_free(git_reflog *reflog)
 		git_reflog_entry__free(entry);
 	}
 
-	git_vector_free(&reflog->entries);
+	git_vector_dispose(&reflog->entries);
 	git__free(reflog->ref_name);
 	git__free(reflog);
 }