rugged 1.7.2 → 1.9.0

data/vendor/libgit2/src/libgit2/odb_mempack.c

@@ -12,7 +12,6 @@
 #include "hash.h"
 #include "odb.h"
 #include "array.h"
-#include "oidmap.h"
 #include "pack-objects.h"
 
 #include "git2/odb_backend.h"
@@ -29,9 +28,11 @@ struct memobject {
 	char data[GIT_FLEX_ARRAY];
 };
 
+GIT_HASHMAP_OID_SETUP(git_odb_mempack_oidmap, struct memobject *);
+
 struct memory_packer_db {
 	git_odb_backend parent;
-	git_oidmap *objects;
+	git_odb_mempack_oidmap objects;
 	git_array_t(struct memobject *) commits;
 };
 
@@ -41,7 +42,7 @@ static int impl__write(git_odb_backend *_backend, const git_oid *oid, const void
 	struct memobject *obj = NULL;
 	size_t alloc_len;
 
-	if (git_oidmap_exists(db->objects, oid))
+	if (git_odb_mempack_oidmap_contains(&db->objects, oid))
 		return 0;
 
 	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, sizeof(struct memobject), len);
@@ -53,7 +54,7 @@ static int impl__write(git_odb_backend *_backend, const git_oid *oid, const void
 	obj->len = len;
 	obj->type = type;
 
-	if (git_oidmap_set(db->objects, &obj->oid, obj) < 0)
+	if (git_odb_mempack_oidmap_put(&db->objects, &obj->oid, obj) < 0)
 		return -1;
 
 	if (type == GIT_OBJECT_COMMIT) {
@@ -69,16 +70,17 @@ static int impl__exists(git_odb_backend *backend, const git_oid *oid)
 {
 	struct memory_packer_db *db = (struct memory_packer_db *)backend;
 
-	return git_oidmap_exists(db->objects, oid);
+	return git_odb_mempack_oidmap_contains(&db->objects, oid);
 }
 
 static int impl__read(void **buffer_p, size_t *len_p, git_object_t *type_p, git_odb_backend *backend, const git_oid *oid)
 {
 	struct memory_packer_db *db = (struct memory_packer_db *)backend;
 	struct memobject *obj;
+	int error;
 
-	if ((obj = git_oidmap_get(db->objects, oid)) == NULL)
-		return GIT_ENOTFOUND;
+	if ((error = git_odb_mempack_oidmap_get(&obj, &db->objects, oid)) != 0)
+		return error;
 
 	*len_p = obj->len;
 	*type_p = obj->type;
@@ -93,9 +95,10 @@ static int impl__read_header(size_t *len_p, git_object_t *type_p, git_odb_backen
 {
 	struct memory_packer_db *db = (struct memory_packer_db *)backend;
 	struct memobject *obj;
+	int error;
 
-	if ((obj = git_oidmap_get(db->objects, oid)) == NULL)
-		return GIT_ENOTFOUND;
+	if ((error = git_odb_mempack_oidmap_get(&obj, &db->objects, oid)) != 0)
+		return error;
 
 	*len_p = obj->len;
 	*type_p = obj->type;
@@ -132,6 +135,29 @@ cleanup:
 	return err;
 }
 
+int git_mempack_write_thin_pack(git_odb_backend *backend, git_packbuilder *pb)
+{
+	struct memory_packer_db *db = (struct memory_packer_db *)backend;
+	const git_oid *oid;
+	git_hashmap_iter_t iter = GIT_HASHMAP_INIT;
+	int err;
+
+	while (true) {
+		err = git_odb_mempack_oidmap_iterate(&iter, &oid, NULL, &db->objects);
+
+		if (err == GIT_ITEROVER)
+			break;
+		else if (err != 0)
+			return err;
+
+		err = git_packbuilder_insert(pb, oid, NULL);
+		if (err != 0)
+			return err;
+	}
+
+	return 0;
+}
+
 int git_mempack_dump(
 	git_buf *pack,
 	git_repository *repo,
@@ -144,14 +170,13 @@ int git_mempack_reset(git_odb_backend *_backend)
 {
 	struct memory_packer_db *db = (struct memory_packer_db *)_backend;
 	struct memobject *object = NULL;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 
-	git_oidmap_foreach_value(db->objects, object, {
+	while (git_odb_mempack_oidmap_iterate(&iter, NULL, &object, &db->objects) == 0)
 		git__free(object);
-	});
 
 	git_array_clear(db->commits);
-
-	git_oidmap_clear(db->objects);
+	git_odb_mempack_oidmap_clear(&db->objects);
 
 	return 0;
 }
@@ -161,7 +186,7 @@ static void impl__free(git_odb_backend *_backend)
 	struct memory_packer_db *db = (struct memory_packer_db *)_backend;
 
 	git_mempack_reset(_backend);
-	git_oidmap_free(db->objects);
+	git_odb_mempack_oidmap_dispose(&db->objects);
 	git__free(db);
 }
 
@@ -174,9 +199,6 @@ int git_mempack_new(git_odb_backend **out)
 	db = git__calloc(1, sizeof(struct memory_packer_db));
 	GIT_ERROR_CHECK_ALLOC(db);
 
-	if (git_oidmap_new(&db->objects) < 0)
-		return -1;
-
 	db->parent.version = GIT_ODB_BACKEND_VERSION;
 	db->parent.read = &impl__read;
 	db->parent.write = &impl__write;
@@ -187,3 +209,13 @@ int git_mempack_new(git_odb_backend **out)
 	*out = (git_odb_backend *)db;
 	return 0;
 }
+
+int git_mempack_object_count(size_t *out, git_odb_backend *_backend)
+{
+	struct memory_packer_db *db = (struct memory_packer_db *)_backend;
+
+	GIT_ASSERT_ARG(_backend);
+
+	*out = (size_t)git_odb_mempack_oidmap_size(&db->objects);
+	return 0;
+}

data/vendor/libgit2/src/libgit2/odb_pack.c

@@ -743,10 +743,10 @@ static int pack_backend__writepack(struct git_odb_writepack **out,
 
 #ifdef GIT_EXPERIMENTAL_SHA256
 	opts.odb = odb;
+	opts.oid_type = backend->opts.oid_type;
 
 	error = git_indexer_new(&writepack->indexer,
 		backend->pack_folder,
-		backend->opts.oid_type,
 		&opts);
 #else
 	error = git_indexer_new(&writepack->indexer,
@@ -796,13 +796,21 @@ static int pack_backend__writemidx(git_odb_backend *_backend)
 	size_t i;
 	int error = 0;
 
+#ifdef GIT_EXPERIMENTAL_SHA256
+	git_midx_writer_options midx_opts = GIT_MIDX_WRITER_OPTIONS_INIT;
+#endif
+
 	GIT_ASSERT_ARG(_backend);
 
 	backend = (struct pack_backend *)_backend;
 
+#ifdef GIT_EXPERIMENTAL_SHA256
+	midx_opts.oid_type = backend->opts.oid_type;
+#endif
+
 	error = git_midx_writer_new(&w, backend->pack_folder
 #ifdef GIT_EXPERIMENTAL_SHA256
-		, backend->opts.oid_type
+		, &midx_opts
 #endif
 		);
 
@@ -863,8 +871,8 @@ static void pack_backend__free(git_odb_backend *_backend)
 		git_mwindow_put_pack(p);
 
 	git_midx_free(backend->midx);
-	git_vector_free(&backend->midx_packs);
-	git_vector_free(&backend->packs);
+	git_vector_dispose(&backend->midx_packs);
+	git_vector_dispose(&backend->packs);
 	git__free(backend->pack_folder);
 	git__free(backend);
 }
@@ -883,7 +891,7 @@ static int pack_backend__alloc(
 	}
 
 	if (git_vector_init(&backend->packs, initial_size, packfile_sort__cb) < 0) {
-		git_vector_free(&backend->midx_packs);
+		git_vector_dispose(&backend->midx_packs);
 		git__free(backend);
 		return -1;
 	}

data/vendor/libgit2/src/libgit2/oid.c

@@ -9,7 +9,7 @@
 
 #include "git2/oid.h"
 #include "repository.h"
-#include "threadstate.h"
+#include "runtime.h"
 #include <string.h>
 #include <limits.h>
 
@@ -153,15 +153,42 @@ int git_oid_pathfmt(char *str, const git_oid *oid)
 	return 0;
 }
 
+static git_tlsdata_key thread_str_key;
+
+static void GIT_SYSTEM_CALL thread_str_free(void *s)
+{
+	char *str = (char *)s;
+	git__free(str);
+}
+
+static void thread_str_global_shutdown(void)
+{
+	char *str = git_tlsdata_get(thread_str_key);
+	git_tlsdata_set(thread_str_key, NULL);
+
+	git__free(str);
+	git_tlsdata_dispose(thread_str_key);
+}
+
+int git_oid_global_init(void)
+{
+	if (git_tlsdata_init(&thread_str_key, thread_str_free) != 0)
+		return -1;
+
+	return git_runtime_shutdown_register(thread_str_global_shutdown);
+}
+
 char *git_oid_tostr_s(const git_oid *oid)
 {
-	git_threadstate *threadstate = git_threadstate_get();
 	char *str;
 
-	if (!threadstate)
-		return NULL;
+	if ((str = git_tlsdata_get(thread_str_key)) == NULL) {
+		if ((str = git__malloc(GIT_OID_MAX_HEXSIZE + 1)) == NULL)
+			return NULL;
+
+		git_tlsdata_set(thread_str_key, str);
+	}
 
-	str = threadstate->oid_fmt;
 	git_oid_nfmt(str, git_oid_hexsize(git_oid_type(oid)) + 1, oid);
 	return str;
 }

data/vendor/libgit2/src/libgit2/oid.h

@@ -66,6 +66,15 @@ GIT_INLINE(size_t) git_oid_hexsize(git_oid_t type)
 	return 0;
 }
 
+GIT_INLINE(bool) git_oid_type_is_valid(git_oid_t type)
+{
+	return (type == GIT_OID_SHA1
+#ifdef GIT_EXPERIMENTAL_SHA256
+	     || type == GIT_OID_SHA256
+#endif
+	);
+}
+
 GIT_INLINE(const char *) git_oid_type_name(git_oid_t type)
 {
 	switch (type) {
@@ -270,4 +279,6 @@ int git_oid__fromstrn(
 
 int git_oid__fromraw(git_oid *out, const unsigned char *raw, git_oid_t type);
 
+int git_oid_global_init(void);
+
 #endif

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

@@ -64,6 +64,9 @@ struct walk_object {
 /* Size of the buffer to feed to zlib */
 #define COMPRESS_BUFLEN (1024 * 1024)
 
+GIT_HASHMAP_OID_FUNCTIONS(git_packbuilder_pobjectmap, GIT_HASHMAP_INLINE, git_pobject *);
+GIT_HASHMAP_OID_FUNCTIONS(git_packbuilder_walk_objectmap, GIT_HASHMAP_INLINE, struct walk_object *);
+
 static unsigned name_hash(const char *name)
 {
 	unsigned c, hash = 0;
@@ -139,9 +142,7 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 	hash_algorithm = git_oid_algorithm(pb->oid_type);
 	GIT_ASSERT(hash_algorithm);
 
-	if (git_oidmap_new(&pb->object_ix) < 0 ||
-	    git_oidmap_new(&pb->walk_objects) < 0 ||
-	    git_pool_init(&pb->object_pool, sizeof(struct walk_object)) < 0)
+	if (git_pool_init(&pb->object_pool, sizeof(struct walk_object)) < 0)
 		goto on_error;
 
 	pb->repo = repo;
@@ -192,10 +193,10 @@ static int rehash(git_packbuilder *pb)
 	git_pobject *po;
 	size_t i;
 
-	git_oidmap_clear(pb->object_ix);
+	git_packbuilder_pobjectmap_clear(&pb->object_ix);
 
 	for (i = 0, po = pb->object_list; i < pb->nr_objects; i++, po++) {
-		if (git_oidmap_set(pb->object_ix, &po->id, po) < 0)
+		if (git_packbuilder_pobjectmap_put(&pb->object_ix, &po->id, po) < 0)
 			return -1;
 	}
 
@@ -214,7 +215,7 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 
 	/* If the object already exists in the hash table, then we don't
 	 * have any work to do */
-	if (git_oidmap_exists(pb->object_ix, oid))
+	if (git_packbuilder_pobjectmap_contains(&pb->object_ix, oid))
 		return 0;
 
 	if (pb->nr_objects >= pb->nr_alloc) {
@@ -246,7 +247,7 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 	git_oid_cpy(&po->id, oid);
 	po->hash = name_hash(name);
 
-	if (git_oidmap_set(pb->object_ix, &po->id, po) < 0) {
+	if (git_packbuilder_pobjectmap_put(&pb->object_ix, &po->id, po) < 0) {
 		git_error_set_oom();
 		return -1;
 	}
@@ -515,7 +516,7 @@ static int cb_tag_foreach(const char *name, git_oid *oid, void *data)
 
 	GIT_UNUSED(name);
 
-	if ((po = git_oidmap_get(pb->object_ix, oid)) == NULL)
+	if (git_packbuilder_pobjectmap_get(&po, &pb->object_ix, oid) != 0)
 		return 0;
 
 	po->tagged = 1;
@@ -932,6 +933,9 @@ static int report_delta_progress(
 {
 	int ret;
 
+	if (pb->failure)
+		return pb->failure;
+
 	if (pb->progress_cb) {
 		uint64_t current_time = git_time_monotonic();
 		uint64_t elapsed = current_time - pb->last_progress_report_time;
@@ -943,8 +947,10 @@ static int report_delta_progress(
 				GIT_PACKBUILDER_DELTAFICATION,
 				count, pb->nr_objects, pb->progress_cb_payload);
 
-			if (ret)
+			if (ret) {
+				pb->failure = ret;
 				return git_error_set_after_callback(ret);
+			}
 		}
 	}
 
@@ -976,7 +982,10 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 		}
 
 		pb->nr_deltified += 1;
-		report_delta_progress(pb, pb->nr_deltified, false);
+		if ((error = report_delta_progress(pb, pb->nr_deltified, false)) < 0) {
+				GIT_ASSERT(git_packbuilder__progress_unlock(pb) == 0);
+				goto on_error;
+		}
 
 		po = *list++;
 		(*list_size)--;
@@ -1124,6 +1133,10 @@ struct thread_params {
 	size_t depth;
 	size_t working;
 	size_t data_ready;
+
+	/* A pb->progress_cb can stop the packing process by returning an error.
+	   When that happens, all threads observe the error and stop voluntarily. */
+	bool stopped;
 };
 
 static void *threaded_find_deltas(void *arg)
@@ -1133,7 +1146,12 @@ static void *threaded_find_deltas(void *arg)
 	while (me->remaining) {
 		if (find_deltas(me->pb, me->list, &me->remaining,
 				me->window, me->depth) < 0) {
-			; /* TODO */
+			me->stopped = true;
+			GIT_ASSERT_WITH_RETVAL(git_packbuilder__progress_lock(me->pb) == 0, NULL);
+			me->working = false;
+			git_cond_signal(&me->pb->progress_cond);
+			GIT_ASSERT_WITH_RETVAL(git_packbuilder__progress_unlock(me->pb) == 0, NULL);
+			return NULL;
 		}
 
 		GIT_ASSERT_WITH_RETVAL(git_packbuilder__progress_lock(me->pb) == 0, NULL);
@@ -1175,8 +1193,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		pb->nr_threads = git__online_cpus();
 
 	if (pb->nr_threads <= 1) {
-		find_deltas(pb, list, &list_size, window, depth);
-		return 0;
+		return find_deltas(pb, list, &list_size, window, depth);
 	}
 
 	p = git__mallocarray(pb->nr_threads, sizeof(*p));
@@ -1195,6 +1212,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		p[i].depth = depth;
 		p[i].working = 1;
 		p[i].data_ready = 0;
+		p[i].stopped = 0;
 
 		/* try to split chunks on "path" boundaries */
 		while (sub_size && sub_size < list_size &&
@@ -1262,7 +1280,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 			    (!victim || victim->remaining < p[i].remaining))
 				victim = &p[i];
 
-		if (victim) {
+		if (victim && !target->stopped) {
 			sub_size = victim->remaining / 2;
 			list = victim->list + victim->list_size - sub_size;
 			while (sub_size && list[0]->hash &&
@@ -1286,7 +1304,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		}
 		target->list_size = sub_size;
 		target->remaining = sub_size;
-		target->working = 1;
+		target->working = 1; /* even when target->stopped, so that we don't process this thread again */
 		GIT_ASSERT(git_packbuilder__progress_unlock(pb) == 0);
 
 		if (git_mutex_lock(&target->mutex)) {
@@ -1299,7 +1317,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		git_cond_signal(&target->cond);
 		git_mutex_unlock(&target->mutex);
 
-		if (!sub_size) {
+		if (target->stopped || !sub_size) {
 			git_thread_join(&target->thread, NULL);
 			git_cond_free(&target->cond);
 			git_mutex_free(&target->mutex);
@@ -1308,7 +1326,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 	}
 
 	git__free(p);
-	return 0;
+	return pb->failure;
 }
 
 #else
@@ -1319,6 +1337,7 @@ int git_packbuilder__prepare(git_packbuilder *pb)
 {
 	git_pobject **delta_list;
 	size_t i, n = 0;
+	int error;
 
 	if (pb->nr_objects == 0 || pb->done)
 		return 0; /* nothing to do */
@@ -1327,8 +1346,10 @@ int git_packbuilder__prepare(git_packbuilder *pb)
 	 * Although we do not report progress during deltafication, we
 	 * at least report that we are in the deltafication stage
 	 */
-	if (pb->progress_cb)
-			pb->progress_cb(GIT_PACKBUILDER_DELTAFICATION, 0, pb->nr_objects, pb->progress_cb_payload);
+	if (pb->progress_cb) {
+		if ((error = pb->progress_cb(GIT_PACKBUILDER_DELTAFICATION, 0, pb->nr_objects, pb->progress_cb_payload)) < 0)
+			return git_error_set_after_callback(error);
+	}
 
 	delta_list = git__mallocarray(pb->nr_objects, sizeof(*delta_list));
 	GIT_ERROR_CHECK_ALLOC(delta_list);
@@ -1345,31 +1366,33 @@ int git_packbuilder__prepare(git_packbuilder *pb)
 
 	if (n > 1) {
 		git__tsort((void **)delta_list, n, type_size_sort);
-		if (ll_find_deltas(pb, delta_list, n,
+		if ((error = ll_find_deltas(pb, delta_list, n,
 				   GIT_PACK_WINDOW + 1,
-				   GIT_PACK_DEPTH) < 0) {
+				   GIT_PACK_DEPTH)) < 0) {
 			git__free(delta_list);
-			return -1;
+			return error;
 		}
 	}
 
-	report_delta_progress(pb, pb->nr_objects, true);
+	error = report_delta_progress(pb, pb->nr_objects, true);
 
 	pb->done = true;
 	git__free(delta_list);
-	return 0;
+	return error;
 }
 
-#define PREPARE_PACK if (git_packbuilder__prepare(pb) < 0) { return -1; }
+#define PREPARE_PACK error = git_packbuilder__prepare(pb); if (error < 0) { return error; }
 
 int git_packbuilder_foreach(git_packbuilder *pb, int (*cb)(void *buf, size_t size, void *payload), void *payload)
 {
+	int error;
 	PREPARE_PACK;
 	return write_pack(pb, cb, payload);
 }
 
 int git_packbuilder__write_buf(git_str *buf, git_packbuilder *pb)
 {
+	int error;
 	PREPARE_PACK;
 
 	return write_pack(pb, &write_pack_buf, buf);
@@ -1419,8 +1442,9 @@ int git_packbuilder_write(
 #ifdef GIT_EXPERIMENTAL_SHA256
 	opts.mode = mode;
 	opts.odb = pb->odb;
+	opts.oid_type = GIT_OID_SHA1;
 
-	error = git_indexer_new(&indexer, path, GIT_OID_SHA1, &opts);
+	error = git_indexer_new(&indexer, path, &opts);
 #else
 	error = git_indexer_new(&indexer, path, mode, pb->odb, &opts);
 #endif
@@ -1584,12 +1608,16 @@ static int retrieve_object(struct walk_object **out, git_packbuilder *pb, const
 	struct walk_object *obj;
 	int error;
 
-	if ((obj = git_oidmap_get(pb->walk_objects, id)) == NULL) {
+	error = git_packbuilder_walk_objectmap_get(&obj, &pb->walk_objects, id);
+
+	if (error == GIT_ENOTFOUND) {
 		if ((error = lookup_walk_object(&obj, pb, id)) < 0)
 			return error;
 
-		if ((error = git_oidmap_set(pb->walk_objects, &obj->id, obj)) < 0)
+		if ((error = git_packbuilder_walk_objectmap_put(&pb->walk_objects, &obj->id, obj)) < 0)
 			return error;
+	} else if (error != 0) {
+		return error;
 	}
 
 	*out = obj;
@@ -1821,13 +1849,12 @@ void git_packbuilder_free(git_packbuilder *pb)
 	if (pb->odb)
 		git_odb_free(pb->odb);
 
-	if (pb->object_ix)
-		git_oidmap_free(pb->object_ix);
+	git_packbuilder_pobjectmap_dispose(&pb->object_ix);
 
 	if (pb->object_list)
 		git__free(pb->object_list);
 
-	git_oidmap_free(pb->walk_objects);
+	git_packbuilder_walk_objectmap_dispose(&pb->walk_objects);
 	git_pool_clear(&pb->object_pool);
 
 	git_hash_ctx_cleanup(&pb->ctx);

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

@@ -12,10 +12,10 @@
 
 #include "str.h"
 #include "hash.h"
-#include "oidmap.h"
 #include "zstream.h"
 #include "pool.h"
 #include "indexer.h"
+#include "hashmap_oid.h"
 
 #include "git2/oid.h"
 #include "git2/pack.h"
@@ -51,6 +51,11 @@ typedef struct git_pobject {
 	             filled:1;
 } git_pobject;
 
+typedef struct walk_object walk_object;
+
+GIT_HASHMAP_OID_STRUCT(git_packbuilder_pobjectmap, git_pobject *);
+GIT_HASHMAP_OID_STRUCT(git_packbuilder_walk_objectmap, walk_object *);
+
 struct git_packbuilder {
 	git_repository *repo; /* associated repository */
 	git_odb *odb; /* associated object database */
@@ -69,9 +74,8 @@ struct git_packbuilder {
 
 	git_pobject *object_list;
 
-	git_oidmap *object_ix;
-
-	git_oidmap *walk_objects;
+	git_packbuilder_pobjectmap object_ix;
+	git_packbuilder_walk_objectmap walk_objects;
 	git_pool object_pool;
 
 #ifndef GIT_DEPRECATE_HARD
@@ -100,6 +104,10 @@ struct git_packbuilder {
 	uint64_t last_progress_report_time;
 
 	bool done;
+
+	/* A non-zero error code in failure causes all threads to shut themselves
+	   down. Some functions will return this error code.  */
+	volatile int failure;
 };
 
 int git_packbuilder__write_buf(git_str *buf, git_packbuilder *pb);