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