reachable.c

   1 #include "cache.h"
   2 #include "refs.h"
   3 #include "tag.h"
   4 #include "commit.h"
   5 #include "blob.h"
   6 #include "diff.h"
   7 #include "revision.h"
   8 #include "reachable.h"
   9 #include "cache-tree.h"
  10 #include "progress.h"
  11 #include "list-objects.h"
  12 #include "packfile.h"
  13 #include "worktree.h"
  14 #include "object-store.h"
  15 #include "pack-bitmap.h"
  16
  17 struct connectivity_progress {
  18         struct progress *progress;
  19         unsigned long count;
  20 };
  21
  22 static void update_progress(struct connectivity_progress *cp)
  23 {
  24         cp->count++;
  25         if ((cp->count & 1023) == 0)
  26                 display_progress(cp->progress, cp->count);
  27 }
  28
  29 static int add_one_ref(const char *path, const struct object_id *oid,
  30                        int flag, void *cb_data)
  31 {
  32         struct rev_info *revs = (struct rev_info *)cb_data;
  33         struct object *object;
  34
  35         if ((flag & REF_ISSYMREF) && (flag & REF_ISBROKEN)) {
  36                 warning("symbolic ref is dangling: %s", path);
  37                 return 0;
  38         }
  39
  40         object = parse_object_or_die(oid, path);
  41         add_pending_object(revs, object, "");
  42
  43         return 0;
  44 }
  45
  46 /*
  47  * The traversal will have already marked us as SEEN, so we
  48  * only need to handle any progress reporting here.
  49  */
  50 static void mark_object(struct object *obj, const char *name, void *data)
  51 {
  52         update_progress(data);
  53 }
  54
  55 static void mark_commit(struct commit *c, void *data)
  56 {
  57         mark_object(&c->object, NULL, data);
  58 }
  59
  60 struct recent_data {
  61         struct rev_info *revs;
  62         timestamp_t timestamp;
  63 };
  64
  65 static void add_recent_object(const struct object_id *oid,
  66                               timestamp_t mtime,
  67                               struct recent_data *data)
  68 {
  69         struct object *obj;
  70         enum object_type type;
  71
  72         if (mtime <= data->timestamp)
  73                 return;
  74
  75         /*
  76          * We do not want to call parse_object here, because
  77          * inflating blobs and trees could be very expensive.
  78          * However, we do need to know the correct type for
  79          * later processing, and the revision machinery expects
  80          * commits and tags to have been parsed.
  81          */
  82         type = oid_object_info(the_repository, oid, NULL);
  83         if (type < 0)
  84                 die("unable to get object info for %s", oid_to_hex(oid));
  85
  86         switch (type) {
  87         case OBJ_TAG:
  88         case OBJ_COMMIT:
  89                 obj = parse_object_or_die(oid, NULL);
  90                 break;
  91         case OBJ_TREE:
  92                 obj = (struct object *)lookup_tree(the_repository, oid);
  93                 break;
  94         case OBJ_BLOB:
  95                 obj = (struct object *)lookup_blob(the_repository, oid);
  96                 break;
  97         default:
  98                 die("unknown object type for %s: %s",
  99                     oid_to_hex(oid), type_name(type));
 100         }
 101
 102         if (!obj)
 103                 die("unable to lookup %s", oid_to_hex(oid));
 104
 105         add_pending_object(data->revs, obj, "");
 106 }
 107
 108 static int add_recent_loose(const struct object_id *oid,
 109                             const char *path, void *data)
 110 {
 111         struct stat st;
 112         struct object *obj = lookup_object(the_repository, oid);
 113
 114         if (obj && obj->flags & SEEN)
 115                 return 0;
 116
 117         if (stat(path, &st) < 0) {
 118                 /*
 119                  * It's OK if an object went away during our iteration; this
 120                  * could be due to a simultaneous repack. But anything else
 121                  * we should abort, since we might then fail to mark objects
 122                  * which should not be pruned.
 123                  */
 124                 if (errno == ENOENT)
 125                         return 0;
 126                 return error_errno("unable to stat %s", oid_to_hex(oid));
 127         }
 128
 129         add_recent_object(oid, st.st_mtime, data);
 130         return 0;
 131 }
 132
 133 static int add_recent_packed(const struct object_id *oid,
 134                              struct packed_git *p, uint32_t pos,
 135                              void *data)
 136 {
 137         struct object *obj = lookup_object(the_repository, oid);
 138
 139         if (obj && obj->flags & SEEN)
 140                 return 0;
 141         add_recent_object(oid, p->mtime, data);
 142         return 0;
 143 }
 144
 145 int add_unseen_recent_objects_to_traversal(struct rev_info *revs,
 146                                            timestamp_t timestamp)
 147 {
 148         struct recent_data data;
 149         int r;
 150
 151         data.revs = revs;
 152         data.timestamp = timestamp;
 153
 154         r = for_each_loose_object(add_recent_loose, &data,
 155                                   FOR_EACH_OBJECT_LOCAL_ONLY);
 156         if (r)
 157                 return r;
 158         return for_each_packed_object(add_recent_packed, &data,
 159                                       FOR_EACH_OBJECT_LOCAL_ONLY);
 160 }
 161
 162 static int mark_object_seen(const struct object_id *oid,
 163                              enum object_type type,
 164                              int exclude,
 165                              uint32_t name_hash,
 166                              struct packed_git *found_pack,
 167                              off_t found_offset)
 168 {
 169         struct object *obj = lookup_object_by_type(the_repository, oid, type);
 170         if (!obj)
 171                 die("unable to create object '%s'", oid_to_hex(oid));
 172
 173         obj->flags |= SEEN;
 174         return 0;
 175 }
 176
 177 void mark_reachable_objects(struct rev_info *revs, int mark_reflog,
 178                             timestamp_t mark_recent, struct progress *progress)
 179 {
 180         struct connectivity_progress cp;
 181         struct bitmap_index *bitmap_git;
 182
 183         /*
 184          * Set up revision parsing, and mark us as being interested
 185          * in all object types, not just commits.
 186          */
 187         revs->tag_objects = 1;
 188         revs->blob_objects = 1;
 189         revs->tree_objects = 1;
 190
 191         /* Add all refs from the index file */
 192         add_index_objects_to_pending(revs, 0);
 193
 194         /* Add all external refs */
 195         for_each_ref(add_one_ref, revs);
 196
 197         /* detached HEAD is not included in the list above */
 198         head_ref(add_one_ref, revs);
 199         other_head_refs(add_one_ref, revs);
 200
 201         /* Add all reflog info */
 202         if (mark_reflog)
 203                 add_reflogs_to_pending(revs, 0);
 204
 205         cp.progress = progress;
 206         cp.count = 0;
 207
 208         bitmap_git = prepare_bitmap_walk(revs, 0);
 209         if (bitmap_git) {
 210                 traverse_bitmap_commit_list(bitmap_git, revs, mark_object_seen);
 211                 free_bitmap_index(bitmap_git);
 212         } else {
 213                 if (prepare_revision_walk(revs))
 214                         die("revision walk setup failed");
 215                 traverse_commit_list(revs, mark_commit, mark_object, &cp);
 216         }
 217
 218         if (mark_recent) {
 219                 revs->ignore_missing_links = 1;
 220                 if (add_unseen_recent_objects_to_traversal(revs, mark_recent))
 221                         die("unable to mark recent objects");
 222                 if (prepare_revision_walk(revs))
 223                         die("revision walk setup failed");
 224                 traverse_commit_list(revs, mark_commit, mark_object, &cp);
 225         }
 226
 227         display_progress(cp.progress, cp.count);
 228 }