tmp-objdir.c - jrn/git - Git at Google

 #include "cache.h"
 #include "tmp-objdir.h"
 #include "chdir-notify.h"
 #include "dir.h"
 #include "sigchain.h"
 #include "string-list.h"
 #include "strbuf.h"
 #include "strvec.h"
 #include "quote.h"
 #include "object-store.h"

 struct tmp_objdir {
 	struct strbuf path;
 	struct strvec env;
 	struct object_directory *prev_odb;
 	int will_destroy;
 };

 /*
  * Allow only one tmp_objdir at a time in a running process, which simplifies
  * our signal/atexit cleanup routines.  It's doubtful callers will ever need
  * more than one, and we can expand later if so.  You can have many such
  * tmp_objdirs simultaneously in many processes, of course.
  */
 static struct tmp_objdir *the_tmp_objdir;

 static void tmp_objdir_free(struct tmp_objdir *t)
 {
 	strbuf_release(&t->path);
 	strvec_clear(&t->env);
 	free(t);
 }

 static int tmp_objdir_destroy_1(struct tmp_objdir *t, int on_signal)
 {
 	int err;

 	if (!t)
 		return 0;

 	if (t == the_tmp_objdir)
 		the_tmp_objdir = NULL;

 	if (!on_signal && t->prev_odb)
 		restore_primary_odb(t->prev_odb, t->path.buf);

 	/*
 	 * This may use malloc via strbuf_grow(), but we should
 	 * have pre-grown t->path sufficiently so that this
 	 * doesn't happen in practice.
 	 */
 	err = remove_dir_recursively(&t->path, 0);

 	/*
 	 * When we are cleaning up due to a signal, we won't bother
 	 * freeing memory; it may cause a deadlock if the signal
 	 * arrived while libc's allocator lock is held.
 	 */
 	if (!on_signal)
 		tmp_objdir_free(t);

 	return err;
 }

 int tmp_objdir_destroy(struct tmp_objdir *t)
 {
 	return tmp_objdir_destroy_1(t, 0);
 }

 static void remove_tmp_objdir(void)
 {
 	tmp_objdir_destroy(the_tmp_objdir);
 }

 static void remove_tmp_objdir_on_signal(int signo)
 {
 	tmp_objdir_destroy_1(the_tmp_objdir, 1);
 	sigchain_pop(signo);
 	raise(signo);
 }

 void tmp_objdir_discard_objects(struct tmp_objdir *t)
 {
 	remove_dir_recursively(&t->path, REMOVE_DIR_KEEP_TOPLEVEL);
 }

 /*
  * These env_* functions are for setting up the child environment; the
  * "replace" variant overrides the value of any existing variable with that
  * "key". The "append" variant puts our new value at the end of a list,
  * separated by PATH_SEP (which is what separate values in
  * GIT_ALTERNATE_OBJECT_DIRECTORIES).
  */
 static void env_append(struct strvec *env, const char *key, const char *val)
 {
 	struct strbuf quoted = STRBUF_INIT;
 	const char *old;

 	/*
 	 * Avoid quoting if it's not necessary, for maximum compatibility
 	 * with older parsers which don't understand the quoting.
 	 */
 	if (*val == '"' || strchr(val, PATH_SEP)) {
 		strbuf_addch(&quoted, '"');
 		quote_c_style(val, &quoted, NULL, 1);
 		strbuf_addch(&quoted, '"');
 		val = quoted.buf;
 	}

 	old = getenv(key);
 	if (!old)
 		strvec_pushf(env, "%s=%s", key, val);
 	else
 		strvec_pushf(env, "%s=%s%c%s", key, old, PATH_SEP, val);

 	strbuf_release(&quoted);
 }

 static void env_replace(struct strvec *env, const char *key, const char *val)
 {
 	strvec_pushf(env, "%s=%s", key, val);
 }

 static int setup_tmp_objdir(const char *root)
 {
 	char *path;
 	int ret = 0;

 	path = xstrfmt("%s/pack", root);
 	ret = mkdir(path, 0777);
 	free(path);

 	return ret;
 }

 struct tmp_objdir *tmp_objdir_create(const char *prefix)
 {
 	static int installed_handlers;
 	struct tmp_objdir *t;

 	if (the_tmp_objdir)
 		BUG("only one tmp_objdir can be used at a time");

 	t = xcalloc(1, sizeof(*t));
 	strbuf_init(&t->path, 0);
 	strvec_init(&t->env);

 	/*
 	 * Use a string starting with tmp_ so that the builtin/prune.c code
 	 * can recognize any stale objdirs left behind by a crash and delete
 	 * them.
 	 */
 	strbuf_addf(&t->path, "%s/tmp_objdir-%s-XXXXXX", get_object_directory(), prefix);

 	/*
 	 * Grow the strbuf beyond any filename we expect to be placed in it.
 	 * If tmp_objdir_destroy() is called by a signal handler, then
 	 * we should be able to use the strbuf to remove files without
 	 * having to call malloc.
 	 */
 	strbuf_grow(&t->path, 1024);

 	if (!mkdtemp(t->path.buf)) {
 		/* free, not destroy, as we never touched the filesystem */
 		tmp_objdir_free(t);
 		return NULL;
 	}

 	the_tmp_objdir = t;
 	if (!installed_handlers) {
 		atexit(remove_tmp_objdir);
 		sigchain_push_common(remove_tmp_objdir_on_signal);
 		installed_handlers++;
 	}

 	if (setup_tmp_objdir(t->path.buf)) {
 		tmp_objdir_destroy(t);
 		return NULL;
 	}

 	env_append(&t->env, ALTERNATE_DB_ENVIRONMENT,
 		   absolute_path(get_object_directory()));
 	env_replace(&t->env, DB_ENVIRONMENT, absolute_path(t->path.buf));
 	env_replace(&t->env, GIT_QUARANTINE_ENVIRONMENT,
 		    absolute_path(t->path.buf));

 	return t;
 }

 /*
  * Make sure we copy packfiles and their associated metafiles in the correct
  * order. All of these ends_with checks are slightly expensive to do in
  * the midst of a sorting routine, but in practice it shouldn't matter.
  * We will have a relatively small number of packfiles to order, and loose
  * objects exit early in the first line.
  */
 static int pack_copy_priority(const char *name)
 {
 	if (!starts_with(name, "pack"))
 		return 0;
 	if (ends_with(name, ".keep"))
 		return 1;
 	if (ends_with(name, ".pack"))
 		return 2;
 	if (ends_with(name, ".rev"))
 		return 3;
 	if (ends_with(name, ".idx"))
 		return 4;
 	return 5;
 }

 static int pack_copy_cmp(const char *a, const char *b)
 {
 	return pack_copy_priority(a) - pack_copy_priority(b);
 }

 static int read_dir_paths(struct string_list *out, const char *path)
 {
 	DIR *dh;
 	struct dirent *de;

 	dh = opendir(path);
 	if (!dh)
 		return -1;

 	while ((de = readdir(dh)))
 		if (de->d_name[0] != '.')
 			string_list_append(out, de->d_name);

 	closedir(dh);
 	return 0;
 }

 static int migrate_paths(struct strbuf *src, struct strbuf *dst);

 static int migrate_one(struct strbuf *src, struct strbuf *dst)
 {
 	struct stat st;

 	if (stat(src->buf, &st) < 0)
 		return -1;
 	if (S_ISDIR(st.st_mode)) {
 		if (!mkdir(dst->buf, 0777)) {
 			if (adjust_shared_perm(dst->buf))
 				return -1;
 		} else if (errno != EEXIST)
 			return -1;
 		return migrate_paths(src, dst);
 	}
 	return finalize_object_file(src->buf, dst->buf);
 }

 static int migrate_paths(struct strbuf *src, struct strbuf *dst)
 {
 	size_t src_len = src->len, dst_len = dst->len;
 	struct string_list paths = STRING_LIST_INIT_DUP;
 	int i;
 	int ret = 0;

 	if (read_dir_paths(&paths, src->buf) < 0)
 		return -1;
 	paths.cmp = pack_copy_cmp;
 	string_list_sort(&paths);

 	for (i = 0; i < paths.nr; i++) {
 		const char *name = paths.items[i].string;

 		strbuf_addf(src, "/%s", name);
 		strbuf_addf(dst, "/%s", name);

 		ret |= migrate_one(src, dst);

 		strbuf_setlen(src, src_len);
 		strbuf_setlen(dst, dst_len);
 	}

 	string_list_clear(&paths, 0);
 	return ret;
 }

 int tmp_objdir_migrate(struct tmp_objdir *t)
 {
 	struct strbuf src = STRBUF_INIT, dst = STRBUF_INIT;
 	int ret;

 	if (!t)
 		return 0;

 	if (t->prev_odb) {
 		if (the_repository->objects->odb->will_destroy)
 			BUG("migrating an ODB that was marked for destruction");
 		restore_primary_odb(t->prev_odb, t->path.buf);
 		t->prev_odb = NULL;
 	}

 	strbuf_addbuf(&src, &t->path);
 	strbuf_addstr(&dst, get_object_directory());

 	ret = migrate_paths(&src, &dst);

 	strbuf_release(&src);
 	strbuf_release(&dst);

 	tmp_objdir_destroy(t);
 	return ret;
 }

 const char **tmp_objdir_env(const struct tmp_objdir *t)
 {
 	if (!t)
 		return NULL;
 	return t->env.v;
 }

 void tmp_objdir_add_as_alternate(const struct tmp_objdir *t)
 {
 	add_to_alternates_memory(t->path.buf);
 }

 void tmp_objdir_replace_primary_odb(struct tmp_objdir *t, int will_destroy)
 {
 	if (t->prev_odb)
 		BUG("the primary object database is already replaced");
 	t->prev_odb = set_temporary_primary_odb(t->path.buf, will_destroy);
 	t->will_destroy = will_destroy;
 }

 struct tmp_objdir *tmp_objdir_unapply_primary_odb(void)
 {
 	if (!the_tmp_objdir || !the_tmp_objdir->prev_odb)
 		return NULL;

 	restore_primary_odb(the_tmp_objdir->prev_odb, the_tmp_objdir->path.buf);
 	the_tmp_objdir->prev_odb = NULL;
 	return the_tmp_objdir;
 }

 void tmp_objdir_reapply_primary_odb(struct tmp_objdir *t, const char *old_cwd,
 		const char *new_cwd)
 {
 	char *path;

 	path = reparent_relative_path(old_cwd, new_cwd, t->path.buf);
 	strbuf_reset(&t->path);
 	strbuf_addstr(&t->path, path);
 	free(path);
 	tmp_objdir_replace_primary_odb(t, t->will_destroy);
 }
	#include "cache.h"
	#include "tmp-objdir.h"
	#include "chdir-notify.h"
	#include "dir.h"
	#include "sigchain.h"
	#include "string-list.h"
	#include "strbuf.h"
	#include "strvec.h"
	#include "quote.h"
	#include "object-store.h"

	struct tmp_objdir {
	struct strbuf path;
	struct strvec env;
	struct object_directory *prev_odb;
	int will_destroy;
	};

	/*
	* Allow only one tmp_objdir at a time in a running process, which simplifies
	* our signal/atexit cleanup routines. It's doubtful callers will ever need
	* more than one, and we can expand later if so. You can have many such
	* tmp_objdirs simultaneously in many processes, of course.
	*/
	static struct tmp_objdir *the_tmp_objdir;

	static void tmp_objdir_free(struct tmp_objdir *t)
	{
	strbuf_release(&t->path);
	strvec_clear(&t->env);
	free(t);
	}

	static int tmp_objdir_destroy_1(struct tmp_objdir *t, int on_signal)
	{
	int err;

	if (!t)
	return 0;

	if (t == the_tmp_objdir)
	the_tmp_objdir = NULL;

	if (!on_signal && t->prev_odb)
	restore_primary_odb(t->prev_odb, t->path.buf);

	/*
	* This may use malloc via strbuf_grow(), but we should
	* have pre-grown t->path sufficiently so that this
	* doesn't happen in practice.
	*/
	err = remove_dir_recursively(&t->path, 0);

	/*
	* When we are cleaning up due to a signal, we won't bother
	* freeing memory; it may cause a deadlock if the signal
	* arrived while libc's allocator lock is held.
	*/
	if (!on_signal)
	tmp_objdir_free(t);

	return err;
	}

	int tmp_objdir_destroy(struct tmp_objdir *t)
	{
	return tmp_objdir_destroy_1(t, 0);
	}

	static void remove_tmp_objdir(void)
	{
	tmp_objdir_destroy(the_tmp_objdir);
	}

	static void remove_tmp_objdir_on_signal(int signo)
	{
	tmp_objdir_destroy_1(the_tmp_objdir, 1);
	sigchain_pop(signo);
	raise(signo);
	}

	void tmp_objdir_discard_objects(struct tmp_objdir *t)
	{
	remove_dir_recursively(&t->path, REMOVE_DIR_KEEP_TOPLEVEL);
	}

	/*
	* These env_* functions are for setting up the child environment; the
	* "replace" variant overrides the value of any existing variable with that
	* "key". The "append" variant puts our new value at the end of a list,
	* separated by PATH_SEP (which is what separate values in
	* GIT_ALTERNATE_OBJECT_DIRECTORIES).
	*/
	static void env_append(struct strvec env, const char key, const char *val)
	{
	struct strbuf quoted = STRBUF_INIT;
	const char *old;

	/*
	* Avoid quoting if it's not necessary, for maximum compatibility
	* with older parsers which don't understand the quoting.
	*/
	if (*val == '"' \|\| strchr(val, PATH_SEP)) {
	strbuf_addch(&quoted, '"');
	quote_c_style(val, &quoted, NULL, 1);
	strbuf_addch(&quoted, '"');
	val = quoted.buf;
	}

	old = getenv(key);
	if (!old)
	strvec_pushf(env, "%s=%s", key, val);
	else
	strvec_pushf(env, "%s=%s%c%s", key, old, PATH_SEP, val);

	strbuf_release(&quoted);
	}

	static void env_replace(struct strvec env, const char key, const char *val)
	{
	strvec_pushf(env, "%s=%s", key, val);
	}

	static int setup_tmp_objdir(const char *root)
	{
	char *path;
	int ret = 0;

	path = xstrfmt("%s/pack", root);
	ret = mkdir(path, 0777);
	free(path);

	return ret;
	}

	struct tmp_objdir tmp_objdir_create(const char prefix)
	{
	static int installed_handlers;
	struct tmp_objdir *t;

	if (the_tmp_objdir)
	BUG("only one tmp_objdir can be used at a time");

	t = xcalloc(1, sizeof(*t));
	strbuf_init(&t->path, 0);
	strvec_init(&t->env);

	/*
	* Use a string starting with tmp_ so that the builtin/prune.c code
	* can recognize any stale objdirs left behind by a crash and delete
	* them.
	*/
	strbuf_addf(&t->path, "%s/tmp_objdir-%s-XXXXXX", get_object_directory(), prefix);

	/*
	* Grow the strbuf beyond any filename we expect to be placed in it.
	* If tmp_objdir_destroy() is called by a signal handler, then
	* we should be able to use the strbuf to remove files without
	* having to call malloc.
	*/
	strbuf_grow(&t->path, 1024);

	if (!mkdtemp(t->path.buf)) {
	/* free, not destroy, as we never touched the filesystem */
	tmp_objdir_free(t);
	return NULL;
	}

	the_tmp_objdir = t;
	if (!installed_handlers) {
	atexit(remove_tmp_objdir);
	sigchain_push_common(remove_tmp_objdir_on_signal);
	installed_handlers++;
	}

	if (setup_tmp_objdir(t->path.buf)) {
	tmp_objdir_destroy(t);
	return NULL;
	}

	env_append(&t->env, ALTERNATE_DB_ENVIRONMENT,
	absolute_path(get_object_directory()));
	env_replace(&t->env, DB_ENVIRONMENT, absolute_path(t->path.buf));
	env_replace(&t->env, GIT_QUARANTINE_ENVIRONMENT,
	absolute_path(t->path.buf));

	return t;
	}

	/*
	* Make sure we copy packfiles and their associated metafiles in the correct
	* order. All of these ends_with checks are slightly expensive to do in
	* the midst of a sorting routine, but in practice it shouldn't matter.
	* We will have a relatively small number of packfiles to order, and loose
	* objects exit early in the first line.
	*/
	static int pack_copy_priority(const char *name)
	{
	if (!starts_with(name, "pack"))
	return 0;
	if (ends_with(name, ".keep"))
	return 1;
	if (ends_with(name, ".pack"))
	return 2;
	if (ends_with(name, ".rev"))
	return 3;
	if (ends_with(name, ".idx"))
	return 4;
	return 5;
	}

	static int pack_copy_cmp(const char a, const char b)
	{
	return pack_copy_priority(a) - pack_copy_priority(b);
	}

	static int read_dir_paths(struct string_list out, const char path)
	{
	DIR *dh;
	struct dirent *de;

	dh = opendir(path);
	if (!dh)
	return -1;

	while ((de = readdir(dh)))
	if (de->d_name[0] != '.')
	string_list_append(out, de->d_name);

	closedir(dh);
	return 0;
	}

	static int migrate_paths(struct strbuf src, struct strbuf dst);

	static int migrate_one(struct strbuf src, struct strbuf dst)
	{
	struct stat st;

	if (stat(src->buf, &st) < 0)
	return -1;
	if (S_ISDIR(st.st_mode)) {
	if (!mkdir(dst->buf, 0777)) {
	if (adjust_shared_perm(dst->buf))
	return -1;
	} else if (errno != EEXIST)
	return -1;
	return migrate_paths(src, dst);
	}
	return finalize_object_file(src->buf, dst->buf);
	}

	static int migrate_paths(struct strbuf src, struct strbuf dst)
	{
	size_t src_len = src->len, dst_len = dst->len;
	struct string_list paths = STRING_LIST_INIT_DUP;
	int i;
	int ret = 0;

	if (read_dir_paths(&paths, src->buf) < 0)
	return -1;
	paths.cmp = pack_copy_cmp;
	string_list_sort(&paths);

	for (i = 0; i < paths.nr; i++) {
	const char *name = paths.items[i].string;

	strbuf_addf(src, "/%s", name);
	strbuf_addf(dst, "/%s", name);

	ret \|= migrate_one(src, dst);

	strbuf_setlen(src, src_len);
	strbuf_setlen(dst, dst_len);
	}

	string_list_clear(&paths, 0);
	return ret;
	}

	int tmp_objdir_migrate(struct tmp_objdir *t)
	{
	struct strbuf src = STRBUF_INIT, dst = STRBUF_INIT;
	int ret;

	if (!t)
	return 0;

	if (t->prev_odb) {
	if (the_repository->objects->odb->will_destroy)
	BUG("migrating an ODB that was marked for destruction");
	restore_primary_odb(t->prev_odb, t->path.buf);
	t->prev_odb = NULL;
	}

	strbuf_addbuf(&src, &t->path);
	strbuf_addstr(&dst, get_object_directory());

	ret = migrate_paths(&src, &dst);

	strbuf_release(&src);
	strbuf_release(&dst);

	tmp_objdir_destroy(t);
	return ret;
	}

	const char *tmp_objdir_env(const struct tmp_objdir t)
	{
	if (!t)
	return NULL;
	return t->env.v;
	}

	void tmp_objdir_add_as_alternate(const struct tmp_objdir *t)
	{
	add_to_alternates_memory(t->path.buf);
	}

	void tmp_objdir_replace_primary_odb(struct tmp_objdir *t, int will_destroy)
	{
	if (t->prev_odb)
	BUG("the primary object database is already replaced");
	t->prev_odb = set_temporary_primary_odb(t->path.buf, will_destroy);
	t->will_destroy = will_destroy;
	}

	struct tmp_objdir *tmp_objdir_unapply_primary_odb(void)
	{
	if (!the_tmp_objdir \|\| !the_tmp_objdir->prev_odb)
	return NULL;

	restore_primary_odb(the_tmp_objdir->prev_odb, the_tmp_objdir->path.buf);
	the_tmp_objdir->prev_odb = NULL;
	return the_tmp_objdir;
	}

	void tmp_objdir_reapply_primary_odb(struct tmp_objdir t, const char old_cwd,
	const char *new_cwd)
	{
	char *path;

	path = reparent_relative_path(old_cwd, new_cwd, t->path.buf);
	strbuf_reset(&t->path);
	strbuf_addstr(&t->path, path);
	free(path);
	tmp_objdir_replace_primary_odb(t, t->will_destroy);
	}