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