reachable.c

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