15 static const char reflog_expire_usage
[] =
16 "git reflog expire [--verbose] [--dry-run] [--stale-fix] [--expire=<time>] [--expire-unreachable=<time>] [--all] <refs>...";
17 static const char reflog_delete_usage
[] =
18 "git reflog delete [--verbose] [--dry-run] [--rewrite] [--updateref] <refs>...";
20 static unsigned long default_reflog_expire
;
21 static unsigned long default_reflog_expire_unreachable
;
23 struct cmd_reflog_expire_cb
{
30 unsigned long expire_total
;
31 unsigned long expire_unreachable
;
35 struct expire_reflog_cb
{
41 } unreachable_expire_kind
;
42 struct commit_list
*mark_list
;
43 unsigned long mark_limit
;
44 struct cmd_reflog_expire_cb
*cmd
;
45 unsigned char last_kept_sha1
[20];
48 struct collected_reflog
{
49 unsigned char sha1
[20];
50 char reflog
[FLEX_ARRAY
];
52 struct collect_reflog_cb
{
53 struct collected_reflog
**e
;
58 #define INCOMPLETE (1u<<10)
59 #define STUDYING (1u<<11)
60 #define REACHABLE (1u<<12)
62 static int tree_is_complete(const unsigned char *sha1
)
64 struct tree_desc desc
;
65 struct name_entry entry
;
69 tree
= lookup_tree(sha1
);
72 if (tree
->object
.flags
& SEEN
)
74 if (tree
->object
.flags
& INCOMPLETE
)
78 enum object_type type
;
80 void *data
= read_sha1_file(sha1
, &type
, &size
);
82 tree
->object
.flags
|= INCOMPLETE
;
88 init_tree_desc(&desc
, tree
->buffer
, tree
->size
);
90 while (tree_entry(&desc
, &entry
)) {
91 if (!has_sha1_file(entry
.sha1
) ||
92 (S_ISDIR(entry
.mode
) && !tree_is_complete(entry
.sha1
))) {
93 tree
->object
.flags
|= INCOMPLETE
;
97 free_tree_buffer(tree
);
100 tree
->object
.flags
|= SEEN
;
104 static int commit_is_complete(struct commit
*commit
)
106 struct object_array study
;
107 struct object_array found
;
108 int is_incomplete
= 0;
112 if (commit
->object
.flags
& SEEN
)
114 if (commit
->object
.flags
& INCOMPLETE
)
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.
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
;
130 struct commit_list
*parent
;
132 c
= (struct commit
*)study
.objects
[--study
.nr
].item
;
133 if (!c
->object
.parsed
&& !parse_object(c
->object
.sha1
))
134 c
->object
.flags
|= INCOMPLETE
;
136 if (c
->object
.flags
& INCOMPLETE
) {
140 else if (c
->object
.flags
& SEEN
)
142 for (parent
= c
->parents
; parent
; parent
= parent
->next
) {
143 struct commit
*p
= parent
->item
;
144 if (p
->object
.flags
& STUDYING
)
146 p
->object
.flags
|= STUDYING
;
147 add_object_array(&p
->object
, NULL
, &study
);
148 add_object_array(&p
->object
, NULL
, &found
);
151 if (!is_incomplete
) {
153 * make sure all commits in "found" array have all the
156 for (i
= 0; i
< found
.nr
; i
++) {
158 (struct commit
*)found
.objects
[i
].item
;
159 if (!tree_is_complete(c
->tree
->object
.sha1
)) {
161 c
->object
.flags
|= INCOMPLETE
;
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
;
170 /* clear flags from the objects we traversed */
171 for (i
= 0; i
< found
.nr
; i
++)
172 found
.objects
[i
].item
->flags
&= ~STUDYING
;
174 commit
->object
.flags
|= INCOMPLETE
;
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.
184 for (i
= 0; i
< found
.nr
; i
++)
185 found
.objects
[i
].item
->flags
|= SEEN
;
187 /* free object arrays */
190 return !is_incomplete
;
193 static int keep_entry(struct commit
**it
, unsigned char *sha1
)
195 struct commit
*commit
;
197 if (is_null_sha1(sha1
))
199 commit
= lookup_commit_reference_gently(sha1
, 1);
204 * Make sure everything in this commit exists.
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
211 if (!commit_is_complete(commit
))
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.
223 static void mark_reachable(struct expire_reflog_cb
*cb
)
225 struct commit
*commit
;
226 struct commit_list
*pending
;
227 unsigned long expire_limit
= cb
->mark_limit
;
228 struct commit_list
*leftover
= NULL
;
230 for (pending
= cb
->mark_list
; pending
; pending
= pending
->next
)
231 pending
->item
->object
.flags
&= ~REACHABLE
;
233 pending
= cb
->mark_list
;
235 struct commit_list
*entry
= pending
;
236 struct commit_list
*parent
;
237 pending
= entry
->next
;
238 commit
= entry
->item
;
240 if (commit
->object
.flags
& REACHABLE
)
242 if (parse_commit(commit
))
244 commit
->object
.flags
|= REACHABLE
;
245 if (commit
->date
< expire_limit
) {
246 commit_list_insert(commit
, &leftover
);
249 commit
->object
.flags
|= REACHABLE
;
250 parent
= commit
->parents
;
252 commit
= parent
->item
;
253 parent
= parent
->next
;
254 if (commit
->object
.flags
& REACHABLE
)
256 commit_list_insert(commit
, &pending
);
259 cb
->mark_list
= leftover
;
262 static int unreachable(struct expire_reflog_cb
*cb
, struct commit
*commit
, unsigned char *sha1
)
265 * We may or may not have the commit yet - if not, look it
266 * up using the supplied sha1.
269 if (is_null_sha1(sha1
))
272 commit
= lookup_commit_reference_gently(sha1
, 1);
274 /* Not a commit -- keep it */
279 /* Reachable from the current ref? Don't prune. */
280 if (commit
->object
.flags
& REACHABLE
)
283 if (cb
->mark_list
&& cb
->mark_limit
) {
284 cb
->mark_limit
= 0; /* dig down to the root */
288 return !(commit
->object
.flags
& REACHABLE
);
291 static int expire_reflog_ent(unsigned char *osha1
, unsigned char *nsha1
,
292 const char *email
, unsigned long timestamp
, int tz
,
293 const char *message
, void *cb_data
)
295 struct expire_reflog_cb
*cb
= cb_data
;
296 struct commit
*old
, *new;
298 if (timestamp
< cb
->cmd
->expire_total
)
301 if (cb
->cmd
->rewrite
)
302 osha1
= cb
->last_kept_sha1
;
305 if (cb
->cmd
->stalefix
&&
306 (!keep_entry(&old
, osha1
) || !keep_entry(&new, nsha1
)))
309 if (timestamp
< cb
->cmd
->expire_unreachable
) {
310 if (cb
->unreachable_expire_kind
== UE_ALWAYS
)
312 if (unreachable(cb
, old
, osha1
) || unreachable(cb
, new, nsha1
))
316 if (cb
->cmd
->recno
&& --(cb
->cmd
->recno
) == 0)
320 char sign
= (tz
< 0) ? '-' : '+';
321 int zone
= (tz
< 0) ? (-tz
) : tz
;
322 fprintf(cb
->newlog
, "%s %s %s %lu %c%04d\t%s",
323 sha1_to_hex(osha1
), sha1_to_hex(nsha1
),
324 email
, timestamp
, sign
, zone
,
326 hashcpy(cb
->last_kept_sha1
, nsha1
);
328 if (cb
->cmd
->verbose
)
329 printf("keep %s", message
);
333 printf("would prune %s", message
);
334 else if (cb
->cmd
->verbose
)
335 printf("prune %s", message
);
339 static int push_tip_to_list(const char *refname
, const unsigned char *sha1
, int flags
, void *cb_data
)
341 struct commit_list
**list
= cb_data
;
342 struct commit
*tip_commit
;
343 if (flags
& REF_ISSYMREF
)
345 tip_commit
= lookup_commit_reference_gently(sha1
, 1);
348 commit_list_insert(tip_commit
, list
);
352 static int expire_reflog(const char *refname
, const unsigned char *sha1
,
353 struct cmd_reflog_expire_cb
*cmd
)
355 struct expire_reflog_cb cb
;
356 struct ref_lock
*lock
;
357 char *log_file
, *newlog_path
= NULL
;
358 struct commit
*tip_commit
;
359 struct commit_list
*tips
;
362 memset(&cb
, 0, sizeof(cb
));
365 * we take the lock for the ref itself to prevent it from
368 lock
= lock_any_ref_for_update(refname
, sha1
, 0, NULL
);
370 return error("cannot lock ref '%s'", refname
);
371 log_file
= git_pathdup("logs/%s", refname
);
372 if (!reflog_exists(refname
))
375 newlog_path
= git_pathdup("logs/%s.lock", refname
);
376 cb
.newlog
= fopen(newlog_path
, "w");
381 if (!cmd
->expire_unreachable
|| !strcmp(refname
, "HEAD")) {
383 cb
.unreachable_expire_kind
= UE_HEAD
;
385 tip_commit
= lookup_commit_reference_gently(sha1
, 1);
387 cb
.unreachable_expire_kind
= UE_ALWAYS
;
389 cb
.unreachable_expire_kind
= UE_NORMAL
;
392 if (cmd
->expire_unreachable
<= cmd
->expire_total
)
393 cb
.unreachable_expire_kind
= UE_ALWAYS
;
397 if (cb
.unreachable_expire_kind
!= UE_ALWAYS
) {
398 if (cb
.unreachable_expire_kind
== UE_HEAD
) {
399 struct commit_list
*elem
;
400 for_each_ref(push_tip_to_list
, &tips
);
401 for (elem
= tips
; elem
; elem
= elem
->next
)
402 commit_list_insert(elem
->item
, &cb
.mark_list
);
404 commit_list_insert(tip_commit
, &cb
.mark_list
);
406 cb
.mark_limit
= cmd
->expire_total
;
410 for_each_reflog_ent(refname
, expire_reflog_ent
, &cb
);
412 if (cb
.unreachable_expire_kind
!= UE_ALWAYS
) {
413 if (cb
.unreachable_expire_kind
== UE_HEAD
) {
414 struct commit_list
*elem
;
415 for (elem
= tips
; elem
; elem
= elem
->next
)
416 clear_commit_marks(elem
->item
, REACHABLE
);
417 free_commit_list(tips
);
419 clear_commit_marks(tip_commit
, REACHABLE
);
424 if (fclose(cb
.newlog
)) {
425 status
|= error("%s: %s", strerror(errno
),
428 } else if (cmd
->updateref
&&
429 (write_in_full(lock
->lock_fd
,
430 sha1_to_hex(cb
.last_kept_sha1
), 40) != 40 ||
431 write_str_in_full(lock
->lock_fd
, "\n") != 1 ||
432 close_ref(lock
) < 0)) {
433 status
|= error("Couldn't write %s",
434 lock
->lk
->filename
.buf
);
436 } else if (rename(newlog_path
, log_file
)) {
437 status
|= error("cannot rename %s to %s",
438 newlog_path
, log_file
);
440 } else if (cmd
->updateref
&& commit_ref(lock
)) {
441 status
|= error("Couldn't set %s", lock
->ref_name
);
443 adjust_shared_perm(log_file
);
452 static int collect_reflog(const char *ref
, const unsigned char *sha1
, int unused
, void *cb_data
)
454 struct collected_reflog
*e
;
455 struct collect_reflog_cb
*cb
= cb_data
;
456 size_t namelen
= strlen(ref
);
458 e
= xmalloc(sizeof(*e
) + namelen
+ 1);
459 hashcpy(e
->sha1
, sha1
);
460 memcpy(e
->reflog
, ref
, namelen
+ 1);
461 ALLOC_GROW(cb
->e
, cb
->nr
+ 1, cb
->alloc
);
466 static struct reflog_expire_cfg
{
467 struct reflog_expire_cfg
*next
;
468 unsigned long expire_total
;
469 unsigned long expire_unreachable
;
471 char pattern
[FLEX_ARRAY
];
472 } *reflog_expire_cfg
, **reflog_expire_cfg_tail
;
474 static struct reflog_expire_cfg
*find_cfg_ent(const char *pattern
, size_t len
)
476 struct reflog_expire_cfg
*ent
;
478 if (!reflog_expire_cfg_tail
)
479 reflog_expire_cfg_tail
= &reflog_expire_cfg
;
481 for (ent
= reflog_expire_cfg
; ent
; ent
= ent
->next
)
482 if (ent
->len
== len
&&
483 !memcmp(ent
->pattern
, pattern
, len
))
486 ent
= xcalloc(1, (sizeof(*ent
) + len
));
487 memcpy(ent
->pattern
, pattern
, len
);
489 *reflog_expire_cfg_tail
= ent
;
490 reflog_expire_cfg_tail
= &(ent
->next
);
494 static int parse_expire_cfg_value(const char *var
, const char *value
, unsigned long *expire
)
497 return config_error_nonbool(var
);
498 if (parse_expiry_date(value
, expire
))
499 return error(_("%s' for '%s' is not a valid timestamp"),
504 /* expiry timer slot */
505 #define EXPIRE_TOTAL 01
506 #define EXPIRE_UNREACH 02
508 static int reflog_expire_config(const char *var
, const char *value
, void *cb
)
510 const char *pattern
, *key
;
512 unsigned long expire
;
514 struct reflog_expire_cfg
*ent
;
516 if (parse_config_key(var
, "gc", &pattern
, &pattern_len
, &key
) < 0)
517 return git_default_config(var
, value
, cb
);
519 if (!strcmp(key
, "reflogexpire")) {
521 if (parse_expire_cfg_value(var
, value
, &expire
))
523 } else if (!strcmp(key
, "reflogexpireunreachable")) {
524 slot
= EXPIRE_UNREACH
;
525 if (parse_expire_cfg_value(var
, value
, &expire
))
528 return git_default_config(var
, value
, cb
);
533 default_reflog_expire
= expire
;
536 default_reflog_expire_unreachable
= expire
;
542 ent
= find_cfg_ent(pattern
, pattern_len
);
547 ent
->expire_total
= expire
;
550 ent
->expire_unreachable
= expire
;
556 static void set_reflog_expiry_param(struct cmd_reflog_expire_cb
*cb
, int slot
, const char *ref
)
558 struct reflog_expire_cfg
*ent
;
560 if (slot
== (EXPIRE_TOTAL
|EXPIRE_UNREACH
))
561 return; /* both given explicitly -- nothing to tweak */
563 for (ent
= reflog_expire_cfg
; ent
; ent
= ent
->next
) {
564 if (!wildmatch(ent
->pattern
, ref
, 0, NULL
)) {
565 if (!(slot
& EXPIRE_TOTAL
))
566 cb
->expire_total
= ent
->expire_total
;
567 if (!(slot
& EXPIRE_UNREACH
))
568 cb
->expire_unreachable
= ent
->expire_unreachable
;
574 * If unconfigured, make stash never expire
576 if (!strcmp(ref
, "refs/stash")) {
577 if (!(slot
& EXPIRE_TOTAL
))
578 cb
->expire_total
= 0;
579 if (!(slot
& EXPIRE_UNREACH
))
580 cb
->expire_unreachable
= 0;
584 /* Nothing matched -- use the default value */
585 if (!(slot
& EXPIRE_TOTAL
))
586 cb
->expire_total
= default_reflog_expire
;
587 if (!(slot
& EXPIRE_UNREACH
))
588 cb
->expire_unreachable
= default_reflog_expire_unreachable
;
591 static int cmd_reflog_expire(int argc
, const char **argv
, const char *prefix
)
593 struct cmd_reflog_expire_cb cb
;
594 unsigned long now
= time(NULL
);
595 int i
, status
, do_all
;
596 int explicit_expiry
= 0;
598 default_reflog_expire_unreachable
= now
- 30 * 24 * 3600;
599 default_reflog_expire
= now
- 90 * 24 * 3600;
600 git_config(reflog_expire_config
, NULL
);
602 save_commit_buffer
= 0;
604 memset(&cb
, 0, sizeof(cb
));
606 cb
.expire_total
= default_reflog_expire
;
607 cb
.expire_unreachable
= default_reflog_expire_unreachable
;
609 for (i
= 1; i
< argc
; i
++) {
610 const char *arg
= argv
[i
];
611 if (!strcmp(arg
, "--dry-run") || !strcmp(arg
, "-n"))
613 else if (starts_with(arg
, "--expire=")) {
614 if (parse_expiry_date(arg
+ 9, &cb
.expire_total
))
615 die(_("'%s' is not a valid timestamp"), arg
);
616 explicit_expiry
|= EXPIRE_TOTAL
;
618 else if (starts_with(arg
, "--expire-unreachable=")) {
619 if (parse_expiry_date(arg
+ 21, &cb
.expire_unreachable
))
620 die(_("'%s' is not a valid timestamp"), arg
);
621 explicit_expiry
|= EXPIRE_UNREACH
;
623 else if (!strcmp(arg
, "--stale-fix"))
625 else if (!strcmp(arg
, "--rewrite"))
627 else if (!strcmp(arg
, "--updateref"))
629 else if (!strcmp(arg
, "--all"))
631 else if (!strcmp(arg
, "--verbose"))
633 else if (!strcmp(arg
, "--")) {
637 else if (arg
[0] == '-')
638 usage(reflog_expire_usage
);
644 * We can trust the commits and objects reachable from refs
645 * even in older repository. We cannot trust what's reachable
646 * from reflog if the repository was pruned with older git.
649 init_revisions(&cb
.revs
, prefix
);
651 printf("Marking reachable objects...");
652 mark_reachable_objects(&cb
.revs
, 0, 0, NULL
);
658 struct collect_reflog_cb collected
;
661 memset(&collected
, 0, sizeof(collected
));
662 for_each_reflog(collect_reflog
, &collected
);
663 for (i
= 0; i
< collected
.nr
; i
++) {
664 struct collected_reflog
*e
= collected
.e
[i
];
665 set_reflog_expiry_param(&cb
, explicit_expiry
, e
->reflog
);
666 status
|= expire_reflog(e
->reflog
, e
->sha1
, &cb
);
672 for (; i
< argc
; i
++) {
674 unsigned char sha1
[20];
675 if (!dwim_log(argv
[i
], strlen(argv
[i
]), sha1
, &ref
)) {
676 status
|= error("%s points nowhere!", argv
[i
]);
679 set_reflog_expiry_param(&cb
, explicit_expiry
, ref
);
680 status
|= expire_reflog(ref
, sha1
, &cb
);
685 static int count_reflog_ent(unsigned char *osha1
, unsigned char *nsha1
,
686 const char *email
, unsigned long timestamp
, int tz
,
687 const char *message
, void *cb_data
)
689 struct cmd_reflog_expire_cb
*cb
= cb_data
;
690 if (!cb
->expire_total
|| timestamp
< cb
->expire_total
)
695 static int cmd_reflog_delete(int argc
, const char **argv
, const char *prefix
)
697 struct cmd_reflog_expire_cb cb
;
700 memset(&cb
, 0, sizeof(cb
));
702 for (i
= 1; i
< argc
; i
++) {
703 const char *arg
= argv
[i
];
704 if (!strcmp(arg
, "--dry-run") || !strcmp(arg
, "-n"))
706 else if (!strcmp(arg
, "--rewrite"))
708 else if (!strcmp(arg
, "--updateref"))
710 else if (!strcmp(arg
, "--verbose"))
712 else if (!strcmp(arg
, "--")) {
716 else if (arg
[0] == '-')
717 usage(reflog_delete_usage
);
723 return error("Nothing to delete?");
725 for ( ; i
< argc
; i
++) {
726 const char *spec
= strstr(argv
[i
], "@{");
727 unsigned char sha1
[20];
732 status
|= error("Not a reflog: %s", argv
[i
]);
736 if (!dwim_log(argv
[i
], spec
- argv
[i
], sha1
, &ref
)) {
737 status
|= error("no reflog for '%s'", argv
[i
]);
741 recno
= strtoul(spec
+ 2, &ep
, 10);
744 for_each_reflog_ent(ref
, count_reflog_ent
, &cb
);
746 cb
.expire_total
= approxidate(spec
+ 2);
747 for_each_reflog_ent(ref
, count_reflog_ent
, &cb
);
751 status
|= expire_reflog(ref
, sha1
, &cb
);
761 static const char reflog_usage
[] =
762 "git reflog [ show | expire | delete ]";
764 int cmd_reflog(int argc
, const char **argv
, const char *prefix
)
766 if (argc
> 1 && !strcmp(argv
[1], "-h"))
769 /* With no command, we default to showing it. */
770 if (argc
< 2 || *argv
[1] == '-')
771 return cmd_log_reflog(argc
, argv
, prefix
);
773 if (!strcmp(argv
[1], "show"))
774 return cmd_log_reflog(argc
- 1, argv
+ 1, prefix
);
776 if (!strcmp(argv
[1], "expire"))
777 return cmd_reflog_expire(argc
- 1, argv
+ 1, prefix
);
779 if (!strcmp(argv
[1], "delete"))
780 return cmd_reflog_delete(argc
- 1, argv
+ 1, prefix
);
782 return cmd_log_reflog(argc
, argv
, prefix
);