builtin/count-objects.c

   1 /*
   2  * Builtin "git count-objects".
   3  *
   4  * Copyright (c) 2006 Junio C Hamano
   5  */
   6
   7 #include "cache.h"
   8 #include "dir.h"
   9 #include "builtin.h"
  10 #include "parse-options.h"
  11
  12 static unsigned long garbage;
  13
  14 static void real_report_garbage(const char *desc, const char *path)
  15 {
  16         warning("%s: %s", desc, path);
  17         garbage++;
  18 }
  19
  20 static void count_objects(DIR *d, char *path, int len, int verbose,
  21                           unsigned long *loose,
  22                           off_t *loose_size,
  23                           unsigned long *packed_loose,
  24                           unsigned long *garbage)
  25 {
  26         struct dirent *ent;
  27         while ((ent = readdir(d)) != NULL) {
  28                 char hex[41];
  29                 unsigned char sha1[20];
  30                 const char *cp;
  31                 int bad = 0;
  32
  33                 if (is_dot_or_dotdot(ent->d_name))
  34                         continue;
  35                 for (cp = ent->d_name; *cp; cp++) {
  36                         int ch = *cp;
  37                         if (('0' <= ch && ch <= '9') ||
  38                             ('a' <= ch && ch <= 'f'))
  39                                 continue;
  40                         bad = 1;
  41                         break;
  42                 }
  43                 if (cp - ent->d_name != 38)
  44                         bad = 1;
  45                 else {
  46                         struct stat st;
  47                         memcpy(path + len + 3, ent->d_name, 38);
  48                         path[len + 2] = '/';
  49                         path[len + 41] = 0;
  50                         if (lstat(path, &st) || !S_ISREG(st.st_mode))
  51                                 bad = 1;
  52                         else
  53                                 (*loose_size) += xsize_t(on_disk_bytes(st));
  54                 }
  55                 if (bad) {
  56                         if (verbose) {
  57                                 error("garbage found: %.*s/%s",
  58                                       len + 2, path, ent->d_name);
  59                                 (*garbage)++;
  60                         }
  61                         continue;
  62                 }
  63                 (*loose)++;
  64                 if (!verbose)
  65                         continue;
  66                 memcpy(hex, path+len, 2);
  67                 memcpy(hex+2, ent->d_name, 38);
  68                 hex[40] = 0;
  69                 if (get_sha1_hex(hex, sha1))
  70                         die("internal error");
  71                 if (has_sha1_pack(sha1))
  72                         (*packed_loose)++;
  73         }
  74 }
  75
  76 static char const * const count_objects_usage[] = {
  77         N_("git count-objects [-v]"),
  78         NULL
  79 };
  80
  81 int cmd_count_objects(int argc, const char **argv, const char *prefix)
  82 {
  83         int i, verbose = 0;
  84         const char *objdir = get_object_directory();
  85         int len = strlen(objdir);
  86         char *path = xmalloc(len + 50);
  87         unsigned long loose = 0, packed = 0, packed_loose = 0;
  88         off_t loose_size = 0;
  89         struct option opts[] = {
  90                 OPT__VERBOSE(&verbose, N_("be verbose")),
  91                 OPT_END(),
  92         };
  93
  94         argc = parse_options(argc, argv, prefix, opts, count_objects_usage, 0);
  95         /* we do not take arguments other than flags for now */
  96         if (argc)
  97                 usage_with_options(count_objects_usage, opts);
  98         if (verbose)
  99                 report_garbage = real_report_garbage;
 100         memcpy(path, objdir, len);
 101         if (len && objdir[len-1] != '/')
 102                 path[len++] = '/';
 103         for (i = 0; i < 256; i++) {
 104                 DIR *d;
 105                 sprintf(path + len, "%02x", i);
 106                 d = opendir(path);
 107                 if (!d)
 108                         continue;
 109                 count_objects(d, path, len, verbose,
 110                               &loose, &loose_size, &packed_loose, &garbage);
 111                 closedir(d);
 112         }
 113         if (verbose) {
 114                 struct packed_git *p;
 115                 unsigned long num_pack = 0;
 116                 off_t size_pack = 0;
 117                 if (!packed_git)
 118                         prepare_packed_git();
 119                 for (p = packed_git; p; p = p->next) {
 120                         if (!p->pack_local)
 121                                 continue;
 122                         if (open_pack_index(p))
 123                                 continue;
 124                         packed += p->num_objects;
 125                         size_pack += p->pack_size + p->index_size;
 126                         num_pack++;
 127                 }
 128                 printf("count: %lu\n", loose);
 129                 printf("size: %lu\n", (unsigned long) (loose_size / 1024));
 130                 printf("in-pack: %lu\n", packed);
 131                 printf("packs: %lu\n", num_pack);
 132                 printf("size-pack: %lu\n", (unsigned long) (size_pack / 1024));
 133                 printf("prune-packable: %lu\n", packed_loose);
 134                 printf("garbage: %lu\n", garbage);
 135         }
 136         else
 137                 printf("%lu objects, %lu kilobytes\n",
 138                        loose, (unsigned long) (loose_size / 1024));
 139         return 0;
 140 }