tmp-objdir.c

   1 #include "cache.h"
   2 #include "tmp-objdir.h"
   3 #include "dir.h"
   4 #include "sigchain.h"
   5 #include "string-list.h"
   6 #include "strbuf.h"
   7 #include "argv-array.h"
   8 #include "quote.h"
   9 #include "object-store.h"
  10
  11 struct tmp_objdir {
  12         struct strbuf path;
  13         struct argv_array env;
  14 };
  15
  16 /*
  17  * Allow only one tmp_objdir at a time in a running process, which simplifies
  18  * our signal/atexit cleanup routines.  It's doubtful callers will ever need
  19  * more than one, and we can expand later if so.  You can have many such
  20  * tmp_objdirs simultaneously in many processes, of course.
  21  */
  22 static struct tmp_objdir *the_tmp_objdir;
  23
  24 static void tmp_objdir_free(struct tmp_objdir *t)
  25 {
  26         strbuf_release(&t->path);
  27         argv_array_clear(&t->env);
  28         free(t);
  29 }
  30
  31 static int tmp_objdir_destroy_1(struct tmp_objdir *t, int on_signal)
  32 {
  33         int err;
  34
  35         if (!t)
  36                 return 0;
  37
  38         if (t == the_tmp_objdir)
  39                 the_tmp_objdir = NULL;
  40
  41         /*
  42          * This may use malloc via strbuf_grow(), but we should
  43          * have pre-grown t->path sufficiently so that this
  44          * doesn't happen in practice.
  45          */
  46         err = remove_dir_recursively(&t->path, 0);
  47
  48         /*
  49          * When we are cleaning up due to a signal, we won't bother
  50          * freeing memory; it may cause a deadlock if the signal
  51          * arrived while libc's allocator lock is held.
  52          */
  53         if (!on_signal)
  54                 tmp_objdir_free(t);
  55         return err;
  56 }
  57
  58 int tmp_objdir_destroy(struct tmp_objdir *t)
  59 {
  60         return tmp_objdir_destroy_1(t, 0);
  61 }
  62
  63 static void remove_tmp_objdir(void)
  64 {
  65         tmp_objdir_destroy(the_tmp_objdir);
  66 }
  67
  68 static void remove_tmp_objdir_on_signal(int signo)
  69 {
  70         tmp_objdir_destroy_1(the_tmp_objdir, 1);
  71         sigchain_pop(signo);
  72         raise(signo);
  73 }
  74
  75 /*
  76  * These env_* functions are for setting up the child environment; the
  77  * "replace" variant overrides the value of any existing variable with that
  78  * "key". The "append" variant puts our new value at the end of a list,
  79  * separated by PATH_SEP (which is what separate values in
  80  * GIT_ALTERNATE_OBJECT_DIRECTORIES).
  81  */
  82 static void env_append(struct argv_array *env, const char *key, const char *val)
  83 {
  84         struct strbuf quoted = STRBUF_INIT;
  85         const char *old;
  86
  87         /*
  88          * Avoid quoting if it's not necessary, for maximum compatibility
  89          * with older parsers which don't understand the quoting.
  90          */
  91         if (*val == '"' || strchr(val, PATH_SEP)) {
  92                 strbuf_addch(&quoted, '"');
  93                 quote_c_style(val, &quoted, NULL, 1);
  94                 strbuf_addch(&quoted, '"');
  95                 val = quoted.buf;
  96         }
  97
  98         old = getenv(key);
  99         if (!old)
 100                 argv_array_pushf(env, "%s=%s", key, val);
 101         else
 102                 argv_array_pushf(env, "%s=%s%c%s", key, old, PATH_SEP, val);
 103
 104         strbuf_release(&quoted);
 105 }
 106
 107 static void env_replace(struct argv_array *env, const char *key, const char *val)
 108 {
 109         argv_array_pushf(env, "%s=%s", key, val);
 110 }
 111
 112 static int setup_tmp_objdir(const char *root)
 113 {
 114         char *path;
 115         int ret = 0;
 116
 117         path = xstrfmt("%s/pack", root);
 118         ret = mkdir(path, 0777);
 119         free(path);
 120
 121         return ret;
 122 }
 123
 124 struct tmp_objdir *tmp_objdir_create(void)
 125 {
 126         static int installed_handlers;
 127         struct tmp_objdir *t;
 128
 129         if (the_tmp_objdir)
 130                 die("BUG: only one tmp_objdir can be used at a time");
 131
 132         t = xmalloc(sizeof(*t));
 133         strbuf_init(&t->path, 0);
 134         argv_array_init(&t->env);
 135
 136         strbuf_addf(&t->path, "%s/incoming-XXXXXX", get_object_directory());
 137
 138         /*
 139          * Grow the strbuf beyond any filename we expect to be placed in it.
 140          * If tmp_objdir_destroy() is called by a signal handler, then
 141          * we should be able to use the strbuf to remove files without
 142          * having to call malloc.
 143          */
 144         strbuf_grow(&t->path, 1024);
 145
 146         if (!mkdtemp(t->path.buf)) {
 147                 /* free, not destroy, as we never touched the filesystem */
 148                 tmp_objdir_free(t);
 149                 return NULL;
 150         }
 151
 152         the_tmp_objdir = t;
 153         if (!installed_handlers) {
 154                 atexit(remove_tmp_objdir);
 155                 sigchain_push_common(remove_tmp_objdir_on_signal);
 156                 installed_handlers++;
 157         }
 158
 159         if (setup_tmp_objdir(t->path.buf)) {
 160                 tmp_objdir_destroy(t);
 161                 return NULL;
 162         }
 163
 164         env_append(&t->env, ALTERNATE_DB_ENVIRONMENT,
 165                    absolute_path(get_object_directory()));
 166         env_replace(&t->env, DB_ENVIRONMENT, absolute_path(t->path.buf));
 167         env_replace(&t->env, GIT_QUARANTINE_ENVIRONMENT,
 168                     absolute_path(t->path.buf));
 169
 170         return t;
 171 }
 172
 173 /*
 174  * Make sure we copy packfiles and their associated metafiles in the correct
 175  * order. All of these ends_with checks are slightly expensive to do in
 176  * the midst of a sorting routine, but in practice it shouldn't matter.
 177  * We will have a relatively small number of packfiles to order, and loose
 178  * objects exit early in the first line.
 179  */
 180 static int pack_copy_priority(const char *name)
 181 {
 182         if (!starts_with(name, "pack"))
 183                 return 0;
 184         if (ends_with(name, ".keep"))
 185                 return 1;
 186         if (ends_with(name, ".pack"))
 187                 return 2;
 188         if (ends_with(name, ".idx"))
 189                 return 3;
 190         return 4;
 191 }
 192
 193 static int pack_copy_cmp(const char *a, const char *b)
 194 {
 195         return pack_copy_priority(a) - pack_copy_priority(b);
 196 }
 197
 198 static int read_dir_paths(struct string_list *out, const char *path)
 199 {
 200         DIR *dh;
 201         struct dirent *de;
 202
 203         dh = opendir(path);
 204         if (!dh)
 205                 return -1;
 206
 207         while ((de = readdir(dh)))
 208                 if (de->d_name[0] != '.')
 209                         string_list_append(out, de->d_name);
 210
 211         closedir(dh);
 212         return 0;
 213 }
 214
 215 static int migrate_paths(struct strbuf *src, struct strbuf *dst);
 216
 217 static int migrate_one(struct strbuf *src, struct strbuf *dst)
 218 {
 219         struct stat st;
 220
 221         if (stat(src->buf, &st) < 0)
 222                 return -1;
 223         if (S_ISDIR(st.st_mode)) {
 224                 if (!mkdir(dst->buf, 0777)) {
 225                         if (adjust_shared_perm(dst->buf))
 226                                 return -1;
 227                 } else if (errno != EEXIST)
 228                         return -1;
 229                 return migrate_paths(src, dst);
 230         }
 231         return finalize_object_file(src->buf, dst->buf);
 232 }
 233
 234 static int migrate_paths(struct strbuf *src, struct strbuf *dst)
 235 {
 236         size_t src_len = src->len, dst_len = dst->len;
 237         struct string_list paths = STRING_LIST_INIT_DUP;
 238         int i;
 239         int ret = 0;
 240
 241         if (read_dir_paths(&paths, src->buf) < 0)
 242                 return -1;
 243         paths.cmp = pack_copy_cmp;
 244         string_list_sort(&paths);
 245
 246         for (i = 0; i < paths.nr; i++) {
 247                 const char *name = paths.items[i].string;
 248
 249                 strbuf_addf(src, "/%s", name);
 250                 strbuf_addf(dst, "/%s", name);
 251
 252                 ret |= migrate_one(src, dst);
 253
 254                 strbuf_setlen(src, src_len);
 255                 strbuf_setlen(dst, dst_len);
 256         }
 257
 258         string_list_clear(&paths, 0);
 259         return ret;
 260 }
 261
 262 int tmp_objdir_migrate(struct tmp_objdir *t)
 263 {
 264         struct strbuf src = STRBUF_INIT, dst = STRBUF_INIT;
 265         int ret;
 266
 267         if (!t)
 268                 return 0;
 269
 270         strbuf_addbuf(&src, &t->path);
 271         strbuf_addstr(&dst, get_object_directory());
 272
 273         ret = migrate_paths(&src, &dst);
 274
 275         strbuf_release(&src);
 276         strbuf_release(&dst);
 277
 278         tmp_objdir_destroy(t);
 279         return ret;
 280 }
 281
 282 const char **tmp_objdir_env(const struct tmp_objdir *t)
 283 {
 284         if (!t)
 285                 return NULL;
 286         return t->env.argv;
 287 }
 288
 289 void tmp_objdir_add_as_alternate(const struct tmp_objdir *t)
 290 {
 291         add_to_alternates_memory(t->path.buf);
 292 }