reachable.c

   1 #include "git-compat-util.h"
   2 #include "gettext.h"
   3 #include "hex.h"
   4 #include "refs.h"
   5 #include "commit.h"
   6 #include "blob.h"
   7 #include "diff.h"
   8 #include "revision.h"
   9 #include "reachable.h"
  10 #include "cache-tree.h"
  11 #include "progress.h"
  12 #include "list-objects.h"
  13 #include "packfile.h"
  14 #include "worktree.h"
  15 #include "object-store-ll.h"
  16 #include "pack-bitmap.h"
  17 #include "pack-mtimes.h"
  18 #include "config.h"
  19 #include "run-command.h"
  20 #include "sequencer.h"
  21
  22 struct connectivity_progress {
  23         struct progress *progress;
  24         unsigned long count;
  25 };
  26
  27 static void update_progress(struct connectivity_progress *cp)
  28 {
  29         cp->count++;
  30         if ((cp->count & 1023) == 0)
  31                 display_progress(cp->progress, cp->count);
  32 }
  33
  34 static void add_one_file(const char *path, struct rev_info *revs)
  35 {
  36         struct strbuf buf = STRBUF_INIT;
  37         struct object_id oid;
  38         struct object *object;
  39
  40         if (!read_oneliner(&buf, path, READ_ONELINER_SKIP_IF_EMPTY)) {
  41                 strbuf_release(&buf);
  42                 return;
  43         }
  44         strbuf_trim(&buf);
  45         if (!get_oid_hex(buf.buf, &oid)) {
  46                 object = parse_object_or_die(&oid, buf.buf);
  47                 add_pending_object(revs, object, "");
  48         }
  49         strbuf_release(&buf);
  50 }
  51
  52 /* Mark objects recorded in rebase state files as reachable. */
  53 static void add_rebase_files(struct rev_info *revs)
  54 {
  55         struct strbuf buf = STRBUF_INIT;
  56         size_t len;
  57         const char *path[] = {
  58                 "rebase-apply/autostash",
  59                 "rebase-apply/orig-head",
  60                 "rebase-merge/autostash",
  61                 "rebase-merge/orig-head",
  62         };
  63         struct worktree **worktrees = get_worktrees();
  64
  65         for (struct worktree **wt = worktrees; *wt; wt++) {
  66                 strbuf_reset(&buf);
  67                 strbuf_addstr(&buf, get_worktree_git_dir(*wt));
  68                 strbuf_complete(&buf, '/');
  69                 len = buf.len;
  70                 for (size_t i = 0; i < ARRAY_SIZE(path); i++) {
  71                         strbuf_setlen(&buf, len);
  72                         strbuf_addstr(&buf, path[i]);
  73                         add_one_file(buf.buf, revs);
  74                 }
  75         }
  76         strbuf_release(&buf);
  77         free_worktrees(worktrees);
  78 }
  79
  80 static int add_one_ref(const char *path, const struct object_id *oid,
  81                        int flag, void *cb_data)
  82 {
  83         struct rev_info *revs = (struct rev_info *)cb_data;
  84         struct object *object;
  85
  86         if ((flag & REF_ISSYMREF) && (flag & REF_ISBROKEN)) {
  87                 warning("symbolic ref is dangling: %s", path);
  88                 return 0;
  89         }
  90
  91         object = parse_object_or_die(oid, path);
  92         add_pending_object(revs, object, "");
  93
  94         return 0;
  95 }
  96
  97 /*
  98  * The traversal will have already marked us as SEEN, so we
  99  * only need to handle any progress reporting here.
 100  */
 101 static void mark_object(struct object *obj UNUSED,
 102                         const char *name UNUSED,
 103                         void *data)
 104 {
 105         update_progress(data);
 106 }
 107
 108 static void mark_commit(struct commit *c, void *data)
 109 {
 110         mark_object(&c->object, NULL, data);
 111 }
 112
 113 struct recent_data {
 114         struct rev_info *revs;
 115         timestamp_t timestamp;
 116         report_recent_object_fn *cb;
 117         int ignore_in_core_kept_packs;
 118
 119         struct oidset extra_recent_oids;
 120         int extra_recent_oids_loaded;
 121 };
 122
 123 static int run_one_gc_recent_objects_hook(struct oidset *set,
 124                                             const char *args)
 125 {
 126         struct child_process cmd = CHILD_PROCESS_INIT;
 127         struct strbuf buf = STRBUF_INIT;
 128         FILE *out;
 129         int ret = 0;
 130
 131         cmd.use_shell = 1;
 132         cmd.out = -1;
 133
 134         strvec_push(&cmd.args, args);
 135
 136         if (start_command(&cmd))
 137                 return -1;
 138
 139         out = xfdopen(cmd.out, "r");
 140         while (strbuf_getline(&buf, out) != EOF) {
 141                 struct object_id oid;
 142                 const char *rest;
 143
 144                 if (parse_oid_hex(buf.buf, &oid, &rest) || *rest) {
 145                         ret = error(_("invalid extra cruft tip: '%s'"), buf.buf);
 146                         break;
 147                 }
 148
 149                 oidset_insert(set, &oid);
 150         }
 151
 152         fclose(out);
 153         ret |= finish_command(&cmd);
 154
 155         strbuf_release(&buf);
 156         return ret;
 157 }
 158
 159 static void load_gc_recent_objects(struct recent_data *data)
 160 {
 161         const struct string_list *programs;
 162         int ret = 0;
 163         size_t i;
 164
 165         data->extra_recent_oids_loaded = 1;
 166
 167         if (git_config_get_string_multi("gc.recentobjectshook", &programs))
 168                 return;
 169
 170         for (i = 0; i < programs->nr; i++) {
 171                 ret = run_one_gc_recent_objects_hook(&data->extra_recent_oids,
 172                                                        programs->items[i].string);
 173                 if (ret)
 174                         die(_("unable to enumerate additional recent objects"));
 175         }
 176 }
 177
 178 static int obj_is_recent(const struct object_id *oid, timestamp_t mtime,
 179                          struct recent_data *data)
 180 {
 181         if (mtime > data->timestamp)
 182                 return 1;
 183
 184         if (!data->extra_recent_oids_loaded)
 185                 load_gc_recent_objects(data);
 186         return oidset_contains(&data->extra_recent_oids, oid);
 187 }
 188
 189 static void add_recent_object(const struct object_id *oid,
 190                               struct packed_git *pack,
 191                               off_t offset,
 192                               timestamp_t mtime,
 193                               struct recent_data *data)
 194 {
 195         struct object *obj;
 196         enum object_type type;
 197
 198         if (!obj_is_recent(oid, mtime, data))
 199                 return;
 200
 201         /*
 202          * We do not want to call parse_object here, because
 203          * inflating blobs and trees could be very expensive.
 204          * However, we do need to know the correct type for
 205          * later processing, and the revision machinery expects
 206          * commits and tags to have been parsed.
 207          */
 208         type = oid_object_info(the_repository, oid, NULL);
 209         if (type < 0)
 210                 die("unable to get object info for %s", oid_to_hex(oid));
 211
 212         switch (type) {
 213         case OBJ_TAG:
 214         case OBJ_COMMIT:
 215                 obj = parse_object_or_die(oid, NULL);
 216                 break;
 217         case OBJ_TREE:
 218                 obj = (struct object *)lookup_tree(the_repository, oid);
 219                 break;
 220         case OBJ_BLOB:
 221                 obj = (struct object *)lookup_blob(the_repository, oid);
 222                 break;
 223         default:
 224                 die("unknown object type for %s: %s",
 225                     oid_to_hex(oid), type_name(type));
 226         }
 227
 228         if (!obj)
 229                 die("unable to lookup %s", oid_to_hex(oid));
 230
 231         add_pending_object(data->revs, obj, "");
 232         if (data->cb)
 233                 data->cb(obj, pack, offset, mtime);
 234 }
 235
 236 static int want_recent_object(struct recent_data *data,
 237                               const struct object_id *oid)
 238 {
 239         if (data->ignore_in_core_kept_packs &&
 240             has_object_kept_pack(oid, IN_CORE_KEEP_PACKS))
 241                 return 0;
 242         return 1;
 243 }
 244
 245 static int add_recent_loose(const struct object_id *oid,
 246                             const char *path, void *data)
 247 {
 248         struct stat st;
 249         struct object *obj;
 250
 251         if (!want_recent_object(data, oid))
 252                 return 0;
 253
 254         obj = lookup_object(the_repository, oid);
 255
 256         if (obj && obj->flags & SEEN)
 257                 return 0;
 258
 259         if (stat(path, &st) < 0) {
 260                 /*
 261                  * It's OK if an object went away during our iteration; this
 262                  * could be due to a simultaneous repack. But anything else
 263                  * we should abort, since we might then fail to mark objects
 264                  * which should not be pruned.
 265                  */
 266                 if (errno == ENOENT)
 267                         return 0;
 268                 return error_errno("unable to stat %s", oid_to_hex(oid));
 269         }
 270
 271         add_recent_object(oid, NULL, 0, st.st_mtime, data);
 272         return 0;
 273 }
 274
 275 static int add_recent_packed(const struct object_id *oid,
 276                              struct packed_git *p,
 277                              uint32_t pos,
 278                              void *data)
 279 {
 280         struct object *obj;
 281         timestamp_t mtime = p->mtime;
 282
 283         if (!want_recent_object(data, oid))
 284                 return 0;
 285
 286         obj = lookup_object(the_repository, oid);
 287
 288         if (obj && obj->flags & SEEN)
 289                 return 0;
 290         if (p->is_cruft) {
 291                 if (load_pack_mtimes(p) < 0)
 292                         die(_("could not load cruft pack .mtimes"));
 293                 mtime = nth_packed_mtime(p, pos);
 294         }
 295         add_recent_object(oid, p, nth_packed_object_offset(p, pos), mtime, data);
 296         return 0;
 297 }
 298
 299 int add_unseen_recent_objects_to_traversal(struct rev_info *revs,
 300                                            timestamp_t timestamp,
 301                                            report_recent_object_fn *cb,
 302                                            int ignore_in_core_kept_packs)
 303 {
 304         struct recent_data data;
 305         enum for_each_object_flags flags;
 306         int r;
 307
 308         data.revs = revs;
 309         data.timestamp = timestamp;
 310         data.cb = cb;
 311         data.ignore_in_core_kept_packs = ignore_in_core_kept_packs;
 312
 313         oidset_init(&data.extra_recent_oids, 0);
 314         data.extra_recent_oids_loaded = 0;
 315
 316         r = for_each_loose_object(add_recent_loose, &data,
 317                                   FOR_EACH_OBJECT_LOCAL_ONLY);
 318         if (r)
 319                 goto done;
 320
 321         flags = FOR_EACH_OBJECT_LOCAL_ONLY | FOR_EACH_OBJECT_PACK_ORDER;
 322         if (ignore_in_core_kept_packs)
 323                 flags |= FOR_EACH_OBJECT_SKIP_IN_CORE_KEPT_PACKS;
 324
 325         r = for_each_packed_object(add_recent_packed, &data, flags);
 326
 327 done:
 328         oidset_clear(&data.extra_recent_oids);
 329
 330         return r;
 331 }
 332
 333 static int mark_object_seen(const struct object_id *oid,
 334                              enum object_type type,
 335                              int exclude UNUSED,
 336                              uint32_t name_hash UNUSED,
 337                              struct packed_git *found_pack UNUSED,
 338                              off_t found_offset UNUSED)
 339 {
 340         struct object *obj = lookup_object_by_type(the_repository, oid, type);
 341         if (!obj)
 342                 die("unable to create object '%s'", oid_to_hex(oid));
 343
 344         obj->flags |= SEEN;
 345         return 0;
 346 }
 347
 348 void mark_reachable_objects(struct rev_info *revs, int mark_reflog,
 349                             timestamp_t mark_recent, struct progress *progress)
 350 {
 351         struct connectivity_progress cp;
 352         struct bitmap_index *bitmap_git;
 353
 354         /*
 355          * Set up revision parsing, and mark us as being interested
 356          * in all object types, not just commits.
 357          */
 358         revs->tag_objects = 1;
 359         revs->blob_objects = 1;
 360         revs->tree_objects = 1;
 361
 362         /* Add all refs from the index file */
 363         add_index_objects_to_pending(revs, 0);
 364
 365         /* Add all external refs */
 366         for_each_ref(add_one_ref, revs);
 367
 368         /* detached HEAD is not included in the list above */
 369         head_ref(add_one_ref, revs);
 370         other_head_refs(add_one_ref, revs);
 371
 372         /* rebase autostash and orig-head */
 373         add_rebase_files(revs);
 374
 375         /* Add all reflog info */
 376         if (mark_reflog)
 377                 add_reflogs_to_pending(revs, 0);
 378
 379         cp.progress = progress;
 380         cp.count = 0;
 381
 382         bitmap_git = prepare_bitmap_walk(revs, 0);
 383         if (bitmap_git) {
 384                 traverse_bitmap_commit_list(bitmap_git, revs, mark_object_seen);
 385                 free_bitmap_index(bitmap_git);
 386         } else {
 387                 if (prepare_revision_walk(revs))
 388                         die("revision walk setup failed");
 389                 traverse_commit_list(revs, mark_commit, mark_object, &cp);
 390         }
 391
 392         if (mark_recent) {
 393                 revs->ignore_missing_links = 1;
 394                 if (add_unseen_recent_objects_to_traversal(revs, mark_recent,
 395                                                            NULL, 0))
 396                         die("unable to mark recent objects");
 397                 if (prepare_revision_walk(revs))
 398                         die("revision walk setup failed");
 399                 traverse_commit_list(revs, mark_commit, mark_object, &cp);
 400         }
 401
 402         display_progress(cp.progress, cp.count);
 403 }