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
;
101 tree
->object
.flags
|= SEEN
;
105 static int commit_is_complete(struct commit
*commit
)
107 struct object_array study
;
108 struct object_array found
;
109 int is_incomplete
= 0;
113 if (commit
->object
.flags
& SEEN
)
115 if (commit
->object
.flags
& INCOMPLETE
)
118 * Find all commits that are reachable and are not marked as
119 * SEEN. Then make sure the trees and blobs contained are
120 * complete. After that, mark these commits also as SEEN.
121 * If some of the objects that are needed to complete this
122 * commit are missing, mark this commit as INCOMPLETE.
124 memset(&study
, 0, sizeof(study
));
125 memset(&found
, 0, sizeof(found
));
126 add_object_array(&commit
->object
, NULL
, &study
);
127 add_object_array(&commit
->object
, NULL
, &found
);
128 commit
->object
.flags
|= STUDYING
;
131 struct commit_list
*parent
;
133 c
= (struct commit
*)study
.objects
[--study
.nr
].item
;
134 if (!c
->object
.parsed
&& !parse_object(c
->object
.sha1
))
135 c
->object
.flags
|= INCOMPLETE
;
137 if (c
->object
.flags
& INCOMPLETE
) {
141 else if (c
->object
.flags
& SEEN
)
143 for (parent
= c
->parents
; parent
; parent
= parent
->next
) {
144 struct commit
*p
= parent
->item
;
145 if (p
->object
.flags
& STUDYING
)
147 p
->object
.flags
|= STUDYING
;
148 add_object_array(&p
->object
, NULL
, &study
);
149 add_object_array(&p
->object
, NULL
, &found
);
152 if (!is_incomplete
) {
154 * make sure all commits in "found" array have all the
157 for (i
= 0; i
< found
.nr
; i
++) {
159 (struct commit
*)found
.objects
[i
].item
;
160 if (!tree_is_complete(c
->tree
->object
.sha1
)) {
162 c
->object
.flags
|= INCOMPLETE
;
165 if (!is_incomplete
) {
166 /* mark all found commits as complete, iow SEEN */
167 for (i
= 0; i
< found
.nr
; i
++)
168 found
.objects
[i
].item
->flags
|= SEEN
;
171 /* clear flags from the objects we traversed */
172 for (i
= 0; i
< found
.nr
; i
++)
173 found
.objects
[i
].item
->flags
&= ~STUDYING
;
175 commit
->object
.flags
|= INCOMPLETE
;
178 * If we come here, we have (1) traversed the ancestry chain
179 * from the "commit" until we reach SEEN commits (which are
180 * known to be complete), and (2) made sure that the commits
181 * encountered during the above traversal refer to trees that
182 * are complete. Which means that we know *all* the commits
183 * we have seen during this process are complete.
185 for (i
= 0; i
< found
.nr
; i
++)
186 found
.objects
[i
].item
->flags
|= SEEN
;
188 /* free object arrays */
191 return !is_incomplete
;
194 static int keep_entry(struct commit
**it
, unsigned char *sha1
)
196 struct commit
*commit
;
198 if (is_null_sha1(sha1
))
200 commit
= lookup_commit_reference_gently(sha1
, 1);
205 * Make sure everything in this commit exists.
207 * We have walked all the objects reachable from the refs
208 * and cache earlier. The commits reachable by this commit
209 * must meet SEEN commits -- and then we should mark them as
212 if (!commit_is_complete(commit
))
219 * Starting from commits in the cb->mark_list, mark commits that are
220 * reachable from them. Stop the traversal at commits older than
221 * the expire_limit and queue them back, so that the caller can call
222 * us again to restart the traversal with longer expire_limit.
224 static void mark_reachable(struct expire_reflog_cb
*cb
)
226 struct commit
*commit
;
227 struct commit_list
*pending
;
228 unsigned long expire_limit
= cb
->mark_limit
;
229 struct commit_list
*leftover
= NULL
;
231 for (pending
= cb
->mark_list
; pending
; pending
= pending
->next
)
232 pending
->item
->object
.flags
&= ~REACHABLE
;
234 pending
= cb
->mark_list
;
236 struct commit_list
*entry
= pending
;
237 struct commit_list
*parent
;
238 pending
= entry
->next
;
239 commit
= entry
->item
;
241 if (commit
->object
.flags
& REACHABLE
)
243 if (parse_commit(commit
))
245 commit
->object
.flags
|= REACHABLE
;
246 if (commit
->date
< expire_limit
) {
247 commit_list_insert(commit
, &leftover
);
250 commit
->object
.flags
|= REACHABLE
;
251 parent
= commit
->parents
;
253 commit
= parent
->item
;
254 parent
= parent
->next
;
255 if (commit
->object
.flags
& REACHABLE
)
257 commit_list_insert(commit
, &pending
);
260 cb
->mark_list
= leftover
;
263 static int unreachable(struct expire_reflog_cb
*cb
, struct commit
*commit
, unsigned char *sha1
)
266 * We may or may not have the commit yet - if not, look it
267 * up using the supplied sha1.
270 if (is_null_sha1(sha1
))
273 commit
= lookup_commit_reference_gently(sha1
, 1);
275 /* Not a commit -- keep it */
280 /* Reachable from the current ref? Don't prune. */
281 if (commit
->object
.flags
& REACHABLE
)
284 if (cb
->mark_list
&& cb
->mark_limit
) {
285 cb
->mark_limit
= 0; /* dig down to the root */
289 return !(commit
->object
.flags
& REACHABLE
);
292 static int expire_reflog_ent(unsigned char *osha1
, unsigned char *nsha1
,
293 const char *email
, unsigned long timestamp
, int tz
,
294 const char *message
, void *cb_data
)
296 struct expire_reflog_cb
*cb
= cb_data
;
297 struct commit
*old
, *new;
299 if (timestamp
< cb
->cmd
->expire_total
)
302 if (cb
->cmd
->rewrite
)
303 osha1
= cb
->last_kept_sha1
;
306 if (cb
->cmd
->stalefix
&&
307 (!keep_entry(&old
, osha1
) || !keep_entry(&new, nsha1
)))
310 if (timestamp
< cb
->cmd
->expire_unreachable
) {
311 if (cb
->unreachable_expire_kind
== UE_ALWAYS
)
313 if (unreachable(cb
, old
, osha1
) || unreachable(cb
, new, nsha1
))
317 if (cb
->cmd
->recno
&& --(cb
->cmd
->recno
) == 0)
321 char sign
= (tz
< 0) ? '-' : '+';
322 int zone
= (tz
< 0) ? (-tz
) : tz
;
323 fprintf(cb
->newlog
, "%s %s %s %lu %c%04d\t%s",
324 sha1_to_hex(osha1
), sha1_to_hex(nsha1
),
325 email
, timestamp
, sign
, zone
,
327 hashcpy(cb
->last_kept_sha1
, nsha1
);
329 if (cb
->cmd
->verbose
)
330 printf("keep %s", message
);
333 if (!cb
->newlog
|| cb
->cmd
->verbose
)
334 printf("%sprune %s", cb
->newlog
? "" : "would ", message
);
338 static int push_tip_to_list(const char *refname
, const unsigned char *sha1
, int flags
, void *cb_data
)
340 struct commit_list
**list
= cb_data
;
341 struct commit
*tip_commit
;
342 if (flags
& REF_ISSYMREF
)
344 tip_commit
= lookup_commit_reference_gently(sha1
, 1);
347 commit_list_insert(tip_commit
, list
);
351 static int expire_reflog(const char *ref
, const unsigned char *sha1
, int unused
, void *cb_data
)
353 struct cmd_reflog_expire_cb
*cmd
= cb_data
;
354 struct expire_reflog_cb cb
;
355 struct ref_lock
*lock
;
356 char *log_file
, *newlog_path
= NULL
;
357 struct commit
*tip_commit
;
358 struct commit_list
*tips
;
361 memset(&cb
, 0, sizeof(cb
));
364 * we take the lock for the ref itself to prevent it from
367 lock
= lock_any_ref_for_update(ref
, sha1
, 0);
369 return error("cannot lock ref '%s'", ref
);
370 log_file
= git_pathdup("logs/%s", ref
);
371 if (!file_exists(log_file
))
374 newlog_path
= git_pathdup("logs/%s.lock", ref
);
375 cb
.newlog
= fopen(newlog_path
, "w");
380 if (!cmd
->expire_unreachable
|| !strcmp(ref
, "HEAD")) {
382 cb
.unreachable_expire_kind
= UE_HEAD
;
384 tip_commit
= lookup_commit_reference_gently(sha1
, 1);
386 cb
.unreachable_expire_kind
= UE_ALWAYS
;
388 cb
.unreachable_expire_kind
= UE_NORMAL
;
391 if (cmd
->expire_unreachable
<= cmd
->expire_total
)
392 cb
.unreachable_expire_kind
= UE_ALWAYS
;
396 if (cb
.unreachable_expire_kind
!= UE_ALWAYS
) {
397 if (cb
.unreachable_expire_kind
== UE_HEAD
) {
398 struct commit_list
*elem
;
399 for_each_ref(push_tip_to_list
, &tips
);
400 for (elem
= tips
; elem
; elem
= elem
->next
)
401 commit_list_insert(elem
->item
, &cb
.mark_list
);
403 commit_list_insert(tip_commit
, &cb
.mark_list
);
405 cb
.mark_limit
= cmd
->expire_total
;
409 for_each_reflog_ent(ref
, expire_reflog_ent
, &cb
);
411 if (cb
.unreachable_expire_kind
!= UE_ALWAYS
) {
412 if (cb
.unreachable_expire_kind
== UE_HEAD
) {
413 struct commit_list
*elem
;
414 for (elem
= tips
; elem
; elem
= elem
->next
)
415 clear_commit_marks(tip_commit
, REACHABLE
);
416 free_commit_list(tips
);
418 clear_commit_marks(tip_commit
, REACHABLE
);
423 if (fclose(cb
.newlog
)) {
424 status
|= error("%s: %s", strerror(errno
),
427 } else if (cmd
->updateref
&&
428 (write_in_full(lock
->lock_fd
,
429 sha1_to_hex(cb
.last_kept_sha1
), 40) != 40 ||
430 write_str_in_full(lock
->lock_fd
, "\n") != 1 ||
431 close_ref(lock
) < 0)) {
432 status
|= error("Couldn't write %s",
435 } else if (rename(newlog_path
, log_file
)) {
436 status
|= error("cannot rename %s to %s",
437 newlog_path
, log_file
);
439 } else if (cmd
->updateref
&& commit_ref(lock
)) {
440 status
|= error("Couldn't set %s", lock
->ref_name
);
442 adjust_shared_perm(log_file
);
451 static int collect_reflog(const char *ref
, const unsigned char *sha1
, int unused
, void *cb_data
)
453 struct collected_reflog
*e
;
454 struct collect_reflog_cb
*cb
= cb_data
;
455 size_t namelen
= strlen(ref
);
457 e
= xmalloc(sizeof(*e
) + namelen
+ 1);
458 hashcpy(e
->sha1
, sha1
);
459 memcpy(e
->reflog
, ref
, namelen
+ 1);
460 ALLOC_GROW(cb
->e
, cb
->nr
+ 1, cb
->alloc
);
465 static struct reflog_expire_cfg
{
466 struct reflog_expire_cfg
*next
;
467 unsigned long expire_total
;
468 unsigned long expire_unreachable
;
470 char pattern
[FLEX_ARRAY
];
471 } *reflog_expire_cfg
, **reflog_expire_cfg_tail
;
473 static struct reflog_expire_cfg
*find_cfg_ent(const char *pattern
, size_t len
)
475 struct reflog_expire_cfg
*ent
;
477 if (!reflog_expire_cfg_tail
)
478 reflog_expire_cfg_tail
= &reflog_expire_cfg
;
480 for (ent
= reflog_expire_cfg
; ent
; ent
= ent
->next
)
481 if (ent
->len
== len
&&
482 !memcmp(ent
->pattern
, pattern
, len
))
485 ent
= xcalloc(1, (sizeof(*ent
) + len
));
486 memcpy(ent
->pattern
, pattern
, len
);
488 *reflog_expire_cfg_tail
= ent
;
489 reflog_expire_cfg_tail
= &(ent
->next
);
493 static int parse_expire_cfg_value(const char *var
, const char *value
, unsigned long *expire
)
496 return config_error_nonbool(var
);
497 if (!strcmp(value
, "never") || !strcmp(value
, "false")) {
501 *expire
= approxidate(value
);
505 /* expiry timer slot */
506 #define EXPIRE_TOTAL 01
507 #define EXPIRE_UNREACH 02
509 static int reflog_expire_config(const char *var
, const char *value
, void *cb
)
511 const char *lastdot
= strrchr(var
, '.');
512 unsigned long expire
;
514 struct reflog_expire_cfg
*ent
;
516 if (!lastdot
|| prefixcmp(var
, "gc."))
517 return git_default_config(var
, value
, cb
);
519 if (!strcmp(lastdot
, ".reflogexpire")) {
521 if (parse_expire_cfg_value(var
, value
, &expire
))
523 } else if (!strcmp(lastdot
, ".reflogexpireunreachable")) {
524 slot
= EXPIRE_UNREACH
;
525 if (parse_expire_cfg_value(var
, value
, &expire
))
528 return git_default_config(var
, value
, cb
);
530 if (lastdot
== var
+ 2) {
533 default_reflog_expire
= expire
;
536 default_reflog_expire_unreachable
= expire
;
542 ent
= find_cfg_ent(var
+ 3, lastdot
- (var
+3));
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 (!fnmatch(ent
->pattern
, ref
, 0)) {
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 (!prefixcmp(arg
, "--expire=")) {
614 cb
.expire_total
= approxidate(arg
+ 9);
615 explicit_expiry
|= EXPIRE_TOTAL
;
617 else if (!prefixcmp(arg
, "--expire-unreachable=")) {
618 cb
.expire_unreachable
= approxidate(arg
+ 21);
619 explicit_expiry
|= EXPIRE_UNREACH
;
621 else if (!strcmp(arg
, "--stale-fix"))
623 else if (!strcmp(arg
, "--rewrite"))
625 else if (!strcmp(arg
, "--updateref"))
627 else if (!strcmp(arg
, "--all"))
629 else if (!strcmp(arg
, "--verbose"))
631 else if (!strcmp(arg
, "--")) {
635 else if (arg
[0] == '-')
636 usage(reflog_expire_usage
);
642 * We can trust the commits and objects reachable from refs
643 * even in older repository. We cannot trust what's reachable
644 * from reflog if the repository was pruned with older git.
647 init_revisions(&cb
.revs
, prefix
);
649 printf("Marking reachable objects...");
650 mark_reachable_objects(&cb
.revs
, 0, NULL
);
656 struct collect_reflog_cb collected
;
659 memset(&collected
, 0, sizeof(collected
));
660 for_each_reflog(collect_reflog
, &collected
);
661 for (i
= 0; i
< collected
.nr
; i
++) {
662 struct collected_reflog
*e
= collected
.e
[i
];
663 set_reflog_expiry_param(&cb
, explicit_expiry
, e
->reflog
);
664 status
|= expire_reflog(e
->reflog
, e
->sha1
, 0, &cb
);
670 for (; i
< argc
; i
++) {
672 unsigned char sha1
[20];
673 if (!dwim_log(argv
[i
], strlen(argv
[i
]), sha1
, &ref
)) {
674 status
|= error("%s points nowhere!", argv
[i
]);
677 set_reflog_expiry_param(&cb
, explicit_expiry
, ref
);
678 status
|= expire_reflog(ref
, sha1
, 0, &cb
);
683 static int count_reflog_ent(unsigned char *osha1
, unsigned char *nsha1
,
684 const char *email
, unsigned long timestamp
, int tz
,
685 const char *message
, void *cb_data
)
687 struct cmd_reflog_expire_cb
*cb
= cb_data
;
688 if (!cb
->expire_total
|| timestamp
< cb
->expire_total
)
693 static int cmd_reflog_delete(int argc
, const char **argv
, const char *prefix
)
695 struct cmd_reflog_expire_cb cb
;
698 memset(&cb
, 0, sizeof(cb
));
700 for (i
= 1; i
< argc
; i
++) {
701 const char *arg
= argv
[i
];
702 if (!strcmp(arg
, "--dry-run") || !strcmp(arg
, "-n"))
704 else if (!strcmp(arg
, "--rewrite"))
706 else if (!strcmp(arg
, "--updateref"))
708 else if (!strcmp(arg
, "--verbose"))
710 else if (!strcmp(arg
, "--")) {
714 else if (arg
[0] == '-')
715 usage(reflog_delete_usage
);
721 return error("Nothing to delete?");
723 for ( ; i
< argc
; i
++) {
724 const char *spec
= strstr(argv
[i
], "@{");
725 unsigned char sha1
[20];
730 status
|= error("Not a reflog: %s", argv
[i
]);
734 if (!dwim_log(argv
[i
], spec
- argv
[i
], sha1
, &ref
)) {
735 status
|= error("no reflog for '%s'", argv
[i
]);
739 recno
= strtoul(spec
+ 2, &ep
, 10);
742 for_each_reflog_ent(ref
, count_reflog_ent
, &cb
);
744 cb
.expire_total
= approxidate(spec
+ 2);
745 for_each_reflog_ent(ref
, count_reflog_ent
, &cb
);
749 status
|= expire_reflog(ref
, sha1
, 0, &cb
);
759 static const char reflog_usage
[] =
760 "git reflog [ show | expire | delete ]";
762 int cmd_reflog(int argc
, const char **argv
, const char *prefix
)
764 if (argc
> 1 && !strcmp(argv
[1], "-h"))
767 /* With no command, we default to showing it. */
768 if (argc
< 2 || *argv
[1] == '-')
769 return cmd_log_reflog(argc
, argv
, prefix
);
771 if (!strcmp(argv
[1], "show"))
772 return cmd_log_reflog(argc
- 1, argv
+ 1, prefix
);
774 if (!strcmp(argv
[1], "expire"))
775 return cmd_reflog_expire(argc
- 1, argv
+ 1, prefix
);
777 if (!strcmp(argv
[1], "delete"))
778 return cmd_reflog_delete(argc
- 1, argv
+ 1, prefix
);
780 return cmd_log_reflog(argc
, argv
, prefix
);