loose.c

   1 #define USE_THE_REPOSITORY_VARIABLE
   2
   3 #include "git-compat-util.h"
   4 #include "hash.h"
   5 #include "path.h"
   6 #include "object-store.h"
   7 #include "hex.h"
   8 #include "wrapper.h"
   9 #include "gettext.h"
  10 #include "loose.h"
  11 #include "lockfile.h"
  12 #include "oidtree.h"
  13
  14 static const char *loose_object_header = "# loose-object-idx\n";
  15
  16 static inline int should_use_loose_object_map(struct repository *repo)
  17 {
  18         return repo->compat_hash_algo && repo->gitdir;
  19 }
  20
  21 void loose_object_map_init(struct loose_object_map **map)
  22 {
  23         struct loose_object_map *m;
  24         m = xmalloc(sizeof(**map));
  25         m->to_compat = kh_init_oid_map();
  26         m->to_storage = kh_init_oid_map();
  27         *map = m;
  28 }
  29
  30 static int insert_oid_pair(kh_oid_map_t *map, const struct object_id *key, const struct object_id *value)
  31 {
  32         khiter_t pos;
  33         int ret;
  34         struct object_id *stored;
  35
  36         pos = kh_put_oid_map(map, *key, &ret);
  37
  38         /* This item already exists in the map. */
  39         if (ret == 0)
  40                 return 0;
  41
  42         stored = xmalloc(sizeof(*stored));
  43         oidcpy(stored, value);
  44         kh_value(map, pos) = stored;
  45         return 1;
  46 }
  47
  48 static int insert_loose_map(struct object_directory *odb,
  49                             const struct object_id *oid,
  50                             const struct object_id *compat_oid)
  51 {
  52         struct loose_object_map *map = odb->loose_map;
  53         int inserted = 0;
  54
  55         inserted |= insert_oid_pair(map->to_compat, oid, compat_oid);
  56         inserted |= insert_oid_pair(map->to_storage, compat_oid, oid);
  57         if (inserted)
  58                 oidtree_insert(odb->loose_objects_cache, compat_oid);
  59
  60         return inserted;
  61 }
  62
  63 static int load_one_loose_object_map(struct repository *repo, struct object_directory *dir)
  64 {
  65         struct strbuf buf = STRBUF_INIT, path = STRBUF_INIT;
  66         FILE *fp;
  67
  68         if (!dir->loose_map)
  69                 loose_object_map_init(&dir->loose_map);
  70         if (!dir->loose_objects_cache) {
  71                 ALLOC_ARRAY(dir->loose_objects_cache, 1);
  72                 oidtree_init(dir->loose_objects_cache);
  73         }
  74
  75         insert_loose_map(dir, repo->hash_algo->empty_tree, repo->compat_hash_algo->empty_tree);
  76         insert_loose_map(dir, repo->hash_algo->empty_blob, repo->compat_hash_algo->empty_blob);
  77         insert_loose_map(dir, repo->hash_algo->null_oid, repo->compat_hash_algo->null_oid);
  78
  79         strbuf_git_common_path(&path, repo, "objects/loose-object-idx");
  80         fp = fopen(path.buf, "rb");
  81         if (!fp) {
  82                 strbuf_release(&path);
  83                 return 0;
  84         }
  85
  86         errno = 0;
  87         if (strbuf_getwholeline(&buf, fp, '\n') || strcmp(buf.buf, loose_object_header))
  88                 goto err;
  89         while (!strbuf_getline_lf(&buf, fp)) {
  90                 const char *p;
  91                 struct object_id oid, compat_oid;
  92                 if (parse_oid_hex_algop(buf.buf, &oid, &p, repo->hash_algo) ||
  93                     *p++ != ' ' ||
  94                     parse_oid_hex_algop(p, &compat_oid, &p, repo->compat_hash_algo) ||
  95                     p != buf.buf + buf.len)
  96                         goto err;
  97                 insert_loose_map(dir, &oid, &compat_oid);
  98         }
  99
 100         strbuf_release(&buf);
 101         strbuf_release(&path);
 102         return errno ? -1 : 0;
 103 err:
 104         strbuf_release(&buf);
 105         strbuf_release(&path);
 106         return -1;
 107 }
 108
 109 int repo_read_loose_object_map(struct repository *repo)
 110 {
 111         struct object_directory *dir;
 112
 113         if (!should_use_loose_object_map(repo))
 114                 return 0;
 115
 116         prepare_alt_odb(repo);
 117
 118         for (dir = repo->objects->odb; dir; dir = dir->next) {
 119                 if (load_one_loose_object_map(repo, dir) < 0) {
 120                         return -1;
 121                 }
 122         }
 123         return 0;
 124 }
 125
 126 int repo_write_loose_object_map(struct repository *repo)
 127 {
 128         kh_oid_map_t *map = repo->objects->odb->loose_map->to_compat;
 129         struct lock_file lock;
 130         int fd;
 131         khiter_t iter;
 132         struct strbuf buf = STRBUF_INIT, path = STRBUF_INIT;
 133
 134         if (!should_use_loose_object_map(repo))
 135                 return 0;
 136
 137         strbuf_git_common_path(&path, repo, "objects/loose-object-idx");
 138         fd = hold_lock_file_for_update_timeout(&lock, path.buf, LOCK_DIE_ON_ERROR, -1);
 139         iter = kh_begin(map);
 140         if (write_in_full(fd, loose_object_header, strlen(loose_object_header)) < 0)
 141                 goto errout;
 142
 143         for (; iter != kh_end(map); iter++) {
 144                 if (kh_exist(map, iter)) {
 145                         if (oideq(&kh_key(map, iter), the_hash_algo->empty_tree) ||
 146                             oideq(&kh_key(map, iter), the_hash_algo->empty_blob))
 147                                 continue;
 148                         strbuf_addf(&buf, "%s %s\n", oid_to_hex(&kh_key(map, iter)), oid_to_hex(kh_value(map, iter)));
 149                         if (write_in_full(fd, buf.buf, buf.len) < 0)
 150                                 goto errout;
 151                         strbuf_reset(&buf);
 152                 }
 153         }
 154         strbuf_release(&buf);
 155         if (commit_lock_file(&lock) < 0) {
 156                 error_errno(_("could not write loose object index %s"), path.buf);
 157                 strbuf_release(&path);
 158                 return -1;
 159         }
 160         strbuf_release(&path);
 161         return 0;
 162 errout:
 163         rollback_lock_file(&lock);
 164         strbuf_release(&buf);
 165         error_errno(_("failed to write loose object index %s\n"), path.buf);
 166         strbuf_release(&path);
 167         return -1;
 168 }
 169
 170 static int write_one_object(struct repository *repo, const struct object_id *oid,
 171                             const struct object_id *compat_oid)
 172 {
 173         struct lock_file lock;
 174         int fd;
 175         struct stat st;
 176         struct strbuf buf = STRBUF_INIT, path = STRBUF_INIT;
 177
 178         strbuf_git_common_path(&path, repo, "objects/loose-object-idx");
 179         hold_lock_file_for_update_timeout(&lock, path.buf, LOCK_DIE_ON_ERROR, -1);
 180
 181         fd = open(path.buf, O_WRONLY | O_CREAT | O_APPEND, 0666);
 182         if (fd < 0)
 183                 goto errout;
 184         if (fstat(fd, &st) < 0)
 185                 goto errout;
 186         if (!st.st_size && write_in_full(fd, loose_object_header, strlen(loose_object_header)) < 0)
 187                 goto errout;
 188
 189         strbuf_addf(&buf, "%s %s\n", oid_to_hex(oid), oid_to_hex(compat_oid));
 190         if (write_in_full(fd, buf.buf, buf.len) < 0)
 191                 goto errout;
 192         if (close(fd))
 193                 goto errout;
 194         adjust_shared_perm(path.buf);
 195         rollback_lock_file(&lock);
 196         strbuf_release(&buf);
 197         strbuf_release(&path);
 198         return 0;
 199 errout:
 200         error_errno(_("failed to write loose object index %s\n"), path.buf);
 201         close(fd);
 202         rollback_lock_file(&lock);
 203         strbuf_release(&buf);
 204         strbuf_release(&path);
 205         return -1;
 206 }
 207
 208 int repo_add_loose_object_map(struct repository *repo, const struct object_id *oid,
 209                               const struct object_id *compat_oid)
 210 {
 211         int inserted = 0;
 212
 213         if (!should_use_loose_object_map(repo))
 214                 return 0;
 215
 216         inserted = insert_loose_map(repo->objects->odb, oid, compat_oid);
 217         if (inserted)
 218                 return write_one_object(repo, oid, compat_oid);
 219         return 0;
 220 }
 221
 222 int repo_loose_object_map_oid(struct repository *repo,
 223                               const struct object_id *src,
 224                               const struct git_hash_algo *to,
 225                               struct object_id *dest)
 226 {
 227         struct object_directory *dir;
 228         kh_oid_map_t *map;
 229         khiter_t pos;
 230
 231         for (dir = repo->objects->odb; dir; dir = dir->next) {
 232                 struct loose_object_map *loose_map = dir->loose_map;
 233                 if (!loose_map)
 234                         continue;
 235                 map = (to == repo->compat_hash_algo) ?
 236                         loose_map->to_compat :
 237                         loose_map->to_storage;
 238                 pos = kh_get_oid_map(map, *src);
 239                 if (pos < kh_end(map)) {
 240                         oidcpy(dest, kh_value(map, pos));
 241                         return 0;
 242                 }
 243         }
 244         return -1;
 245 }
 246
 247 void loose_object_map_clear(struct loose_object_map **map)
 248 {
 249         struct loose_object_map *m = *map;
 250         struct object_id *oid;
 251
 252         if (!m)
 253                 return;
 254
 255         kh_foreach_value(m->to_compat, oid, free(oid));
 256         kh_foreach_value(m->to_storage, oid, free(oid));
 257         kh_destroy_oid_map(m->to_compat);
 258         kh_destroy_oid_map(m->to_storage);
 259         free(m);
 260         *map = NULL;
 261 }