11 /* NEEDSWORK: switch to using parse_options */
12 static const char reflog_expire_usage
[] =
13 "git reflog expire [--expire=<time>] [--expire-unreachable=<time>] [--rewrite] [--updateref] [--stale-fix] [--dry-run | -n] [--verbose] [--all] <refs>...";
14 static const char reflog_delete_usage
[] =
15 "git reflog delete [--rewrite] [--updateref] [--dry-run | -n] [--verbose] <refs>...";
16 static const char reflog_exists_usage
[] =
17 "git reflog exists <ref>";
19 static unsigned long default_reflog_expire
;
20 static unsigned long default_reflog_expire_unreachable
;
22 struct cmd_reflog_expire_cb
{
25 unsigned long expire_total
;
26 unsigned long expire_unreachable
;
30 struct expire_reflog_policy_cb
{
35 } unreachable_expire_kind
;
36 struct commit_list
*mark_list
;
37 unsigned long mark_limit
;
38 struct cmd_reflog_expire_cb cmd
;
39 struct commit
*tip_commit
;
40 struct commit_list
*tips
;
43 struct collected_reflog
{
44 unsigned char sha1
[20];
45 char reflog
[FLEX_ARRAY
];
48 struct collect_reflog_cb
{
49 struct collected_reflog
**e
;
54 #define INCOMPLETE (1u<<10)
55 #define STUDYING (1u<<11)
56 #define REACHABLE (1u<<12)
58 static int tree_is_complete(const unsigned char *sha1
)
60 struct tree_desc desc
;
61 struct name_entry entry
;
65 tree
= lookup_tree(sha1
);
68 if (tree
->object
.flags
& SEEN
)
70 if (tree
->object
.flags
& INCOMPLETE
)
74 enum object_type type
;
76 void *data
= read_sha1_file(sha1
, &type
, &size
);
78 tree
->object
.flags
|= INCOMPLETE
;
84 init_tree_desc(&desc
, tree
->buffer
, tree
->size
);
86 while (tree_entry(&desc
, &entry
)) {
87 if (!has_sha1_file(entry
.sha1
) ||
88 (S_ISDIR(entry
.mode
) && !tree_is_complete(entry
.sha1
))) {
89 tree
->object
.flags
|= INCOMPLETE
;
93 free_tree_buffer(tree
);
96 tree
->object
.flags
|= SEEN
;
100 static int commit_is_complete(struct commit
*commit
)
102 struct object_array study
;
103 struct object_array found
;
104 int is_incomplete
= 0;
108 if (commit
->object
.flags
& SEEN
)
110 if (commit
->object
.flags
& INCOMPLETE
)
113 * Find all commits that are reachable and are not marked as
114 * SEEN. Then make sure the trees and blobs contained are
115 * complete. After that, mark these commits also as SEEN.
116 * If some of the objects that are needed to complete this
117 * commit are missing, mark this commit as INCOMPLETE.
119 memset(&study
, 0, sizeof(study
));
120 memset(&found
, 0, sizeof(found
));
121 add_object_array(&commit
->object
, NULL
, &study
);
122 add_object_array(&commit
->object
, NULL
, &found
);
123 commit
->object
.flags
|= STUDYING
;
126 struct commit_list
*parent
;
128 c
= (struct commit
*)study
.objects
[--study
.nr
].item
;
129 if (!c
->object
.parsed
&& !parse_object(c
->object
.oid
.hash
))
130 c
->object
.flags
|= INCOMPLETE
;
132 if (c
->object
.flags
& INCOMPLETE
) {
136 else if (c
->object
.flags
& SEEN
)
138 for (parent
= c
->parents
; parent
; parent
= parent
->next
) {
139 struct commit
*p
= parent
->item
;
140 if (p
->object
.flags
& STUDYING
)
142 p
->object
.flags
|= STUDYING
;
143 add_object_array(&p
->object
, NULL
, &study
);
144 add_object_array(&p
->object
, NULL
, &found
);
147 if (!is_incomplete
) {
149 * make sure all commits in "found" array have all the
152 for (i
= 0; i
< found
.nr
; i
++) {
154 (struct commit
*)found
.objects
[i
].item
;
155 if (!tree_is_complete(c
->tree
->object
.oid
.hash
)) {
157 c
->object
.flags
|= INCOMPLETE
;
160 if (!is_incomplete
) {
161 /* mark all found commits as complete, iow SEEN */
162 for (i
= 0; i
< found
.nr
; i
++)
163 found
.objects
[i
].item
->flags
|= SEEN
;
166 /* clear flags from the objects we traversed */
167 for (i
= 0; i
< found
.nr
; i
++)
168 found
.objects
[i
].item
->flags
&= ~STUDYING
;
170 commit
->object
.flags
|= INCOMPLETE
;
173 * If we come here, we have (1) traversed the ancestry chain
174 * from the "commit" until we reach SEEN commits (which are
175 * known to be complete), and (2) made sure that the commits
176 * encountered during the above traversal refer to trees that
177 * are complete. Which means that we know *all* the commits
178 * we have seen during this process are complete.
180 for (i
= 0; i
< found
.nr
; i
++)
181 found
.objects
[i
].item
->flags
|= SEEN
;
183 /* free object arrays */
186 return !is_incomplete
;
189 static int keep_entry(struct commit
**it
, unsigned char *sha1
)
191 struct commit
*commit
;
193 if (is_null_sha1(sha1
))
195 commit
= lookup_commit_reference_gently(sha1
, 1);
200 * Make sure everything in this commit exists.
202 * We have walked all the objects reachable from the refs
203 * and cache earlier. The commits reachable by this commit
204 * must meet SEEN commits -- and then we should mark them as
207 if (!commit_is_complete(commit
))
214 * Starting from commits in the cb->mark_list, mark commits that are
215 * reachable from them. Stop the traversal at commits older than
216 * the expire_limit and queue them back, so that the caller can call
217 * us again to restart the traversal with longer expire_limit.
219 static void mark_reachable(struct expire_reflog_policy_cb
*cb
)
221 struct commit_list
*pending
;
222 unsigned long expire_limit
= cb
->mark_limit
;
223 struct commit_list
*leftover
= NULL
;
225 for (pending
= cb
->mark_list
; pending
; pending
= pending
->next
)
226 pending
->item
->object
.flags
&= ~REACHABLE
;
228 pending
= cb
->mark_list
;
230 struct commit_list
*parent
;
231 struct commit
*commit
= pop_commit(&pending
);
232 if (commit
->object
.flags
& REACHABLE
)
234 if (parse_commit(commit
))
236 commit
->object
.flags
|= REACHABLE
;
237 if (commit
->date
< expire_limit
) {
238 commit_list_insert(commit
, &leftover
);
241 commit
->object
.flags
|= REACHABLE
;
242 parent
= commit
->parents
;
244 commit
= parent
->item
;
245 parent
= parent
->next
;
246 if (commit
->object
.flags
& REACHABLE
)
248 commit_list_insert(commit
, &pending
);
251 cb
->mark_list
= leftover
;
254 static int unreachable(struct expire_reflog_policy_cb
*cb
, struct commit
*commit
, unsigned char *sha1
)
257 * We may or may not have the commit yet - if not, look it
258 * up using the supplied sha1.
261 if (is_null_sha1(sha1
))
264 commit
= lookup_commit_reference_gently(sha1
, 1);
266 /* Not a commit -- keep it */
271 /* Reachable from the current ref? Don't prune. */
272 if (commit
->object
.flags
& REACHABLE
)
275 if (cb
->mark_list
&& cb
->mark_limit
) {
276 cb
->mark_limit
= 0; /* dig down to the root */
280 return !(commit
->object
.flags
& REACHABLE
);
284 * Return true iff the specified reflog entry should be expired.
286 static int should_expire_reflog_ent(unsigned char *osha1
, unsigned char *nsha1
,
287 const char *email
, unsigned long timestamp
, int tz
,
288 const char *message
, void *cb_data
)
290 struct expire_reflog_policy_cb
*cb
= cb_data
;
291 struct commit
*old
, *new;
293 if (timestamp
< cb
->cmd
.expire_total
)
297 if (cb
->cmd
.stalefix
&&
298 (!keep_entry(&old
, osha1
) || !keep_entry(&new, nsha1
)))
301 if (timestamp
< cb
->cmd
.expire_unreachable
) {
302 if (cb
->unreachable_expire_kind
== UE_ALWAYS
)
304 if (unreachable(cb
, old
, osha1
) || unreachable(cb
, new, nsha1
))
308 if (cb
->cmd
.recno
&& --(cb
->cmd
.recno
) == 0)
314 static int push_tip_to_list(const char *refname
, const struct object_id
*oid
,
315 int flags
, void *cb_data
)
317 struct commit_list
**list
= cb_data
;
318 struct commit
*tip_commit
;
319 if (flags
& REF_ISSYMREF
)
321 tip_commit
= lookup_commit_reference_gently(oid
->hash
, 1);
324 commit_list_insert(tip_commit
, list
);
328 static void reflog_expiry_prepare(const char *refname
,
329 const unsigned char *sha1
,
332 struct expire_reflog_policy_cb
*cb
= cb_data
;
334 if (!cb
->cmd
.expire_unreachable
|| !strcmp(refname
, "HEAD")) {
335 cb
->tip_commit
= NULL
;
336 cb
->unreachable_expire_kind
= UE_HEAD
;
338 cb
->tip_commit
= lookup_commit_reference_gently(sha1
, 1);
340 cb
->unreachable_expire_kind
= UE_ALWAYS
;
342 cb
->unreachable_expire_kind
= UE_NORMAL
;
345 if (cb
->cmd
.expire_unreachable
<= cb
->cmd
.expire_total
)
346 cb
->unreachable_expire_kind
= UE_ALWAYS
;
348 cb
->mark_list
= NULL
;
350 if (cb
->unreachable_expire_kind
!= UE_ALWAYS
) {
351 if (cb
->unreachable_expire_kind
== UE_HEAD
) {
352 struct commit_list
*elem
;
354 for_each_ref(push_tip_to_list
, &cb
->tips
);
355 for (elem
= cb
->tips
; elem
; elem
= elem
->next
)
356 commit_list_insert(elem
->item
, &cb
->mark_list
);
358 commit_list_insert(cb
->tip_commit
, &cb
->mark_list
);
360 cb
->mark_limit
= cb
->cmd
.expire_total
;
365 static void reflog_expiry_cleanup(void *cb_data
)
367 struct expire_reflog_policy_cb
*cb
= cb_data
;
369 if (cb
->unreachable_expire_kind
!= UE_ALWAYS
) {
370 if (cb
->unreachable_expire_kind
== UE_HEAD
) {
371 struct commit_list
*elem
;
372 for (elem
= cb
->tips
; elem
; elem
= elem
->next
)
373 clear_commit_marks(elem
->item
, REACHABLE
);
374 free_commit_list(cb
->tips
);
376 clear_commit_marks(cb
->tip_commit
, REACHABLE
);
381 static int collect_reflog(const char *ref
, const struct object_id
*oid
, int unused
, void *cb_data
)
383 struct collected_reflog
*e
;
384 struct collect_reflog_cb
*cb
= cb_data
;
385 size_t namelen
= strlen(ref
);
387 e
= xmalloc(sizeof(*e
) + namelen
+ 1);
388 hashcpy(e
->sha1
, oid
->hash
);
389 memcpy(e
->reflog
, ref
, namelen
+ 1);
390 ALLOC_GROW(cb
->e
, cb
->nr
+ 1, cb
->alloc
);
395 static struct reflog_expire_cfg
{
396 struct reflog_expire_cfg
*next
;
397 unsigned long expire_total
;
398 unsigned long expire_unreachable
;
399 char pattern
[FLEX_ARRAY
];
400 } *reflog_expire_cfg
, **reflog_expire_cfg_tail
;
402 static struct reflog_expire_cfg
*find_cfg_ent(const char *pattern
, size_t len
)
404 struct reflog_expire_cfg
*ent
;
406 if (!reflog_expire_cfg_tail
)
407 reflog_expire_cfg_tail
= &reflog_expire_cfg
;
409 for (ent
= reflog_expire_cfg
; ent
; ent
= ent
->next
)
410 if (!strncmp(ent
->pattern
, pattern
, len
) &&
411 ent
->pattern
[len
] == '\0')
414 ent
= xcalloc(1, sizeof(*ent
) + len
+ 1);
415 memcpy(ent
->pattern
, pattern
, len
);
416 *reflog_expire_cfg_tail
= ent
;
417 reflog_expire_cfg_tail
= &(ent
->next
);
421 static int parse_expire_cfg_value(const char *var
, const char *value
, unsigned long *expire
)
424 return config_error_nonbool(var
);
425 if (parse_expiry_date(value
, expire
))
426 return error(_("'%s' for '%s' is not a valid timestamp"),
431 /* expiry timer slot */
432 #define EXPIRE_TOTAL 01
433 #define EXPIRE_UNREACH 02
435 static int reflog_expire_config(const char *var
, const char *value
, void *cb
)
437 const char *pattern
, *key
;
439 unsigned long expire
;
441 struct reflog_expire_cfg
*ent
;
443 if (parse_config_key(var
, "gc", &pattern
, &pattern_len
, &key
) < 0)
444 return git_default_config(var
, value
, cb
);
446 if (!strcmp(key
, "reflogexpire")) {
448 if (parse_expire_cfg_value(var
, value
, &expire
))
450 } else if (!strcmp(key
, "reflogexpireunreachable")) {
451 slot
= EXPIRE_UNREACH
;
452 if (parse_expire_cfg_value(var
, value
, &expire
))
455 return git_default_config(var
, value
, cb
);
460 default_reflog_expire
= expire
;
463 default_reflog_expire_unreachable
= expire
;
469 ent
= find_cfg_ent(pattern
, pattern_len
);
474 ent
->expire_total
= expire
;
477 ent
->expire_unreachable
= expire
;
483 static void set_reflog_expiry_param(struct cmd_reflog_expire_cb
*cb
, int slot
, const char *ref
)
485 struct reflog_expire_cfg
*ent
;
487 if (slot
== (EXPIRE_TOTAL
|EXPIRE_UNREACH
))
488 return; /* both given explicitly -- nothing to tweak */
490 for (ent
= reflog_expire_cfg
; ent
; ent
= ent
->next
) {
491 if (!wildmatch(ent
->pattern
, ref
, 0, NULL
)) {
492 if (!(slot
& EXPIRE_TOTAL
))
493 cb
->expire_total
= ent
->expire_total
;
494 if (!(slot
& EXPIRE_UNREACH
))
495 cb
->expire_unreachable
= ent
->expire_unreachable
;
501 * If unconfigured, make stash never expire
503 if (!strcmp(ref
, "refs/stash")) {
504 if (!(slot
& EXPIRE_TOTAL
))
505 cb
->expire_total
= 0;
506 if (!(slot
& EXPIRE_UNREACH
))
507 cb
->expire_unreachable
= 0;
511 /* Nothing matched -- use the default value */
512 if (!(slot
& EXPIRE_TOTAL
))
513 cb
->expire_total
= default_reflog_expire
;
514 if (!(slot
& EXPIRE_UNREACH
))
515 cb
->expire_unreachable
= default_reflog_expire_unreachable
;
518 static int cmd_reflog_expire(int argc
, const char **argv
, const char *prefix
)
520 struct expire_reflog_policy_cb cb
;
521 unsigned long now
= time(NULL
);
522 int i
, status
, do_all
;
523 int explicit_expiry
= 0;
524 unsigned int flags
= 0;
526 default_reflog_expire_unreachable
= now
- 30 * 24 * 3600;
527 default_reflog_expire
= now
- 90 * 24 * 3600;
528 git_config(reflog_expire_config
, NULL
);
530 save_commit_buffer
= 0;
532 memset(&cb
, 0, sizeof(cb
));
534 cb
.cmd
.expire_total
= default_reflog_expire
;
535 cb
.cmd
.expire_unreachable
= default_reflog_expire_unreachable
;
537 for (i
= 1; i
< argc
; i
++) {
538 const char *arg
= argv
[i
];
539 if (!strcmp(arg
, "--dry-run") || !strcmp(arg
, "-n"))
540 flags
|= EXPIRE_REFLOGS_DRY_RUN
;
541 else if (starts_with(arg
, "--expire=")) {
542 if (parse_expiry_date(arg
+ 9, &cb
.cmd
.expire_total
))
543 die(_("'%s' is not a valid timestamp"), arg
);
544 explicit_expiry
|= EXPIRE_TOTAL
;
546 else if (starts_with(arg
, "--expire-unreachable=")) {
547 if (parse_expiry_date(arg
+ 21, &cb
.cmd
.expire_unreachable
))
548 die(_("'%s' is not a valid timestamp"), arg
);
549 explicit_expiry
|= EXPIRE_UNREACH
;
551 else if (!strcmp(arg
, "--stale-fix"))
553 else if (!strcmp(arg
, "--rewrite"))
554 flags
|= EXPIRE_REFLOGS_REWRITE
;
555 else if (!strcmp(arg
, "--updateref"))
556 flags
|= EXPIRE_REFLOGS_UPDATE_REF
;
557 else if (!strcmp(arg
, "--all"))
559 else if (!strcmp(arg
, "--verbose"))
560 flags
|= EXPIRE_REFLOGS_VERBOSE
;
561 else if (!strcmp(arg
, "--")) {
565 else if (arg
[0] == '-')
566 usage(reflog_expire_usage
);
572 * We can trust the commits and objects reachable from refs
573 * even in older repository. We cannot trust what's reachable
574 * from reflog if the repository was pruned with older git.
576 if (cb
.cmd
.stalefix
) {
577 init_revisions(&cb
.cmd
.revs
, prefix
);
578 if (flags
& EXPIRE_REFLOGS_VERBOSE
)
579 printf("Marking reachable objects...");
580 mark_reachable_objects(&cb
.cmd
.revs
, 0, 0, NULL
);
581 if (flags
& EXPIRE_REFLOGS_VERBOSE
)
586 struct collect_reflog_cb collected
;
589 memset(&collected
, 0, sizeof(collected
));
590 for_each_reflog(collect_reflog
, &collected
);
591 for (i
= 0; i
< collected
.nr
; i
++) {
592 struct collected_reflog
*e
= collected
.e
[i
];
593 set_reflog_expiry_param(&cb
.cmd
, explicit_expiry
, e
->reflog
);
594 status
|= reflog_expire(e
->reflog
, e
->sha1
, flags
,
595 reflog_expiry_prepare
,
596 should_expire_reflog_ent
,
597 reflog_expiry_cleanup
,
604 for (; i
< argc
; i
++) {
606 unsigned char sha1
[20];
607 if (!dwim_log(argv
[i
], strlen(argv
[i
]), sha1
, &ref
)) {
608 status
|= error("%s points nowhere!", argv
[i
]);
611 set_reflog_expiry_param(&cb
.cmd
, explicit_expiry
, ref
);
612 status
|= reflog_expire(ref
, sha1
, flags
,
613 reflog_expiry_prepare
,
614 should_expire_reflog_ent
,
615 reflog_expiry_cleanup
,
621 static int count_reflog_ent(unsigned char *osha1
, unsigned char *nsha1
,
622 const char *email
, unsigned long timestamp
, int tz
,
623 const char *message
, void *cb_data
)
625 struct expire_reflog_policy_cb
*cb
= cb_data
;
626 if (!cb
->cmd
.expire_total
|| timestamp
< cb
->cmd
.expire_total
)
631 static int cmd_reflog_delete(int argc
, const char **argv
, const char *prefix
)
633 struct expire_reflog_policy_cb cb
;
635 unsigned int flags
= 0;
637 memset(&cb
, 0, sizeof(cb
));
639 for (i
= 1; i
< argc
; i
++) {
640 const char *arg
= argv
[i
];
641 if (!strcmp(arg
, "--dry-run") || !strcmp(arg
, "-n"))
642 flags
|= EXPIRE_REFLOGS_DRY_RUN
;
643 else if (!strcmp(arg
, "--rewrite"))
644 flags
|= EXPIRE_REFLOGS_REWRITE
;
645 else if (!strcmp(arg
, "--updateref"))
646 flags
|= EXPIRE_REFLOGS_UPDATE_REF
;
647 else if (!strcmp(arg
, "--verbose"))
648 flags
|= EXPIRE_REFLOGS_VERBOSE
;
649 else if (!strcmp(arg
, "--")) {
653 else if (arg
[0] == '-')
654 usage(reflog_delete_usage
);
660 return error("Nothing to delete?");
662 for ( ; i
< argc
; i
++) {
663 const char *spec
= strstr(argv
[i
], "@{");
664 unsigned char sha1
[20];
669 status
|= error("Not a reflog: %s", argv
[i
]);
673 if (!dwim_log(argv
[i
], spec
- argv
[i
], sha1
, &ref
)) {
674 status
|= error("no reflog for '%s'", argv
[i
]);
678 recno
= strtoul(spec
+ 2, &ep
, 10);
680 cb
.cmd
.recno
= -recno
;
681 for_each_reflog_ent(ref
, count_reflog_ent
, &cb
);
683 cb
.cmd
.expire_total
= approxidate(spec
+ 2);
684 for_each_reflog_ent(ref
, count_reflog_ent
, &cb
);
685 cb
.cmd
.expire_total
= 0;
688 status
|= reflog_expire(ref
, sha1
, flags
,
689 reflog_expiry_prepare
,
690 should_expire_reflog_ent
,
691 reflog_expiry_cleanup
,
698 static int cmd_reflog_exists(int argc
, const char **argv
, const char *prefix
)
702 for (i
= 1; i
< argc
; i
++) {
703 const char *arg
= argv
[i
];
704 if (!strcmp(arg
, "--")) {
708 else if (arg
[0] == '-')
709 usage(reflog_exists_usage
);
716 if (argc
- start
!= 1)
717 usage(reflog_exists_usage
);
719 if (check_refname_format(argv
[start
], REFNAME_ALLOW_ONELEVEL
))
720 die("invalid ref format: %s", argv
[start
]);
721 return !reflog_exists(argv
[start
]);
728 static const char reflog_usage
[] =
729 "git reflog [ show | expire | delete | exists ]";
731 int cmd_reflog(int argc
, const char **argv
, const char *prefix
)
733 if (argc
> 1 && !strcmp(argv
[1], "-h"))
736 /* With no command, we default to showing it. */
737 if (argc
< 2 || *argv
[1] == '-')
738 return cmd_log_reflog(argc
, argv
, prefix
);
740 if (!strcmp(argv
[1], "show"))
741 return cmd_log_reflog(argc
- 1, argv
+ 1, prefix
);
743 if (!strcmp(argv
[1], "expire"))
744 return cmd_reflog_expire(argc
- 1, argv
+ 1, prefix
);
746 if (!strcmp(argv
[1], "delete"))
747 return cmd_reflog_delete(argc
- 1, argv
+ 1, prefix
);
749 if (!strcmp(argv
[1], "exists"))
750 return cmd_reflog_exists(argc
- 1, argv
+ 1, prefix
);
752 return cmd_log_reflog(argc
, argv
, prefix
);