Andrew's git - gitweb.git/blob

   1/*
   2 * git gc builtin command
   3 *
   4 * Cleanup unreachable files and optimize the repository.
   5 *
   6 * Copyright (c) 2007 James Bowes
   7 *
   8 * Based on git-gc.sh, which is
   9 *
  10 * Copyright (c) 2006 Shawn O. Pearce
  11 */
  12
  13#include "builtin.h"
  14#include "cache.h"
  15#include "parse-options.h"
  16#include "run-command.h"
  17
  18#define FAILED_RUN "failed to run %s"
  19
  20static const char * const builtin_gc_usage[] = {
  21        "git-gc [options]",
  22        NULL
  23};
  24
  25static int pack_refs = 1;
  26static int aggressive_window = -1;
  27static int gc_auto_threshold = 6700;
  28static int gc_auto_pack_limit = 20;
  29
  30#define MAX_ADD 10
  31static const char *argv_pack_refs[] = {"pack-refs", "--all", "--prune", NULL};
  32static const char *argv_reflog[] = {"reflog", "expire", "--all", NULL};
  33static const char *argv_repack[MAX_ADD] = {"repack", "-d", "-l", NULL};
  34static const char *argv_prune[] = {"prune", NULL};
  35static const char *argv_rerere[] = {"rerere", "gc", NULL};
  36
  37static int gc_config(const char *var, const char *value)
  38{
  39        if (!strcmp(var, "gc.packrefs")) {
  40                if (!strcmp(value, "notbare"))
  41                        pack_refs = -1;
  42                else
  43                        pack_refs = git_config_bool(var, value);
  44                return 0;
  45        }
  46        if (!strcmp(var, "gc.aggressivewindow")) {
  47                aggressive_window = git_config_int(var, value);
  48                return 0;
  49        }
  50        if (!strcmp(var, "gc.auto")) {
  51                gc_auto_threshold = git_config_int(var, value);
  52                return 0;
  53        }
  54        if (!strcmp(var, "gc.autopacklimit")) {
  55                gc_auto_pack_limit = git_config_int(var, value);
  56                return 0;
  57        }
  58        return git_default_config(var, value);
  59}
  60
  61static void append_option(const char **cmd, const char *opt, int max_length)
  62{
  63        int i;
  64
  65        for (i = 0; cmd[i]; i++)
  66                ;
  67
  68        if (i + 2 >= max_length)
  69                die("Too many options specified");
  70        cmd[i++] = opt;
  71        cmd[i] = NULL;
  72}
  73
  74static int too_many_loose_objects(void)
  75{
  76        /*
  77         * Quickly check if a "gc" is needed, by estimating how
  78         * many loose objects there are.  Because SHA-1 is evenly
  79         * distributed, we can check only one and get a reasonable
  80         * estimate.
  81         */
  82        char path[PATH_MAX];
  83        const char *objdir = get_object_directory();
  84        DIR *dir;
  85        struct dirent *ent;
  86        int auto_threshold;
  87        int num_loose = 0;
  88        int needed = 0;
  89
  90        if (gc_auto_threshold <= 0)
  91                return 0;
  92
  93        if (sizeof(path) <= snprintf(path, sizeof(path), "%s/17", objdir)) {
  94                warning("insanely long object directory %.*s", 50, objdir);
  95                return 0;
  96        }
  97        dir = opendir(path);
  98        if (!dir)
  99                return 0;
 100
 101        auto_threshold = (gc_auto_threshold + 255) / 256;
 102        while ((ent = readdir(dir)) != NULL) {
 103                if (strspn(ent->d_name, "0123456789abcdef") != 38 ||
 104                    ent->d_name[38] != '\0')
 105                        continue;
 106                if (++num_loose > auto_threshold) {
 107                        needed = 1;
 108                        break;
 109                }
 110        }
 111        closedir(dir);
 112        return needed;
 113}
 114
 115static int too_many_packs(void)
 116{
 117        struct packed_git *p;
 118        int cnt;
 119
 120        if (gc_auto_pack_limit <= 0)
 121                return 0;
 122
 123        prepare_packed_git();
 124        for (cnt = 0, p = packed_git; p; p = p->next) {
 125                char path[PATH_MAX];
 126                size_t len;
 127                int keep;
 128
 129                if (!p->pack_local)
 130                        continue;
 131                len = strlen(p->pack_name);
 132                if (PATH_MAX <= len + 1)
 133                        continue; /* oops, give up */
 134                memcpy(path, p->pack_name, len-5);
 135                memcpy(path + len - 5, ".keep", 6);
 136                keep = access(p->pack_name, F_OK) && (errno == ENOENT);
 137                if (keep)
 138                        continue;
 139                /*
 140                 * Perhaps check the size of the pack and count only
 141                 * very small ones here?
 142                 */
 143                cnt++;
 144        }
 145        return gc_auto_pack_limit <= cnt;
 146}
 147
 148static int need_to_gc(void)
 149{
 150        /*
 151         * Setting gc.auto and gc.autopacklimit to 0 or negative can
 152         * disable the automatic gc.
 153         */
 154        if (gc_auto_threshold <= 0 && gc_auto_pack_limit <= 0)
 155                return 0;
 156
 157        /*
 158         * If there are too many loose objects, but not too many
 159         * packs, we run "repack -d -l".  If there are too many packs,
 160         * we run "repack -A -d -l".  Otherwise we tell the caller
 161         * there is no need.
 162         */
 163        if (too_many_packs())
 164                append_option(argv_repack, "-A", MAX_ADD);
 165        else if (!too_many_loose_objects())
 166                return 0;
 167        return 1;
 168}
 169
 170int cmd_gc(int argc, const char **argv, const char *prefix)
 171{
 172        int prune = 0;
 173        int aggressive = 0;
 174        int auto_gc = 0;
 175        char buf[80];
 176
 177        struct option builtin_gc_options[] = {
 178                OPT_BOOLEAN(0, "prune", &prune, "prune unreferenced objects"),
 179                OPT_BOOLEAN(0, "aggressive", &aggressive, "be more thorough (increased runtime)"),
 180                OPT_BOOLEAN(0, "auto", &auto_gc, "enable auto-gc mode"),
 181                OPT_END()
 182        };
 183
 184        git_config(gc_config);
 185
 186        if (pack_refs < 0)
 187                pack_refs = !is_bare_repository();
 188
 189        argc = parse_options(argc, argv, builtin_gc_options, builtin_gc_usage, 0);
 190        if (argc > 0)
 191                usage_with_options(builtin_gc_usage, builtin_gc_options);
 192
 193        if (aggressive) {
 194                append_option(argv_repack, "-f", MAX_ADD);
 195                if (aggressive_window > 0) {
 196                        sprintf(buf, "--window=%d", aggressive_window);
 197                        append_option(argv_repack, buf, MAX_ADD);
 198                }
 199        }
 200
 201        if (auto_gc) {
 202                /*
 203                 * Auto-gc should be least intrusive as possible.
 204                 */
 205                prune = 0;
 206                if (!need_to_gc())
 207                        return 0;
 208                fprintf(stderr, "Packing your repository for optimum "
 209                        "performance. You may also\n"
 210                        "run \"git gc\" manually. See "
 211                        "\"git help gc\" for more information.\n");
 212        } else {
 213                /*
 214                 * Use safer (for shared repos) "-A" option to
 215                 * repack when not pruning. Auto-gc makes its
 216                 * own decision.
 217                 */
 218                if (prune)
 219                        append_option(argv_repack, "-a", MAX_ADD);
 220                else
 221                        append_option(argv_repack, "-A", MAX_ADD);
 222        }
 223
 224        if (pack_refs && run_command_v_opt(argv_pack_refs, RUN_GIT_CMD))
 225                return error(FAILED_RUN, argv_pack_refs[0]);
 226
 227        if (run_command_v_opt(argv_reflog, RUN_GIT_CMD))
 228                return error(FAILED_RUN, argv_reflog[0]);
 229
 230        if (run_command_v_opt(argv_repack, RUN_GIT_CMD))
 231                return error(FAILED_RUN, argv_repack[0]);
 232
 233        if (prune && run_command_v_opt(argv_prune, RUN_GIT_CMD))
 234                return error(FAILED_RUN, argv_prune[0]);
 235
 236        if (run_command_v_opt(argv_rerere, RUN_GIT_CMD))
 237                return error(FAILED_RUN, argv_rerere[0]);
 238
 239        if (auto_gc && too_many_loose_objects())
 240                warning("There are too many unreachable loose objects; "
 241                        "run 'git prune' to remove them.");
 242
 243        return 0;
 244}