commit: add repository argument to lookup_commit_reference_gently
[git/git.git] / builtin / reflog.c
1 #include "builtin.h"
2 #include "config.h"
3 #include "lockfile.h"
4 #include "object-store.h"
5 #include "repository.h"
6 #include "commit.h"
7 #include "refs.h"
8 #include "dir.h"
9 #include "tree-walk.h"
10 #include "diff.h"
11 #include "revision.h"
12 #include "reachable.h"
13
14 /* NEEDSWORK: switch to using parse_options */
15 static const char reflog_expire_usage[] =
16 "git reflog expire [--expire=<time>] [--expire-unreachable=<time>] [--rewrite] [--updateref] [--stale-fix] [--dry-run | -n] [--verbose] [--all] <refs>...";
17 static const char reflog_delete_usage[] =
18 "git reflog delete [--rewrite] [--updateref] [--dry-run | -n] [--verbose] <refs>...";
19 static const char reflog_exists_usage[] =
20 "git reflog exists <ref>";
21
22 static timestamp_t default_reflog_expire;
23 static timestamp_t default_reflog_expire_unreachable;
24
25 struct cmd_reflog_expire_cb {
26 struct rev_info revs;
27 int stalefix;
28 timestamp_t expire_total;
29 timestamp_t expire_unreachable;
30 int recno;
31 };
32
33 struct expire_reflog_policy_cb {
34 enum {
35 UE_NORMAL,
36 UE_ALWAYS,
37 UE_HEAD
38 } unreachable_expire_kind;
39 struct commit_list *mark_list;
40 unsigned long mark_limit;
41 struct cmd_reflog_expire_cb cmd;
42 struct commit *tip_commit;
43 struct commit_list *tips;
44 };
45
46 struct collected_reflog {
47 struct object_id oid;
48 char reflog[FLEX_ARRAY];
49 };
50
51 struct collect_reflog_cb {
52 struct collected_reflog **e;
53 int alloc;
54 int nr;
55 };
56
57 /* Remember to update object flag allocation in object.h */
58 #define INCOMPLETE (1u<<10)
59 #define STUDYING (1u<<11)
60 #define REACHABLE (1u<<12)
61
62 static int tree_is_complete(const struct object_id *oid)
63 {
64 struct tree_desc desc;
65 struct name_entry entry;
66 int complete;
67 struct tree *tree;
68
69 tree = lookup_tree(the_repository, oid);
70 if (!tree)
71 return 0;
72 if (tree->object.flags & SEEN)
73 return 1;
74 if (tree->object.flags & INCOMPLETE)
75 return 0;
76
77 if (!tree->buffer) {
78 enum object_type type;
79 unsigned long size;
80 void *data = read_object_file(oid, &type, &size);
81 if (!data) {
82 tree->object.flags |= INCOMPLETE;
83 return 0;
84 }
85 tree->buffer = data;
86 tree->size = size;
87 }
88 init_tree_desc(&desc, tree->buffer, tree->size);
89 complete = 1;
90 while (tree_entry(&desc, &entry)) {
91 if (!has_sha1_file(entry.oid->hash) ||
92 (S_ISDIR(entry.mode) && !tree_is_complete(entry.oid))) {
93 tree->object.flags |= INCOMPLETE;
94 complete = 0;
95 }
96 }
97 free_tree_buffer(tree);
98
99 if (complete)
100 tree->object.flags |= SEEN;
101 return complete;
102 }
103
104 static int commit_is_complete(struct commit *commit)
105 {
106 struct object_array study;
107 struct object_array found;
108 int is_incomplete = 0;
109 int i;
110
111 /* early return */
112 if (commit->object.flags & SEEN)
113 return 1;
114 if (commit->object.flags & INCOMPLETE)
115 return 0;
116 /*
117 * Find all commits that are reachable and are not marked as
118 * SEEN. Then make sure the trees and blobs contained are
119 * complete. After that, mark these commits also as SEEN.
120 * If some of the objects that are needed to complete this
121 * commit are missing, mark this commit as INCOMPLETE.
122 */
123 memset(&study, 0, sizeof(study));
124 memset(&found, 0, sizeof(found));
125 add_object_array(&commit->object, NULL, &study);
126 add_object_array(&commit->object, NULL, &found);
127 commit->object.flags |= STUDYING;
128 while (study.nr) {
129 struct commit *c;
130 struct commit_list *parent;
131
132 c = (struct commit *)object_array_pop(&study);
133 if (!c->object.parsed && !parse_object(the_repository, &c->object.oid))
134 c->object.flags |= INCOMPLETE;
135
136 if (c->object.flags & INCOMPLETE) {
137 is_incomplete = 1;
138 break;
139 }
140 else if (c->object.flags & SEEN)
141 continue;
142 for (parent = c->parents; parent; parent = parent->next) {
143 struct commit *p = parent->item;
144 if (p->object.flags & STUDYING)
145 continue;
146 p->object.flags |= STUDYING;
147 add_object_array(&p->object, NULL, &study);
148 add_object_array(&p->object, NULL, &found);
149 }
150 }
151 if (!is_incomplete) {
152 /*
153 * make sure all commits in "found" array have all the
154 * necessary objects.
155 */
156 for (i = 0; i < found.nr; i++) {
157 struct commit *c =
158 (struct commit *)found.objects[i].item;
159 if (!tree_is_complete(get_commit_tree_oid(c))) {
160 is_incomplete = 1;
161 c->object.flags |= INCOMPLETE;
162 }
163 }
164 if (!is_incomplete) {
165 /* mark all found commits as complete, iow SEEN */
166 for (i = 0; i < found.nr; i++)
167 found.objects[i].item->flags |= SEEN;
168 }
169 }
170 /* clear flags from the objects we traversed */
171 for (i = 0; i < found.nr; i++)
172 found.objects[i].item->flags &= ~STUDYING;
173 if (is_incomplete)
174 commit->object.flags |= INCOMPLETE;
175 else {
176 /*
177 * If we come here, we have (1) traversed the ancestry chain
178 * from the "commit" until we reach SEEN commits (which are
179 * known to be complete), and (2) made sure that the commits
180 * encountered during the above traversal refer to trees that
181 * are complete. Which means that we know *all* the commits
182 * we have seen during this process are complete.
183 */
184 for (i = 0; i < found.nr; i++)
185 found.objects[i].item->flags |= SEEN;
186 }
187 /* free object arrays */
188 object_array_clear(&study);
189 object_array_clear(&found);
190 return !is_incomplete;
191 }
192
193 static int keep_entry(struct commit **it, struct object_id *oid)
194 {
195 struct commit *commit;
196
197 if (is_null_oid(oid))
198 return 1;
199 commit = lookup_commit_reference_gently(the_repository, oid, 1);
200 if (!commit)
201 return 0;
202
203 /*
204 * Make sure everything in this commit exists.
205 *
206 * We have walked all the objects reachable from the refs
207 * and cache earlier. The commits reachable by this commit
208 * must meet SEEN commits -- and then we should mark them as
209 * SEEN as well.
210 */
211 if (!commit_is_complete(commit))
212 return 0;
213 *it = commit;
214 return 1;
215 }
216
217 /*
218 * Starting from commits in the cb->mark_list, mark commits that are
219 * reachable from them. Stop the traversal at commits older than
220 * the expire_limit and queue them back, so that the caller can call
221 * us again to restart the traversal with longer expire_limit.
222 */
223 static void mark_reachable(struct expire_reflog_policy_cb *cb)
224 {
225 struct commit_list *pending;
226 timestamp_t expire_limit = cb->mark_limit;
227 struct commit_list *leftover = NULL;
228
229 for (pending = cb->mark_list; pending; pending = pending->next)
230 pending->item->object.flags &= ~REACHABLE;
231
232 pending = cb->mark_list;
233 while (pending) {
234 struct commit_list *parent;
235 struct commit *commit = pop_commit(&pending);
236 if (commit->object.flags & REACHABLE)
237 continue;
238 if (parse_commit(commit))
239 continue;
240 commit->object.flags |= REACHABLE;
241 if (commit->date < expire_limit) {
242 commit_list_insert(commit, &leftover);
243 continue;
244 }
245 commit->object.flags |= REACHABLE;
246 parent = commit->parents;
247 while (parent) {
248 commit = parent->item;
249 parent = parent->next;
250 if (commit->object.flags & REACHABLE)
251 continue;
252 commit_list_insert(commit, &pending);
253 }
254 }
255 cb->mark_list = leftover;
256 }
257
258 static int unreachable(struct expire_reflog_policy_cb *cb, struct commit *commit, struct object_id *oid)
259 {
260 /*
261 * We may or may not have the commit yet - if not, look it
262 * up using the supplied sha1.
263 */
264 if (!commit) {
265 if (is_null_oid(oid))
266 return 0;
267
268 commit = lookup_commit_reference_gently(the_repository, oid,
269 1);
270
271 /* Not a commit -- keep it */
272 if (!commit)
273 return 0;
274 }
275
276 /* Reachable from the current ref? Don't prune. */
277 if (commit->object.flags & REACHABLE)
278 return 0;
279
280 if (cb->mark_list && cb->mark_limit) {
281 cb->mark_limit = 0; /* dig down to the root */
282 mark_reachable(cb);
283 }
284
285 return !(commit->object.flags & REACHABLE);
286 }
287
288 /*
289 * Return true iff the specified reflog entry should be expired.
290 */
291 static int should_expire_reflog_ent(struct object_id *ooid, struct object_id *noid,
292 const char *email, timestamp_t timestamp, int tz,
293 const char *message, void *cb_data)
294 {
295 struct expire_reflog_policy_cb *cb = cb_data;
296 struct commit *old_commit, *new_commit;
297
298 if (timestamp < cb->cmd.expire_total)
299 return 1;
300
301 old_commit = new_commit = NULL;
302 if (cb->cmd.stalefix &&
303 (!keep_entry(&old_commit, ooid) || !keep_entry(&new_commit, noid)))
304 return 1;
305
306 if (timestamp < cb->cmd.expire_unreachable) {
307 if (cb->unreachable_expire_kind == UE_ALWAYS)
308 return 1;
309 if (unreachable(cb, old_commit, ooid) || unreachable(cb, new_commit, noid))
310 return 1;
311 }
312
313 if (cb->cmd.recno && --(cb->cmd.recno) == 0)
314 return 1;
315
316 return 0;
317 }
318
319 static int push_tip_to_list(const char *refname, const struct object_id *oid,
320 int flags, void *cb_data)
321 {
322 struct commit_list **list = cb_data;
323 struct commit *tip_commit;
324 if (flags & REF_ISSYMREF)
325 return 0;
326 tip_commit = lookup_commit_reference_gently(the_repository, oid, 1);
327 if (!tip_commit)
328 return 0;
329 commit_list_insert(tip_commit, list);
330 return 0;
331 }
332
333 static void reflog_expiry_prepare(const char *refname,
334 const struct object_id *oid,
335 void *cb_data)
336 {
337 struct expire_reflog_policy_cb *cb = cb_data;
338
339 if (!cb->cmd.expire_unreachable || !strcmp(refname, "HEAD")) {
340 cb->tip_commit = NULL;
341 cb->unreachable_expire_kind = UE_HEAD;
342 } else {
343 cb->tip_commit = lookup_commit_reference_gently(the_repository,
344 oid, 1);
345 if (!cb->tip_commit)
346 cb->unreachable_expire_kind = UE_ALWAYS;
347 else
348 cb->unreachable_expire_kind = UE_NORMAL;
349 }
350
351 if (cb->cmd.expire_unreachable <= cb->cmd.expire_total)
352 cb->unreachable_expire_kind = UE_ALWAYS;
353
354 cb->mark_list = NULL;
355 cb->tips = NULL;
356 if (cb->unreachable_expire_kind != UE_ALWAYS) {
357 if (cb->unreachable_expire_kind == UE_HEAD) {
358 struct commit_list *elem;
359
360 for_each_ref(push_tip_to_list, &cb->tips);
361 for (elem = cb->tips; elem; elem = elem->next)
362 commit_list_insert(elem->item, &cb->mark_list);
363 } else {
364 commit_list_insert(cb->tip_commit, &cb->mark_list);
365 }
366 cb->mark_limit = cb->cmd.expire_total;
367 mark_reachable(cb);
368 }
369 }
370
371 static void reflog_expiry_cleanup(void *cb_data)
372 {
373 struct expire_reflog_policy_cb *cb = cb_data;
374
375 if (cb->unreachable_expire_kind != UE_ALWAYS) {
376 if (cb->unreachable_expire_kind == UE_HEAD) {
377 struct commit_list *elem;
378 for (elem = cb->tips; elem; elem = elem->next)
379 clear_commit_marks(elem->item, REACHABLE);
380 free_commit_list(cb->tips);
381 } else {
382 clear_commit_marks(cb->tip_commit, REACHABLE);
383 }
384 }
385 }
386
387 static int collect_reflog(const char *ref, const struct object_id *oid, int unused, void *cb_data)
388 {
389 struct collected_reflog *e;
390 struct collect_reflog_cb *cb = cb_data;
391
392 FLEX_ALLOC_STR(e, reflog, ref);
393 oidcpy(&e->oid, oid);
394 ALLOC_GROW(cb->e, cb->nr + 1, cb->alloc);
395 cb->e[cb->nr++] = e;
396 return 0;
397 }
398
399 static struct reflog_expire_cfg {
400 struct reflog_expire_cfg *next;
401 timestamp_t expire_total;
402 timestamp_t expire_unreachable;
403 char pattern[FLEX_ARRAY];
404 } *reflog_expire_cfg, **reflog_expire_cfg_tail;
405
406 static struct reflog_expire_cfg *find_cfg_ent(const char *pattern, size_t len)
407 {
408 struct reflog_expire_cfg *ent;
409
410 if (!reflog_expire_cfg_tail)
411 reflog_expire_cfg_tail = &reflog_expire_cfg;
412
413 for (ent = reflog_expire_cfg; ent; ent = ent->next)
414 if (!strncmp(ent->pattern, pattern, len) &&
415 ent->pattern[len] == '\0')
416 return ent;
417
418 FLEX_ALLOC_MEM(ent, pattern, pattern, len);
419 *reflog_expire_cfg_tail = ent;
420 reflog_expire_cfg_tail = &(ent->next);
421 return ent;
422 }
423
424 /* expiry timer slot */
425 #define EXPIRE_TOTAL 01
426 #define EXPIRE_UNREACH 02
427
428 static int reflog_expire_config(const char *var, const char *value, void *cb)
429 {
430 const char *pattern, *key;
431 int pattern_len;
432 timestamp_t expire;
433 int slot;
434 struct reflog_expire_cfg *ent;
435
436 if (parse_config_key(var, "gc", &pattern, &pattern_len, &key) < 0)
437 return git_default_config(var, value, cb);
438
439 if (!strcmp(key, "reflogexpire")) {
440 slot = EXPIRE_TOTAL;
441 if (git_config_expiry_date(&expire, var, value))
442 return -1;
443 } else if (!strcmp(key, "reflogexpireunreachable")) {
444 slot = EXPIRE_UNREACH;
445 if (git_config_expiry_date(&expire, var, value))
446 return -1;
447 } else
448 return git_default_config(var, value, cb);
449
450 if (!pattern) {
451 switch (slot) {
452 case EXPIRE_TOTAL:
453 default_reflog_expire = expire;
454 break;
455 case EXPIRE_UNREACH:
456 default_reflog_expire_unreachable = expire;
457 break;
458 }
459 return 0;
460 }
461
462 ent = find_cfg_ent(pattern, pattern_len);
463 if (!ent)
464 return -1;
465 switch (slot) {
466 case EXPIRE_TOTAL:
467 ent->expire_total = expire;
468 break;
469 case EXPIRE_UNREACH:
470 ent->expire_unreachable = expire;
471 break;
472 }
473 return 0;
474 }
475
476 static void set_reflog_expiry_param(struct cmd_reflog_expire_cb *cb, int slot, const char *ref)
477 {
478 struct reflog_expire_cfg *ent;
479
480 if (slot == (EXPIRE_TOTAL|EXPIRE_UNREACH))
481 return; /* both given explicitly -- nothing to tweak */
482
483 for (ent = reflog_expire_cfg; ent; ent = ent->next) {
484 if (!wildmatch(ent->pattern, ref, 0)) {
485 if (!(slot & EXPIRE_TOTAL))
486 cb->expire_total = ent->expire_total;
487 if (!(slot & EXPIRE_UNREACH))
488 cb->expire_unreachable = ent->expire_unreachable;
489 return;
490 }
491 }
492
493 /*
494 * If unconfigured, make stash never expire
495 */
496 if (!strcmp(ref, "refs/stash")) {
497 if (!(slot & EXPIRE_TOTAL))
498 cb->expire_total = 0;
499 if (!(slot & EXPIRE_UNREACH))
500 cb->expire_unreachable = 0;
501 return;
502 }
503
504 /* Nothing matched -- use the default value */
505 if (!(slot & EXPIRE_TOTAL))
506 cb->expire_total = default_reflog_expire;
507 if (!(slot & EXPIRE_UNREACH))
508 cb->expire_unreachable = default_reflog_expire_unreachable;
509 }
510
511 static int cmd_reflog_expire(int argc, const char **argv, const char *prefix)
512 {
513 struct expire_reflog_policy_cb cb;
514 timestamp_t now = time(NULL);
515 int i, status, do_all;
516 int explicit_expiry = 0;
517 unsigned int flags = 0;
518
519 default_reflog_expire_unreachable = now - 30 * 24 * 3600;
520 default_reflog_expire = now - 90 * 24 * 3600;
521 git_config(reflog_expire_config, NULL);
522
523 save_commit_buffer = 0;
524 do_all = status = 0;
525 memset(&cb, 0, sizeof(cb));
526
527 cb.cmd.expire_total = default_reflog_expire;
528 cb.cmd.expire_unreachable = default_reflog_expire_unreachable;
529
530 for (i = 1; i < argc; i++) {
531 const char *arg = argv[i];
532 if (!strcmp(arg, "--dry-run") || !strcmp(arg, "-n"))
533 flags |= EXPIRE_REFLOGS_DRY_RUN;
534 else if (starts_with(arg, "--expire=")) {
535 if (parse_expiry_date(arg + 9, &cb.cmd.expire_total))
536 die(_("'%s' is not a valid timestamp"), arg);
537 explicit_expiry |= EXPIRE_TOTAL;
538 }
539 else if (starts_with(arg, "--expire-unreachable=")) {
540 if (parse_expiry_date(arg + 21, &cb.cmd.expire_unreachable))
541 die(_("'%s' is not a valid timestamp"), arg);
542 explicit_expiry |= EXPIRE_UNREACH;
543 }
544 else if (!strcmp(arg, "--stale-fix"))
545 cb.cmd.stalefix = 1;
546 else if (!strcmp(arg, "--rewrite"))
547 flags |= EXPIRE_REFLOGS_REWRITE;
548 else if (!strcmp(arg, "--updateref"))
549 flags |= EXPIRE_REFLOGS_UPDATE_REF;
550 else if (!strcmp(arg, "--all"))
551 do_all = 1;
552 else if (!strcmp(arg, "--verbose"))
553 flags |= EXPIRE_REFLOGS_VERBOSE;
554 else if (!strcmp(arg, "--")) {
555 i++;
556 break;
557 }
558 else if (arg[0] == '-')
559 usage(reflog_expire_usage);
560 else
561 break;
562 }
563
564 /*
565 * We can trust the commits and objects reachable from refs
566 * even in older repository. We cannot trust what's reachable
567 * from reflog if the repository was pruned with older git.
568 */
569 if (cb.cmd.stalefix) {
570 init_revisions(&cb.cmd.revs, prefix);
571 if (flags & EXPIRE_REFLOGS_VERBOSE)
572 printf("Marking reachable objects...");
573 mark_reachable_objects(&cb.cmd.revs, 0, 0, NULL);
574 if (flags & EXPIRE_REFLOGS_VERBOSE)
575 putchar('\n');
576 }
577
578 if (do_all) {
579 struct collect_reflog_cb collected;
580 int i;
581
582 memset(&collected, 0, sizeof(collected));
583 for_each_reflog(collect_reflog, &collected);
584 for (i = 0; i < collected.nr; i++) {
585 struct collected_reflog *e = collected.e[i];
586 set_reflog_expiry_param(&cb.cmd, explicit_expiry, e->reflog);
587 status |= reflog_expire(e->reflog, &e->oid, flags,
588 reflog_expiry_prepare,
589 should_expire_reflog_ent,
590 reflog_expiry_cleanup,
591 &cb);
592 free(e);
593 }
594 free(collected.e);
595 }
596
597 for (; i < argc; i++) {
598 char *ref;
599 struct object_id oid;
600 if (!dwim_log(argv[i], strlen(argv[i]), &oid, &ref)) {
601 status |= error("%s points nowhere!", argv[i]);
602 continue;
603 }
604 set_reflog_expiry_param(&cb.cmd, explicit_expiry, ref);
605 status |= reflog_expire(ref, &oid, flags,
606 reflog_expiry_prepare,
607 should_expire_reflog_ent,
608 reflog_expiry_cleanup,
609 &cb);
610 }
611 return status;
612 }
613
614 static int count_reflog_ent(struct object_id *ooid, struct object_id *noid,
615 const char *email, timestamp_t timestamp, int tz,
616 const char *message, void *cb_data)
617 {
618 struct expire_reflog_policy_cb *cb = cb_data;
619 if (!cb->cmd.expire_total || timestamp < cb->cmd.expire_total)
620 cb->cmd.recno++;
621 return 0;
622 }
623
624 static int cmd_reflog_delete(int argc, const char **argv, const char *prefix)
625 {
626 struct expire_reflog_policy_cb cb;
627 int i, status = 0;
628 unsigned int flags = 0;
629
630 memset(&cb, 0, sizeof(cb));
631
632 for (i = 1; i < argc; i++) {
633 const char *arg = argv[i];
634 if (!strcmp(arg, "--dry-run") || !strcmp(arg, "-n"))
635 flags |= EXPIRE_REFLOGS_DRY_RUN;
636 else if (!strcmp(arg, "--rewrite"))
637 flags |= EXPIRE_REFLOGS_REWRITE;
638 else if (!strcmp(arg, "--updateref"))
639 flags |= EXPIRE_REFLOGS_UPDATE_REF;
640 else if (!strcmp(arg, "--verbose"))
641 flags |= EXPIRE_REFLOGS_VERBOSE;
642 else if (!strcmp(arg, "--")) {
643 i++;
644 break;
645 }
646 else if (arg[0] == '-')
647 usage(reflog_delete_usage);
648 else
649 break;
650 }
651
652 if (argc - i < 1)
653 return error("Nothing to delete?");
654
655 for ( ; i < argc; i++) {
656 const char *spec = strstr(argv[i], "@{");
657 struct object_id oid;
658 char *ep, *ref;
659 int recno;
660
661 if (!spec) {
662 status |= error("Not a reflog: %s", argv[i]);
663 continue;
664 }
665
666 if (!dwim_log(argv[i], spec - argv[i], &oid, &ref)) {
667 status |= error("no reflog for '%s'", argv[i]);
668 continue;
669 }
670
671 recno = strtoul(spec + 2, &ep, 10);
672 if (*ep == '}') {
673 cb.cmd.recno = -recno;
674 for_each_reflog_ent(ref, count_reflog_ent, &cb);
675 } else {
676 cb.cmd.expire_total = approxidate(spec + 2);
677 for_each_reflog_ent(ref, count_reflog_ent, &cb);
678 cb.cmd.expire_total = 0;
679 }
680
681 status |= reflog_expire(ref, &oid, flags,
682 reflog_expiry_prepare,
683 should_expire_reflog_ent,
684 reflog_expiry_cleanup,
685 &cb);
686 free(ref);
687 }
688 return status;
689 }
690
691 static int cmd_reflog_exists(int argc, const char **argv, const char *prefix)
692 {
693 int i, start = 0;
694
695 for (i = 1; i < argc; i++) {
696 const char *arg = argv[i];
697 if (!strcmp(arg, "--")) {
698 i++;
699 break;
700 }
701 else if (arg[0] == '-')
702 usage(reflog_exists_usage);
703 else
704 break;
705 }
706
707 start = i;
708
709 if (argc - start != 1)
710 usage(reflog_exists_usage);
711
712 if (check_refname_format(argv[start], REFNAME_ALLOW_ONELEVEL))
713 die("invalid ref format: %s", argv[start]);
714 return !reflog_exists(argv[start]);
715 }
716
717 /*
718 * main "reflog"
719 */
720
721 static const char reflog_usage[] =
722 "git reflog [ show | expire | delete | exists ]";
723
724 int cmd_reflog(int argc, const char **argv, const char *prefix)
725 {
726 if (argc > 1 && !strcmp(argv[1], "-h"))
727 usage(reflog_usage);
728
729 /* With no command, we default to showing it. */
730 if (argc < 2 || *argv[1] == '-')
731 return cmd_log_reflog(argc, argv, prefix);
732
733 if (!strcmp(argv[1], "show"))
734 return cmd_log_reflog(argc - 1, argv + 1, prefix);
735
736 if (!strcmp(argv[1], "expire"))
737 return cmd_reflog_expire(argc - 1, argv + 1, prefix);
738
739 if (!strcmp(argv[1], "delete"))
740 return cmd_reflog_delete(argc - 1, argv + 1, prefix);
741
742 if (!strcmp(argv[1], "exists"))
743 return cmd_reflog_exists(argc - 1, argv + 1, prefix);
744
745 return cmd_log_reflog(argc, argv, prefix);
746 }