Peter Hagervall | baffc0e | 2007-07-15 01:14:45 +0200 | [diff] [blame] | 1 | #include "builtin.h" |
Linus Torvalds | 4b18242 | 2005-04-30 09:59:31 -0700 | [diff] [blame] | 2 | #include "cache.h" |
Daniel Barkalow | ff5ebe3 | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 3 | #include "commit.h" |
| 4 | #include "tree.h" |
| 5 | #include "blob.h" |
Daniel Barkalow | c418eda | 2005-04-28 07:46:33 -0700 | [diff] [blame] | 6 | #include "tag.h" |
Linus Torvalds | 944d858 | 2005-07-03 10:01:38 -0700 | [diff] [blame] | 7 | #include "refs.h" |
Junio C Hamano | f925339 | 2005-06-29 02:51:27 -0700 | [diff] [blame] | 8 | #include "pack.h" |
Junio C Hamano | 53dc3f3 | 2006-04-25 16:37:08 -0700 | [diff] [blame] | 9 | #include "cache-tree.h" |
Linus Torvalds | e9a95be | 2006-05-29 12:19:02 -0700 | [diff] [blame] | 10 | #include "tree-walk.h" |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 11 | #include "fsck.h" |
Pierre Habouzit | 5ac0a20 | 2007-10-15 22:34:05 +0200 | [diff] [blame] | 12 | #include "parse-options.h" |
Alexander Potashev | 8ca12c0 | 2009-01-10 15:07:50 +0300 | [diff] [blame] | 13 | #include "dir.h" |
Daniel Barkalow | ff5ebe3 | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 14 | |
| 15 | #define REACHABLE 0x0001 |
Linus Torvalds | 2d9c58c | 2006-05-29 12:18:33 -0700 | [diff] [blame] | 16 | #define SEEN 0x0002 |
Linus Torvalds | d9839e0 | 2005-04-13 09:57:30 -0700 | [diff] [blame] | 17 | |
David Rientjes | 96f1e58 | 2006-08-15 10:23:48 -0700 | [diff] [blame] | 18 | static int show_root; |
| 19 | static int show_tags; |
| 20 | static int show_unreachable; |
Shawn O. Pearce | 566842f | 2007-04-04 10:46:14 -0400 | [diff] [blame] | 21 | static int include_reflogs = 1; |
Junio C Hamano | f29cd39 | 2009-10-20 11:46:55 -0700 | [diff] [blame] | 22 | static int check_full = 1; |
David Rientjes | 96f1e58 | 2006-08-15 10:23:48 -0700 | [diff] [blame] | 23 | static int check_strict; |
| 24 | static int keep_cache_objects; |
Linus Torvalds | d9839e0 | 2005-04-13 09:57:30 -0700 | [diff] [blame] | 25 | static unsigned char head_sha1[20]; |
Junio C Hamano | 469e2eb | 2009-01-30 00:33:00 -0800 | [diff] [blame] | 26 | static const char *head_points_at; |
Junio C Hamano | e2b4f63 | 2007-03-05 00:22:06 -0800 | [diff] [blame] | 27 | static int errors_found; |
Johannes Schindelin | 68f6c01 | 2007-07-03 01:33:54 +0100 | [diff] [blame] | 28 | static int write_lost_and_found; |
Johannes Schindelin | 20f1eb6 | 2007-06-05 03:44:00 +0100 | [diff] [blame] | 29 | static int verbose; |
Junio C Hamano | e2b4f63 | 2007-03-05 00:22:06 -0800 | [diff] [blame] | 30 | #define ERROR_OBJECT 01 |
| 31 | #define ERROR_REACHABLE 02 |
Linus Torvalds | d9839e0 | 2005-04-13 09:57:30 -0700 | [diff] [blame] | 32 | |
Timo Hirvonen | 962554c | 2006-02-26 17:13:46 +0200 | [diff] [blame] | 33 | #ifdef NO_D_INO_IN_DIRENT |
Junio C Hamano | 35a730f | 2006-01-19 17:13:51 -0800 | [diff] [blame] | 34 | #define SORT_DIRENT 0 |
| 35 | #define DIRENT_SORT_HINT(de) 0 |
| 36 | #else |
| 37 | #define SORT_DIRENT 1 |
| 38 | #define DIRENT_SORT_HINT(de) ((de)->d_ino) |
| 39 | #endif |
Petr Baudis | f1f0d08 | 2005-09-20 20:56:05 +0200 | [diff] [blame] | 40 | |
| 41 | static void objreport(struct object *obj, const char *severity, |
| 42 | const char *err, va_list params) |
| 43 | { |
| 44 | fprintf(stderr, "%s in %s %s: ", |
Linus Torvalds | 885a86a | 2006-06-14 16:45:13 -0700 | [diff] [blame] | 45 | severity, typename(obj->type), sha1_to_hex(obj->sha1)); |
Petr Baudis | f1f0d08 | 2005-09-20 20:56:05 +0200 | [diff] [blame] | 46 | vfprintf(stderr, err, params); |
| 47 | fputs("\n", stderr); |
| 48 | } |
| 49 | |
Tarmigan Casebolt | 28bea9e | 2009-11-14 13:33:13 -0800 | [diff] [blame] | 50 | __attribute__((format (printf, 2, 3))) |
Peter Hagervall | a7928f8 | 2005-09-28 14:04:54 +0200 | [diff] [blame] | 51 | static int objerror(struct object *obj, const char *err, ...) |
Petr Baudis | f1f0d08 | 2005-09-20 20:56:05 +0200 | [diff] [blame] | 52 | { |
| 53 | va_list params; |
| 54 | va_start(params, err); |
Junio C Hamano | e2b4f63 | 2007-03-05 00:22:06 -0800 | [diff] [blame] | 55 | errors_found |= ERROR_OBJECT; |
Petr Baudis | f1f0d08 | 2005-09-20 20:56:05 +0200 | [diff] [blame] | 56 | objreport(obj, "error", err, params); |
| 57 | va_end(params); |
| 58 | return -1; |
| 59 | } |
| 60 | |
Tarmigan Casebolt | 28bea9e | 2009-11-14 13:33:13 -0800 | [diff] [blame] | 61 | __attribute__((format (printf, 3, 4))) |
Martin Koegler | ba002f3 | 2008-02-25 22:46:08 +0100 | [diff] [blame] | 62 | static int fsck_error_func(struct object *obj, int type, const char *err, ...) |
Petr Baudis | f1f0d08 | 2005-09-20 20:56:05 +0200 | [diff] [blame] | 63 | { |
| 64 | va_list params; |
| 65 | va_start(params, err); |
Martin Koegler | ba002f3 | 2008-02-25 22:46:08 +0100 | [diff] [blame] | 66 | objreport(obj, (type == FSCK_WARN) ? "warning" : "error", err, params); |
Petr Baudis | f1f0d08 | 2005-09-20 20:56:05 +0200 | [diff] [blame] | 67 | va_end(params); |
Martin Koegler | ba002f3 | 2008-02-25 22:46:08 +0100 | [diff] [blame] | 68 | return (type == FSCK_WARN) ? 0 : 1; |
Petr Baudis | f1f0d08 | 2005-09-20 20:56:05 +0200 | [diff] [blame] | 69 | } |
| 70 | |
Linus Torvalds | 04d3975 | 2008-12-10 19:44:37 -0800 | [diff] [blame] | 71 | static struct object_array pending; |
| 72 | |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 73 | static int mark_object(struct object *obj, int type, void *data) |
| 74 | { |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 75 | struct object *parent = data; |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 76 | |
Junio C Hamano | a1cdc25 | 2011-01-26 12:46:55 -0800 | [diff] [blame] | 77 | /* |
| 78 | * The only case data is NULL or type is OBJ_ANY is when |
| 79 | * mark_object_reachable() calls us. All the callers of |
| 80 | * that function has non-NULL obj hence ... |
| 81 | */ |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 82 | if (!obj) { |
Junio C Hamano | a1cdc25 | 2011-01-26 12:46:55 -0800 | [diff] [blame] | 83 | /* ... these references to parent->fld are safe here */ |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 84 | printf("broken link from %7s %s\n", |
| 85 | typename(parent->type), sha1_to_hex(parent->sha1)); |
| 86 | printf("broken link from %7s %s\n", |
| 87 | (type == OBJ_ANY ? "unknown" : typename(type)), "unknown"); |
| 88 | errors_found |= ERROR_REACHABLE; |
| 89 | return 1; |
| 90 | } |
| 91 | |
| 92 | if (type != OBJ_ANY && obj->type != type) |
Junio C Hamano | a1cdc25 | 2011-01-26 12:46:55 -0800 | [diff] [blame] | 93 | /* ... and the reference to parent is safe here */ |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 94 | objerror(parent, "wrong object type in link"); |
| 95 | |
| 96 | if (obj->flags & REACHABLE) |
| 97 | return 0; |
| 98 | obj->flags |= REACHABLE; |
| 99 | if (!obj->parsed) { |
| 100 | if (parent && !has_sha1_file(obj->sha1)) { |
| 101 | printf("broken link from %7s %s\n", |
| 102 | typename(parent->type), sha1_to_hex(parent->sha1)); |
| 103 | printf(" to %7s %s\n", |
| 104 | typename(obj->type), sha1_to_hex(obj->sha1)); |
| 105 | errors_found |= ERROR_REACHABLE; |
| 106 | } |
| 107 | return 1; |
| 108 | } |
| 109 | |
Linus Torvalds | 04d3975 | 2008-12-10 19:44:37 -0800 | [diff] [blame] | 110 | add_object_array(obj, (void *) parent, &pending); |
| 111 | return 0; |
| 112 | } |
| 113 | |
| 114 | static void mark_object_reachable(struct object *obj) |
| 115 | { |
Linus Torvalds | 2af202b | 2009-06-18 10:28:43 -0700 | [diff] [blame] | 116 | mark_object(obj, OBJ_ANY, NULL); |
Linus Torvalds | 04d3975 | 2008-12-10 19:44:37 -0800 | [diff] [blame] | 117 | } |
| 118 | |
Junio C Hamano | a1cdc25 | 2011-01-26 12:46:55 -0800 | [diff] [blame] | 119 | static int traverse_one_object(struct object *obj) |
Linus Torvalds | 04d3975 | 2008-12-10 19:44:37 -0800 | [diff] [blame] | 120 | { |
| 121 | int result; |
| 122 | struct tree *tree = NULL; |
| 123 | |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 124 | if (obj->type == OBJ_TREE) { |
| 125 | obj->parsed = 0; |
| 126 | tree = (struct tree *)obj; |
| 127 | if (parse_tree(tree) < 0) |
| 128 | return 1; /* error already displayed */ |
| 129 | } |
| 130 | result = fsck_walk(obj, mark_object, obj); |
| 131 | if (tree) { |
| 132 | free(tree->buffer); |
| 133 | tree->buffer = NULL; |
| 134 | } |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 135 | return result; |
| 136 | } |
| 137 | |
Linus Torvalds | 04d3975 | 2008-12-10 19:44:37 -0800 | [diff] [blame] | 138 | static int traverse_reachable(void) |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 139 | { |
Linus Torvalds | 04d3975 | 2008-12-10 19:44:37 -0800 | [diff] [blame] | 140 | int result = 0; |
| 141 | while (pending.nr) { |
| 142 | struct object_array_entry *entry; |
Johannes Schindelin | c0aa335 | 2011-03-22 13:50:08 +0100 | [diff] [blame] | 143 | struct object *obj; |
Linus Torvalds | 04d3975 | 2008-12-10 19:44:37 -0800 | [diff] [blame] | 144 | |
| 145 | entry = pending.objects + --pending.nr; |
| 146 | obj = entry->item; |
Junio C Hamano | a1cdc25 | 2011-01-26 12:46:55 -0800 | [diff] [blame] | 147 | result |= traverse_one_object(obj); |
Linus Torvalds | 04d3975 | 2008-12-10 19:44:37 -0800 | [diff] [blame] | 148 | } |
| 149 | return !!result; |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 150 | } |
| 151 | |
| 152 | static int mark_used(struct object *obj, int type, void *data) |
| 153 | { |
| 154 | if (!obj) |
| 155 | return 1; |
| 156 | obj->used = 1; |
| 157 | return 0; |
Petr Baudis | f1f0d08 | 2005-09-20 20:56:05 +0200 | [diff] [blame] | 158 | } |
| 159 | |
Linus Torvalds | 18af29f | 2007-01-21 22:26:41 -0800 | [diff] [blame] | 160 | /* |
| 161 | * Check a single reachable object |
| 162 | */ |
| 163 | static void check_reachable_object(struct object *obj) |
| 164 | { |
Linus Torvalds | 18af29f | 2007-01-21 22:26:41 -0800 | [diff] [blame] | 165 | /* |
| 166 | * We obviously want the object to be parsed, |
| 167 | * except if it was in a pack-file and we didn't |
| 168 | * do a full fsck |
| 169 | */ |
| 170 | if (!obj->parsed) { |
Junio C Hamano | cd673c1 | 2009-02-27 23:15:53 -0800 | [diff] [blame] | 171 | if (has_sha1_pack(obj->sha1)) |
Linus Torvalds | 18af29f | 2007-01-21 22:26:41 -0800 | [diff] [blame] | 172 | return; /* it is in pack - forget about it */ |
| 173 | printf("missing %s %s\n", typename(obj->type), sha1_to_hex(obj->sha1)); |
Junio C Hamano | e2b4f63 | 2007-03-05 00:22:06 -0800 | [diff] [blame] | 174 | errors_found |= ERROR_REACHABLE; |
Linus Torvalds | 18af29f | 2007-01-21 22:26:41 -0800 | [diff] [blame] | 175 | return; |
| 176 | } |
Linus Torvalds | 18af29f | 2007-01-21 22:26:41 -0800 | [diff] [blame] | 177 | } |
| 178 | |
| 179 | /* |
| 180 | * Check a single unreachable object |
| 181 | */ |
| 182 | static void check_unreachable_object(struct object *obj) |
| 183 | { |
| 184 | /* |
| 185 | * Missing unreachable object? Ignore it. It's not like |
| 186 | * we miss it (since it can't be reached), nor do we want |
| 187 | * to complain about it being unreachable (since it does |
| 188 | * not exist). |
| 189 | */ |
| 190 | if (!obj->parsed) |
| 191 | return; |
| 192 | |
| 193 | /* |
| 194 | * Unreachable object that exists? Show it if asked to, |
| 195 | * since this is something that is prunable. |
| 196 | */ |
| 197 | if (show_unreachable) { |
| 198 | printf("unreachable %s %s\n", typename(obj->type), sha1_to_hex(obj->sha1)); |
| 199 | return; |
| 200 | } |
| 201 | |
| 202 | /* |
| 203 | * "!used" means that nothing at all points to it, including |
Pavel Roskin | 3dff537 | 2007-02-03 23:49:16 -0500 | [diff] [blame] | 204 | * other unreachable objects. In other words, it's the "tip" |
Linus Torvalds | 18af29f | 2007-01-21 22:26:41 -0800 | [diff] [blame] | 205 | * of some set of unreachable objects, usually a commit that |
| 206 | * got dropped. |
| 207 | * |
| 208 | * Such starting points are more interesting than some random |
| 209 | * set of unreachable objects, so we show them even if the user |
| 210 | * hasn't asked for _all_ unreachable objects. If you have |
| 211 | * deleted a branch by mistake, this is a prime candidate to |
| 212 | * start looking at, for example. |
| 213 | */ |
| 214 | if (!obj->used) { |
| 215 | printf("dangling %s %s\n", typename(obj->type), |
| 216 | sha1_to_hex(obj->sha1)); |
Johannes Schindelin | 68f6c01 | 2007-07-03 01:33:54 +0100 | [diff] [blame] | 217 | if (write_lost_and_found) { |
| 218 | char *filename = git_path("lost-found/%s/%s", |
| 219 | obj->type == OBJ_COMMIT ? "commit" : "other", |
| 220 | sha1_to_hex(obj->sha1)); |
| 221 | FILE *f; |
| 222 | |
| 223 | if (safe_create_leading_directories(filename)) { |
| 224 | error("Could not create lost-found"); |
| 225 | return; |
| 226 | } |
| 227 | if (!(f = fopen(filename, "w"))) |
Thomas Rast | 0721c31 | 2009-06-27 17:58:47 +0200 | [diff] [blame] | 228 | die_errno("Could not open '%s'", filename); |
Johannes Schindelin | 16a7fcf | 2007-07-22 21:20:26 +0100 | [diff] [blame] | 229 | if (obj->type == OBJ_BLOB) { |
| 230 | enum object_type type; |
| 231 | unsigned long size; |
| 232 | char *buf = read_sha1_file(obj->sha1, |
| 233 | &type, &size); |
Junio C Hamano | eb726f2 | 2011-09-11 18:03:38 -0700 | [diff] [blame] | 234 | if (buf && fwrite(buf, 1, size, f) != size) |
| 235 | die_errno("Could not write '%s'", filename); |
| 236 | free(buf); |
Johannes Schindelin | 16a7fcf | 2007-07-22 21:20:26 +0100 | [diff] [blame] | 237 | } else |
| 238 | fprintf(f, "%s\n", sha1_to_hex(obj->sha1)); |
Alex Riesen | 47d32af | 2008-12-05 01:35:48 +0100 | [diff] [blame] | 239 | if (fclose(f)) |
Thomas Rast | d824cbb | 2009-06-27 17:58:46 +0200 | [diff] [blame] | 240 | die_errno("Could not finish '%s'", |
| 241 | filename); |
Johannes Schindelin | 68f6c01 | 2007-07-03 01:33:54 +0100 | [diff] [blame] | 242 | } |
Linus Torvalds | 18af29f | 2007-01-21 22:26:41 -0800 | [diff] [blame] | 243 | return; |
| 244 | } |
| 245 | |
| 246 | /* |
| 247 | * Otherwise? It's there, it's unreachable, and some other unreachable |
| 248 | * object points to it. Ignore it - it's not interesting, and we showed |
| 249 | * all the interesting cases above. |
| 250 | */ |
| 251 | } |
| 252 | |
| 253 | static void check_object(struct object *obj) |
| 254 | { |
Johannes Schindelin | 20f1eb6 | 2007-06-05 03:44:00 +0100 | [diff] [blame] | 255 | if (verbose) |
| 256 | fprintf(stderr, "Checking %s\n", sha1_to_hex(obj->sha1)); |
| 257 | |
Linus Torvalds | 18af29f | 2007-01-21 22:26:41 -0800 | [diff] [blame] | 258 | if (obj->flags & REACHABLE) |
| 259 | check_reachable_object(obj); |
| 260 | else |
| 261 | check_unreachable_object(obj); |
| 262 | } |
Petr Baudis | f1f0d08 | 2005-09-20 20:56:05 +0200 | [diff] [blame] | 263 | |
Linus Torvalds | 8ba0bbb | 2005-04-10 23:13:09 -0700 | [diff] [blame] | 264 | static void check_connectivity(void) |
| 265 | { |
Linus Torvalds | fc046a7 | 2006-06-29 21:38:55 -0700 | [diff] [blame] | 266 | int i, max; |
Linus Torvalds | 8ba0bbb | 2005-04-10 23:13:09 -0700 | [diff] [blame] | 267 | |
Linus Torvalds | 04d3975 | 2008-12-10 19:44:37 -0800 | [diff] [blame] | 268 | /* Traverse the pending reachable objects */ |
| 269 | traverse_reachable(); |
| 270 | |
Linus Torvalds | 8ba0bbb | 2005-04-10 23:13:09 -0700 | [diff] [blame] | 271 | /* Look up all the requirements, warn about missing objects.. */ |
Linus Torvalds | fc046a7 | 2006-06-29 21:38:55 -0700 | [diff] [blame] | 272 | max = get_max_object_index(); |
Johannes Schindelin | 20f1eb6 | 2007-06-05 03:44:00 +0100 | [diff] [blame] | 273 | if (verbose) |
| 274 | fprintf(stderr, "Checking connectivity (%d objects)\n", max); |
| 275 | |
Linus Torvalds | fc046a7 | 2006-06-29 21:38:55 -0700 | [diff] [blame] | 276 | for (i = 0; i < max; i++) { |
Linus Torvalds | fc046a7 | 2006-06-29 21:38:55 -0700 | [diff] [blame] | 277 | struct object *obj = get_indexed_object(i); |
Linus Torvalds | 8ba0bbb | 2005-04-10 23:13:09 -0700 | [diff] [blame] | 278 | |
Linus Torvalds | 18af29f | 2007-01-21 22:26:41 -0800 | [diff] [blame] | 279 | if (obj) |
| 280 | check_object(obj); |
Linus Torvalds | 8ba0bbb | 2005-04-10 23:13:09 -0700 | [diff] [blame] | 281 | } |
| 282 | } |
| 283 | |
Nicolas Pitre | d72308e | 2007-04-04 16:49:04 -0400 | [diff] [blame] | 284 | static int fsck_sha1(const unsigned char *sha1) |
Linus Torvalds | 2022211 | 2005-04-08 15:02:42 -0700 | [diff] [blame] | 285 | { |
Linus Torvalds | 7e8c174 | 2005-05-02 09:06:33 -0700 | [diff] [blame] | 286 | struct object *obj = parse_object(sha1); |
Junio C Hamano | e2b4f63 | 2007-03-05 00:22:06 -0800 | [diff] [blame] | 287 | if (!obj) { |
| 288 | errors_found |= ERROR_OBJECT; |
| 289 | return error("%s: object corrupt or missing", |
| 290 | sha1_to_hex(sha1)); |
| 291 | } |
Linus Torvalds | 2d9c58c | 2006-05-29 12:18:33 -0700 | [diff] [blame] | 292 | if (obj->flags & SEEN) |
| 293 | return 0; |
| 294 | obj->flags |= SEEN; |
Junio C Hamano | e2b4f63 | 2007-03-05 00:22:06 -0800 | [diff] [blame] | 295 | |
Martin Koegler | ba002f3 | 2008-02-25 22:46:08 +0100 | [diff] [blame] | 296 | if (verbose) |
| 297 | fprintf(stderr, "Checking %s %s\n", |
| 298 | typename(obj->type), sha1_to_hex(obj->sha1)); |
| 299 | |
Linus Torvalds | 2af202b | 2009-06-18 10:28:43 -0700 | [diff] [blame] | 300 | if (fsck_walk(obj, mark_used, NULL)) |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 301 | objerror(obj, "broken links"); |
Martin Koegler | ba002f3 | 2008-02-25 22:46:08 +0100 | [diff] [blame] | 302 | if (fsck_object(obj, check_strict, fsck_error_func)) |
| 303 | return -1; |
Linus Torvalds | 7e8c174 | 2005-05-02 09:06:33 -0700 | [diff] [blame] | 304 | |
Martin Koegler | ba002f3 | 2008-02-25 22:46:08 +0100 | [diff] [blame] | 305 | if (obj->type == OBJ_TREE) { |
| 306 | struct tree *item = (struct tree *) obj; |
| 307 | |
| 308 | free(item->buffer); |
| 309 | item->buffer = NULL; |
| 310 | } |
| 311 | |
| 312 | if (obj->type == OBJ_COMMIT) { |
| 313 | struct commit *commit = (struct commit *) obj; |
| 314 | |
| 315 | free(commit->buffer); |
| 316 | commit->buffer = NULL; |
| 317 | |
| 318 | if (!commit->parents && show_root) |
| 319 | printf("root %s\n", sha1_to_hex(commit->object.sha1)); |
| 320 | } |
| 321 | |
| 322 | if (obj->type == OBJ_TAG) { |
| 323 | struct tag *tag = (struct tag *) obj; |
| 324 | |
| 325 | if (show_tags && tag->tagged) { |
| 326 | printf("tagged %s %s", typename(tag->tagged->type), sha1_to_hex(tag->tagged->sha1)); |
| 327 | printf(" (%s) in %s\n", tag->tag, sha1_to_hex(tag->object.sha1)); |
| 328 | } |
| 329 | } |
| 330 | |
| 331 | return 0; |
Linus Torvalds | 2022211 | 2005-04-08 15:02:42 -0700 | [diff] [blame] | 332 | } |
| 333 | |
Linus Torvalds | 7e8c174 | 2005-05-02 09:06:33 -0700 | [diff] [blame] | 334 | /* |
| 335 | * This is the sorting chunk size: make it reasonably |
| 336 | * big so that we can sort well.. |
| 337 | */ |
| 338 | #define MAX_SHA1_ENTRIES (1024) |
| 339 | |
| 340 | struct sha1_entry { |
| 341 | unsigned long ino; |
| 342 | unsigned char sha1[20]; |
| 343 | }; |
| 344 | |
| 345 | static struct { |
| 346 | unsigned long nr; |
| 347 | struct sha1_entry *entry[MAX_SHA1_ENTRIES]; |
| 348 | } sha1_list; |
| 349 | |
| 350 | static int ino_compare(const void *_a, const void *_b) |
| 351 | { |
| 352 | const struct sha1_entry *a = _a, *b = _b; |
| 353 | unsigned long ino1 = a->ino, ino2 = b->ino; |
| 354 | return ino1 < ino2 ? -1 : ino1 > ino2 ? 1 : 0; |
| 355 | } |
| 356 | |
| 357 | static void fsck_sha1_list(void) |
| 358 | { |
| 359 | int i, nr = sha1_list.nr; |
| 360 | |
Junio C Hamano | 35a730f | 2006-01-19 17:13:51 -0800 | [diff] [blame] | 361 | if (SORT_DIRENT) |
| 362 | qsort(sha1_list.entry, nr, |
| 363 | sizeof(struct sha1_entry *), ino_compare); |
Linus Torvalds | 7e8c174 | 2005-05-02 09:06:33 -0700 | [diff] [blame] | 364 | for (i = 0; i < nr; i++) { |
| 365 | struct sha1_entry *entry = sha1_list.entry[i]; |
| 366 | unsigned char *sha1 = entry->sha1; |
| 367 | |
| 368 | sha1_list.entry[i] = NULL; |
Petr Baudis | f1f0d08 | 2005-09-20 20:56:05 +0200 | [diff] [blame] | 369 | fsck_sha1(sha1); |
Linus Torvalds | 7e8c174 | 2005-05-02 09:06:33 -0700 | [diff] [blame] | 370 | free(entry); |
| 371 | } |
| 372 | sha1_list.nr = 0; |
| 373 | } |
| 374 | |
| 375 | static void add_sha1_list(unsigned char *sha1, unsigned long ino) |
| 376 | { |
| 377 | struct sha1_entry *entry = xmalloc(sizeof(*entry)); |
| 378 | int nr; |
| 379 | |
| 380 | entry->ino = ino; |
Shawn Pearce | e702496 | 2006-08-23 02:49:00 -0400 | [diff] [blame] | 381 | hashcpy(entry->sha1, sha1); |
Linus Torvalds | 7e8c174 | 2005-05-02 09:06:33 -0700 | [diff] [blame] | 382 | nr = sha1_list.nr; |
| 383 | if (nr == MAX_SHA1_ENTRIES) { |
| 384 | fsck_sha1_list(); |
| 385 | nr = 0; |
| 386 | } |
| 387 | sha1_list.entry[nr] = entry; |
| 388 | sha1_list.nr = ++nr; |
| 389 | } |
| 390 | |
Junio C Hamano | ea6f0a2 | 2011-01-26 13:01:54 -0800 | [diff] [blame] | 391 | static inline int is_loose_object_file(struct dirent *de, |
| 392 | char *name, unsigned char *sha1) |
| 393 | { |
| 394 | if (strlen(de->d_name) != 38) |
| 395 | return 0; |
| 396 | memcpy(name + 2, de->d_name, 39); |
| 397 | return !get_sha1_hex(name, sha1); |
| 398 | } |
| 399 | |
David Rientjes | b5524c8 | 2006-08-14 13:36:18 -0700 | [diff] [blame] | 400 | static void fsck_dir(int i, char *path) |
Linus Torvalds | 2022211 | 2005-04-08 15:02:42 -0700 | [diff] [blame] | 401 | { |
| 402 | DIR *dir = opendir(path); |
| 403 | struct dirent *de; |
Junio C Hamano | ea6f0a2 | 2011-01-26 13:01:54 -0800 | [diff] [blame] | 404 | char name[100]; |
Linus Torvalds | 2022211 | 2005-04-08 15:02:42 -0700 | [diff] [blame] | 405 | |
Linus Torvalds | 230f132 | 2005-10-08 15:54:01 -0700 | [diff] [blame] | 406 | if (!dir) |
David Rientjes | b5524c8 | 2006-08-14 13:36:18 -0700 | [diff] [blame] | 407 | return; |
Linus Torvalds | 2022211 | 2005-04-08 15:02:42 -0700 | [diff] [blame] | 408 | |
Johannes Schindelin | 20f1eb6 | 2007-06-05 03:44:00 +0100 | [diff] [blame] | 409 | if (verbose) |
| 410 | fprintf(stderr, "Checking directory %s\n", path); |
| 411 | |
Junio C Hamano | ea6f0a2 | 2011-01-26 13:01:54 -0800 | [diff] [blame] | 412 | sprintf(name, "%02x", i); |
Linus Torvalds | 2022211 | 2005-04-08 15:02:42 -0700 | [diff] [blame] | 413 | while ((de = readdir(dir)) != NULL) { |
Linus Torvalds | 7e8c174 | 2005-05-02 09:06:33 -0700 | [diff] [blame] | 414 | unsigned char sha1[20]; |
Linus Torvalds | 2022211 | 2005-04-08 15:02:42 -0700 | [diff] [blame] | 415 | |
Alexander Potashev | 8ca12c0 | 2009-01-10 15:07:50 +0300 | [diff] [blame] | 416 | if (is_dot_or_dotdot(de->d_name)) |
Linus Torvalds | 2022211 | 2005-04-08 15:02:42 -0700 | [diff] [blame] | 417 | continue; |
Junio C Hamano | ea6f0a2 | 2011-01-26 13:01:54 -0800 | [diff] [blame] | 418 | if (is_loose_object_file(de, name, sha1)) { |
Junio C Hamano | 35a730f | 2006-01-19 17:13:51 -0800 | [diff] [blame] | 419 | add_sha1_list(sha1, DIRENT_SORT_HINT(de)); |
Linus Torvalds | 7e8c174 | 2005-05-02 09:06:33 -0700 | [diff] [blame] | 420 | continue; |
Linus Torvalds | 2022211 | 2005-04-08 15:02:42 -0700 | [diff] [blame] | 421 | } |
Brandon Casey | 3d32a46 | 2008-08-05 13:01:50 -0500 | [diff] [blame] | 422 | if (!prefixcmp(de->d_name, "tmp_obj_")) |
Shawn O. Pearce | a08c53a | 2008-07-26 21:33:00 -0500 | [diff] [blame] | 423 | continue; |
Linus Torvalds | 2022211 | 2005-04-08 15:02:42 -0700 | [diff] [blame] | 424 | fprintf(stderr, "bad sha1 file: %s/%s\n", path, de->d_name); |
| 425 | } |
| 426 | closedir(dir); |
Linus Torvalds | 2022211 | 2005-04-08 15:02:42 -0700 | [diff] [blame] | 427 | } |
| 428 | |
David Rientjes | 96f1e58 | 2006-08-15 10:23:48 -0700 | [diff] [blame] | 429 | static int default_refs; |
Linus Torvalds | 944d858 | 2005-07-03 10:01:38 -0700 | [diff] [blame] | 430 | |
Johannes Schindelin | 883d60f | 2007-01-08 01:59:54 +0100 | [diff] [blame] | 431 | static int fsck_handle_reflog_ent(unsigned char *osha1, unsigned char *nsha1, |
| 432 | const char *email, unsigned long timestamp, int tz, |
| 433 | const char *message, void *cb_data) |
Junio C Hamano | 55dd552 | 2006-12-18 01:36:16 -0800 | [diff] [blame] | 434 | { |
| 435 | struct object *obj; |
| 436 | |
Johannes Schindelin | 20f1eb6 | 2007-06-05 03:44:00 +0100 | [diff] [blame] | 437 | if (verbose) |
| 438 | fprintf(stderr, "Checking reflog %s->%s\n", |
| 439 | sha1_to_hex(osha1), sha1_to_hex(nsha1)); |
| 440 | |
Junio C Hamano | 55dd552 | 2006-12-18 01:36:16 -0800 | [diff] [blame] | 441 | if (!is_null_sha1(osha1)) { |
| 442 | obj = lookup_object(osha1); |
| 443 | if (obj) { |
| 444 | obj->used = 1; |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 445 | mark_object_reachable(obj); |
Junio C Hamano | 55dd552 | 2006-12-18 01:36:16 -0800 | [diff] [blame] | 446 | } |
| 447 | } |
| 448 | obj = lookup_object(nsha1); |
| 449 | if (obj) { |
| 450 | obj->used = 1; |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 451 | mark_object_reachable(obj); |
Junio C Hamano | 55dd552 | 2006-12-18 01:36:16 -0800 | [diff] [blame] | 452 | } |
| 453 | return 0; |
| 454 | } |
| 455 | |
Nicolas Pitre | eb8381c | 2007-02-03 13:25:43 -0500 | [diff] [blame] | 456 | static int fsck_handle_reflog(const char *logname, const unsigned char *sha1, int flag, void *cb_data) |
| 457 | { |
| 458 | for_each_reflog_ent(logname, fsck_handle_reflog_ent, NULL); |
| 459 | return 0; |
| 460 | } |
| 461 | |
Linus Torvalds | 6232f62 | 2008-01-15 16:34:17 -0800 | [diff] [blame] | 462 | static int is_branch(const char *refname) |
| 463 | { |
| 464 | return !strcmp(refname, "HEAD") || !prefixcmp(refname, "refs/heads/"); |
| 465 | } |
| 466 | |
Junio C Hamano | 8da1977 | 2006-09-20 22:02:01 -0700 | [diff] [blame] | 467 | static int fsck_handle_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data) |
Linus Torvalds | 1024932 | 2005-05-18 10:16:14 -0700 | [diff] [blame] | 468 | { |
Linus Torvalds | 1024932 | 2005-05-18 10:16:14 -0700 | [diff] [blame] | 469 | struct object *obj; |
| 470 | |
Linus Torvalds | 6232f62 | 2008-01-15 16:34:17 -0800 | [diff] [blame] | 471 | obj = parse_object(sha1); |
Junio C Hamano | 8a498a0 | 2005-06-28 14:58:33 -0700 | [diff] [blame] | 472 | if (!obj) { |
Linus Torvalds | 944d858 | 2005-07-03 10:01:38 -0700 | [diff] [blame] | 473 | error("%s: invalid sha1 pointer %s", refname, sha1_to_hex(sha1)); |
| 474 | /* We'll continue with the rest despite the error.. */ |
| 475 | return 0; |
Junio C Hamano | 8a498a0 | 2005-06-28 14:58:33 -0700 | [diff] [blame] | 476 | } |
Linus Torvalds | 6232f62 | 2008-01-15 16:34:17 -0800 | [diff] [blame] | 477 | if (obj->type != OBJ_COMMIT && is_branch(refname)) |
| 478 | error("%s: not a commit", refname); |
Linus Torvalds | 944d858 | 2005-07-03 10:01:38 -0700 | [diff] [blame] | 479 | default_refs++; |
Linus Torvalds | 1024932 | 2005-05-18 10:16:14 -0700 | [diff] [blame] | 480 | obj->used = 1; |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 481 | mark_object_reachable(obj); |
Junio C Hamano | 55dd552 | 2006-12-18 01:36:16 -0800 | [diff] [blame] | 482 | |
Linus Torvalds | 7c4d07c | 2005-05-20 07:49:17 -0700 | [diff] [blame] | 483 | return 0; |
Linus Torvalds | 1024932 | 2005-05-18 10:16:14 -0700 | [diff] [blame] | 484 | } |
| 485 | |
Linus Torvalds | 1024932 | 2005-05-18 10:16:14 -0700 | [diff] [blame] | 486 | static void get_default_heads(void) |
| 487 | { |
Junio C Hamano | 469e2eb | 2009-01-30 00:33:00 -0800 | [diff] [blame] | 488 | if (head_points_at && !is_null_sha1(head_sha1)) |
| 489 | fsck_handle_ref("HEAD", head_sha1, 0, NULL); |
Junio C Hamano | cb5d709 | 2006-09-20 21:47:42 -0700 | [diff] [blame] | 490 | for_each_ref(fsck_handle_ref, NULL); |
Shawn O. Pearce | 566842f | 2007-04-04 10:46:14 -0400 | [diff] [blame] | 491 | if (include_reflogs) |
| 492 | for_each_reflog(fsck_handle_reflog, NULL); |
Linus Torvalds | 071fa89 | 2006-08-29 11:47:30 -0700 | [diff] [blame] | 493 | |
| 494 | /* |
| 495 | * Not having any default heads isn't really fatal, but |
| 496 | * it does mean that "--unreachable" no longer makes any |
| 497 | * sense (since in this case everything will obviously |
| 498 | * be unreachable by definition. |
| 499 | * |
| 500 | * Showing dangling objects is valid, though (as those |
| 501 | * dangling objects are likely lost heads). |
| 502 | * |
| 503 | * So we just print a warning about it, and clear the |
| 504 | * "show_unreachable" flag. |
| 505 | */ |
| 506 | if (!default_refs) { |
Junio C Hamano | 8eb2d0b | 2007-04-11 01:28:43 -0700 | [diff] [blame] | 507 | fprintf(stderr, "notice: No default references\n"); |
Linus Torvalds | 071fa89 | 2006-08-29 11:47:30 -0700 | [diff] [blame] | 508 | show_unreachable = 0; |
| 509 | } |
Linus Torvalds | 1024932 | 2005-05-18 10:16:14 -0700 | [diff] [blame] | 510 | } |
| 511 | |
Junio C Hamano | 8a498a0 | 2005-06-28 14:58:33 -0700 | [diff] [blame] | 512 | static void fsck_object_dir(const char *path) |
| 513 | { |
| 514 | int i; |
Johannes Schindelin | 20f1eb6 | 2007-06-05 03:44:00 +0100 | [diff] [blame] | 515 | |
| 516 | if (verbose) |
| 517 | fprintf(stderr, "Checking object directory\n"); |
| 518 | |
Junio C Hamano | 8a498a0 | 2005-06-28 14:58:33 -0700 | [diff] [blame] | 519 | for (i = 0; i < 256; i++) { |
| 520 | static char dir[4096]; |
| 521 | sprintf(dir, "%s/%02x", path, i); |
| 522 | fsck_dir(i, dir); |
| 523 | } |
| 524 | fsck_sha1_list(); |
| 525 | } |
| 526 | |
Linus Torvalds | c333038 | 2005-07-03 10:40:38 -0700 | [diff] [blame] | 527 | static int fsck_head_link(void) |
| 528 | { |
Junio C Hamano | 8da1977 | 2006-09-20 22:02:01 -0700 | [diff] [blame] | 529 | int flag; |
Junio C Hamano | 8eb2d0b | 2007-04-11 01:28:43 -0700 | [diff] [blame] | 530 | int null_is_error = 0; |
Linus Torvalds | c333038 | 2005-07-03 10:40:38 -0700 | [diff] [blame] | 531 | |
Johannes Schindelin | 20f1eb6 | 2007-06-05 03:44:00 +0100 | [diff] [blame] | 532 | if (verbose) |
| 533 | fprintf(stderr, "Checking HEAD link\n"); |
| 534 | |
Junio C Hamano | 469e2eb | 2009-01-30 00:33:00 -0800 | [diff] [blame] | 535 | head_points_at = resolve_ref("HEAD", head_sha1, 0, &flag); |
Junio C Hamano | 8eb2d0b | 2007-04-11 01:28:43 -0700 | [diff] [blame] | 536 | if (!head_points_at) |
| 537 | return error("Invalid HEAD"); |
| 538 | if (!strcmp(head_points_at, "HEAD")) |
| 539 | /* detached HEAD */ |
| 540 | null_is_error = 1; |
| 541 | else if (prefixcmp(head_points_at, "refs/heads/")) |
Junio C Hamano | 8098a17 | 2005-09-30 14:26:57 -0700 | [diff] [blame] | 542 | return error("HEAD points to something strange (%s)", |
Junio C Hamano | 5b10b09 | 2006-09-18 01:08:00 -0700 | [diff] [blame] | 543 | head_points_at); |
Junio C Hamano | 469e2eb | 2009-01-30 00:33:00 -0800 | [diff] [blame] | 544 | if (is_null_sha1(head_sha1)) { |
Junio C Hamano | 8eb2d0b | 2007-04-11 01:28:43 -0700 | [diff] [blame] | 545 | if (null_is_error) |
| 546 | return error("HEAD: detached HEAD points at nothing"); |
| 547 | fprintf(stderr, "notice: HEAD points to an unborn branch (%s)\n", |
| 548 | head_points_at + 11); |
| 549 | } |
Linus Torvalds | c333038 | 2005-07-03 10:40:38 -0700 | [diff] [blame] | 550 | return 0; |
| 551 | } |
| 552 | |
Junio C Hamano | 53dc3f3 | 2006-04-25 16:37:08 -0700 | [diff] [blame] | 553 | static int fsck_cache_tree(struct cache_tree *it) |
| 554 | { |
| 555 | int i; |
| 556 | int err = 0; |
| 557 | |
Johannes Schindelin | 20f1eb6 | 2007-06-05 03:44:00 +0100 | [diff] [blame] | 558 | if (verbose) |
| 559 | fprintf(stderr, "Checking cache tree\n"); |
| 560 | |
Junio C Hamano | 53dc3f3 | 2006-04-25 16:37:08 -0700 | [diff] [blame] | 561 | if (0 <= it->entry_count) { |
| 562 | struct object *obj = parse_object(it->sha1); |
Junio C Hamano | 6d60bbe | 2006-05-03 21:17:45 -0700 | [diff] [blame] | 563 | if (!obj) { |
| 564 | error("%s: invalid sha1 pointer in cache-tree", |
| 565 | sha1_to_hex(it->sha1)); |
| 566 | return 1; |
| 567 | } |
Junio C Hamano | cdc08b3 | 2006-05-01 22:15:54 -0700 | [diff] [blame] | 568 | obj->used = 1; |
Junio C Hamano | a1cdc25 | 2011-01-26 12:46:55 -0800 | [diff] [blame] | 569 | mark_object_reachable(obj); |
Linus Torvalds | 1974632 | 2006-07-11 20:45:31 -0700 | [diff] [blame] | 570 | if (obj->type != OBJ_TREE) |
Junio C Hamano | 53dc3f3 | 2006-04-25 16:37:08 -0700 | [diff] [blame] | 571 | err |= objerror(obj, "non-tree in cache-tree"); |
| 572 | } |
| 573 | for (i = 0; i < it->subtree_nr; i++) |
| 574 | err |= fsck_cache_tree(it->down[i]->cache_tree); |
| 575 | return err; |
| 576 | } |
| 577 | |
Pierre Habouzit | 5ac0a20 | 2007-10-15 22:34:05 +0200 | [diff] [blame] | 578 | static char const * const fsck_usage[] = { |
Stephan Beyer | 1b1dd23 | 2008-07-13 15:36:15 +0200 | [diff] [blame] | 579 | "git fsck [options] [<object>...]", |
Pierre Habouzit | 5ac0a20 | 2007-10-15 22:34:05 +0200 | [diff] [blame] | 580 | NULL |
| 581 | }; |
| 582 | |
| 583 | static struct option fsck_opts[] = { |
René Scharfe | fd03881 | 2010-11-08 18:56:39 +0100 | [diff] [blame] | 584 | OPT__VERBOSE(&verbose, "be verbose"), |
Pierre Habouzit | 5ac0a20 | 2007-10-15 22:34:05 +0200 | [diff] [blame] | 585 | OPT_BOOLEAN(0, "unreachable", &show_unreachable, "show unreachable objects"), |
| 586 | OPT_BOOLEAN(0, "tags", &show_tags, "report tags"), |
| 587 | OPT_BOOLEAN(0, "root", &show_root, "report root nodes"), |
| 588 | OPT_BOOLEAN(0, "cache", &keep_cache_objects, "make index objects head nodes"), |
| 589 | OPT_BOOLEAN(0, "reflogs", &include_reflogs, "make reflogs head nodes (default)"), |
Wesley J. Landaker | 2b26e0e | 2010-02-05 12:58:50 -0700 | [diff] [blame] | 590 | OPT_BOOLEAN(0, "full", &check_full, "also consider packs and alternate objects"), |
Emil Medve | dd46b9b | 2007-10-30 14:15:21 -0500 | [diff] [blame] | 591 | OPT_BOOLEAN(0, "strict", &check_strict, "enable more strict checking"), |
Pierre Habouzit | 5ac0a20 | 2007-10-15 22:34:05 +0200 | [diff] [blame] | 592 | OPT_BOOLEAN(0, "lost-found", &write_lost_and_found, |
| 593 | "write dangling objects in .git/lost-found"), |
| 594 | OPT_END(), |
| 595 | }; |
Junio C Hamano | e2b4f63 | 2007-03-05 00:22:06 -0800 | [diff] [blame] | 596 | |
Peter Hagervall | baffc0e | 2007-07-15 01:14:45 +0200 | [diff] [blame] | 597 | int cmd_fsck(int argc, const char **argv, const char *prefix) |
Linus Torvalds | 2022211 | 2005-04-08 15:02:42 -0700 | [diff] [blame] | 598 | { |
Linus Torvalds | bcee6fd | 2005-04-13 16:42:09 -0700 | [diff] [blame] | 599 | int i, heads; |
Junio C Hamano | e15ef66 | 2009-01-30 00:50:54 -0800 | [diff] [blame] | 600 | struct alternate_object_database *alt; |
Linus Torvalds | 2022211 | 2005-04-08 15:02:42 -0700 | [diff] [blame] | 601 | |
Junio C Hamano | e2b4f63 | 2007-03-05 00:22:06 -0800 | [diff] [blame] | 602 | errors_found = 0; |
Christian Couder | dae556b | 2009-01-23 10:07:46 +0100 | [diff] [blame] | 603 | read_replace_refs = 0; |
Junio C Hamano | 61e2b01 | 2005-11-25 23:52:04 -0800 | [diff] [blame] | 604 | |
Stephen Boyd | 3778292 | 2009-05-23 11:53:12 -0700 | [diff] [blame] | 605 | argc = parse_options(argc, argv, prefix, fsck_opts, fsck_usage, 0); |
Pierre Habouzit | 5ac0a20 | 2007-10-15 22:34:05 +0200 | [diff] [blame] | 606 | if (write_lost_and_found) { |
| 607 | check_full = 1; |
| 608 | include_reflogs = 0; |
Linus Torvalds | 889262e | 2005-04-25 16:31:13 -0700 | [diff] [blame] | 609 | } |
| 610 | |
Linus Torvalds | c333038 | 2005-07-03 10:40:38 -0700 | [diff] [blame] | 611 | fsck_head_link(); |
Junio C Hamano | 8a498a0 | 2005-06-28 14:58:33 -0700 | [diff] [blame] | 612 | fsck_object_dir(get_object_directory()); |
Junio C Hamano | e15ef66 | 2009-01-30 00:50:54 -0800 | [diff] [blame] | 613 | |
| 614 | prepare_alt_odb(); |
| 615 | for (alt = alt_odb_list; alt; alt = alt->next) { |
| 616 | char namebuf[PATH_MAX]; |
| 617 | int namelen = alt->name - alt->base; |
| 618 | memcpy(namebuf, alt->base, namelen); |
| 619 | namebuf[namelen - 1] = 0; |
| 620 | fsck_object_dir(namebuf); |
| 621 | } |
| 622 | |
Junio C Hamano | 8a498a0 | 2005-06-28 14:58:33 -0700 | [diff] [blame] | 623 | if (check_full) { |
Junio C Hamano | 8a498a0 | 2005-06-28 14:58:33 -0700 | [diff] [blame] | 624 | struct packed_git *p; |
Junio C Hamano | e15ef66 | 2009-01-30 00:50:54 -0800 | [diff] [blame] | 625 | |
Junio C Hamano | 8a498a0 | 2005-06-28 14:58:33 -0700 | [diff] [blame] | 626 | prepare_packed_git(); |
Junio C Hamano | f925339 | 2005-06-29 02:51:27 -0700 | [diff] [blame] | 627 | for (p = packed_git; p; p = p->next) |
| 628 | /* verify gives error messages itself */ |
Nicolas Pitre | 77d3ece | 2008-06-24 23:18:17 -0400 | [diff] [blame] | 629 | verify_pack(p); |
Junio C Hamano | f925339 | 2005-06-29 02:51:27 -0700 | [diff] [blame] | 630 | |
Junio C Hamano | 8a498a0 | 2005-06-28 14:58:33 -0700 | [diff] [blame] | 631 | for (p = packed_git; p; p = p->next) { |
Pierre Habouzit | 5ac0a20 | 2007-10-15 22:34:05 +0200 | [diff] [blame] | 632 | uint32_t j, num; |
Shawn O. Pearce | b77ffe8 | 2007-05-30 02:13:14 -0400 | [diff] [blame] | 633 | if (open_pack_index(p)) |
| 634 | continue; |
| 635 | num = p->num_objects; |
Pierre Habouzit | 5ac0a20 | 2007-10-15 22:34:05 +0200 | [diff] [blame] | 636 | for (j = 0; j < num; j++) |
| 637 | fsck_sha1(nth_packed_object_sha1(p, j)); |
Junio C Hamano | 8a498a0 | 2005-06-28 14:58:33 -0700 | [diff] [blame] | 638 | } |
Linus Torvalds | 2022211 | 2005-04-08 15:02:42 -0700 | [diff] [blame] | 639 | } |
Linus Torvalds | bcee6fd | 2005-04-13 16:42:09 -0700 | [diff] [blame] | 640 | |
| 641 | heads = 0; |
Christian Couder | 3aed2fd | 2009-01-18 04:46:09 +0100 | [diff] [blame] | 642 | for (i = 0; i < argc; i++) { |
Junio C Hamano | a6080a0 | 2007-06-07 00:04:01 -0700 | [diff] [blame] | 643 | const char *arg = argv[i]; |
Junio C Hamano | 469e2eb | 2009-01-30 00:33:00 -0800 | [diff] [blame] | 644 | unsigned char sha1[20]; |
| 645 | if (!get_sha1(arg, sha1)) { |
| 646 | struct object *obj = lookup_object(sha1); |
Jonas Fonseca | e1a1388 | 2005-04-29 20:00:40 -0700 | [diff] [blame] | 647 | |
Linus Torvalds | 770896e | 2005-05-04 17:03:09 -0700 | [diff] [blame] | 648 | /* Error is printed by lookup_object(). */ |
| 649 | if (!obj) |
Jonas Fonseca | e1a1388 | 2005-04-29 20:00:40 -0700 | [diff] [blame] | 650 | continue; |
| 651 | |
Daniel Barkalow | ff5ebe3 | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 652 | obj->used = 1; |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 653 | mark_object_reachable(obj); |
Linus Torvalds | bcee6fd | 2005-04-13 16:42:09 -0700 | [diff] [blame] | 654 | heads++; |
| 655 | continue; |
| 656 | } |
Petr Baudis | f1f0d08 | 2005-09-20 20:56:05 +0200 | [diff] [blame] | 657 | error("invalid parameter: expected sha1, got '%s'", arg); |
Linus Torvalds | bcee6fd | 2005-04-13 16:42:09 -0700 | [diff] [blame] | 658 | } |
| 659 | |
Linus Torvalds | 1024932 | 2005-05-18 10:16:14 -0700 | [diff] [blame] | 660 | /* |
Nicolas Pitre | d1af002 | 2005-05-20 16:59:17 -0400 | [diff] [blame] | 661 | * If we've not been given any explicit head information, do the |
Linus Torvalds | e7bd907 | 2005-05-18 10:19:59 -0700 | [diff] [blame] | 662 | * default ones from .git/refs. We also consider the index file |
| 663 | * in this case (ie this implies --cache). |
Linus Torvalds | 1024932 | 2005-05-18 10:16:14 -0700 | [diff] [blame] | 664 | */ |
Linus Torvalds | e7bd907 | 2005-05-18 10:19:59 -0700 | [diff] [blame] | 665 | if (!heads) { |
Linus Torvalds | 1024932 | 2005-05-18 10:16:14 -0700 | [diff] [blame] | 666 | get_default_heads(); |
| 667 | keep_cache_objects = 1; |
| 668 | } |
| 669 | |
Junio C Hamano | ae7c0c9 | 2005-05-04 01:33:33 -0700 | [diff] [blame] | 670 | if (keep_cache_objects) { |
Junio C Hamano | ae7c0c9 | 2005-05-04 01:33:33 -0700 | [diff] [blame] | 671 | read_cache(); |
| 672 | for (i = 0; i < active_nr; i++) { |
Linus Torvalds | 8d9721c | 2007-04-09 21:15:29 -0700 | [diff] [blame] | 673 | unsigned int mode; |
| 674 | struct blob *blob; |
Junio C Hamano | ae7c0c9 | 2005-05-04 01:33:33 -0700 | [diff] [blame] | 675 | struct object *obj; |
Linus Torvalds | 8d9721c | 2007-04-09 21:15:29 -0700 | [diff] [blame] | 676 | |
Linus Torvalds | 7a51ed6 | 2008-01-14 16:03:17 -0800 | [diff] [blame] | 677 | mode = active_cache[i]->ce_mode; |
Martin Waitz | 302b928 | 2007-05-21 22:08:28 +0200 | [diff] [blame] | 678 | if (S_ISGITLINK(mode)) |
Linus Torvalds | 8d9721c | 2007-04-09 21:15:29 -0700 | [diff] [blame] | 679 | continue; |
| 680 | blob = lookup_blob(active_cache[i]->sha1); |
Junio C Hamano | ae7c0c9 | 2005-05-04 01:33:33 -0700 | [diff] [blame] | 681 | if (!blob) |
| 682 | continue; |
| 683 | obj = &blob->object; |
| 684 | obj->used = 1; |
Martin Koegler | 271b8d2 | 2008-02-25 22:46:05 +0100 | [diff] [blame] | 685 | mark_object_reachable(obj); |
Junio C Hamano | ae7c0c9 | 2005-05-04 01:33:33 -0700 | [diff] [blame] | 686 | } |
Junio C Hamano | 53dc3f3 | 2006-04-25 16:37:08 -0700 | [diff] [blame] | 687 | if (active_cache_tree) |
| 688 | fsck_cache_tree(active_cache_tree); |
Junio C Hamano | ae7c0c9 | 2005-05-04 01:33:33 -0700 | [diff] [blame] | 689 | } |
| 690 | |
Linus Torvalds | 8ba0bbb | 2005-04-10 23:13:09 -0700 | [diff] [blame] | 691 | check_connectivity(); |
Junio C Hamano | e2b4f63 | 2007-03-05 00:22:06 -0800 | [diff] [blame] | 692 | return errors_found; |
Linus Torvalds | 2022211 | 2005-04-08 15:02:42 -0700 | [diff] [blame] | 693 | } |