2006-12-19 09:23:12 +01:00
|
|
|
#include "builtin.h"
|
2014-10-01 12:28:42 +02:00
|
|
|
#include "lockfile.h"
|
2006-12-19 09:23:12 +01:00
|
|
|
#include "commit.h"
|
|
|
|
#include "refs.h"
|
|
|
|
#include "dir.h"
|
2006-12-22 09:46:33 +01:00
|
|
|
#include "tree-walk.h"
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
#include "diff.h"
|
|
|
|
#include "revision.h"
|
|
|
|
#include "reachable.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* reflog expire
|
|
|
|
*/
|
|
|
|
|
|
|
|
static const char reflog_expire_usage[] =
|
2010-04-19 11:52:30 +02:00
|
|
|
"git reflog expire [--verbose] [--dry-run] [--stale-fix] [--expire=<time>] [--expire-unreachable=<time>] [--all] <refs>...";
|
2008-02-22 22:08:59 +01:00
|
|
|
static const char reflog_delete_usage[] =
|
2008-07-13 15:36:15 +02:00
|
|
|
"git reflog delete [--verbose] [--dry-run] [--rewrite] [--updateref] <refs>...";
|
2006-12-19 09:23:12 +01:00
|
|
|
|
2006-12-27 10:47:57 +01:00
|
|
|
static unsigned long default_reflog_expire;
|
|
|
|
static unsigned long default_reflog_expire_unreachable;
|
|
|
|
|
2014-12-12 09:56:50 +01:00
|
|
|
enum expire_reflog_flags {
|
2014-12-12 09:56:51 +01:00
|
|
|
EXPIRE_REFLOGS_DRY_RUN = 1 << 0,
|
|
|
|
EXPIRE_REFLOGS_UPDATE_REF = 1 << 1
|
2014-12-12 09:56:50 +01:00
|
|
|
};
|
|
|
|
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
struct cmd_reflog_expire_cb {
|
|
|
|
struct rev_info revs;
|
|
|
|
int stalefix;
|
2008-02-22 19:56:50 +01:00
|
|
|
int rewrite;
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
int verbose;
|
|
|
|
unsigned long expire_total;
|
|
|
|
unsigned long expire_unreachable;
|
2007-10-17 03:50:45 +02:00
|
|
|
int recno;
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
};
|
|
|
|
|
2014-12-12 09:56:52 +01:00
|
|
|
struct expire_reflog_policy_cb {
|
2006-12-19 09:23:12 +01:00
|
|
|
FILE *newlog;
|
2010-04-09 22:20:02 +02:00
|
|
|
enum {
|
|
|
|
UE_NORMAL,
|
|
|
|
UE_ALWAYS,
|
|
|
|
UE_HEAD
|
|
|
|
} unreachable_expire_kind;
|
2010-04-07 20:09:12 +02:00
|
|
|
struct commit_list *mark_list;
|
|
|
|
unsigned long mark_limit;
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
struct cmd_reflog_expire_cb *cmd;
|
2008-02-22 19:56:50 +01:00
|
|
|
unsigned char last_kept_sha1[20];
|
2014-12-12 09:56:48 +01:00
|
|
|
struct commit *tip_commit;
|
|
|
|
struct commit_list *tips;
|
2006-12-19 09:23:12 +01:00
|
|
|
};
|
|
|
|
|
2014-12-12 09:56:53 +01:00
|
|
|
struct expire_reflog_cb {
|
2014-12-12 09:56:54 +01:00
|
|
|
unsigned int flags;
|
2014-12-12 09:56:53 +01:00
|
|
|
void *policy_cb;
|
|
|
|
};
|
|
|
|
|
2008-01-26 08:53:05 +01:00
|
|
|
struct collected_reflog {
|
|
|
|
unsigned char sha1[20];
|
|
|
|
char reflog[FLEX_ARRAY];
|
|
|
|
};
|
2014-12-12 09:56:53 +01:00
|
|
|
|
2008-01-26 08:53:05 +01:00
|
|
|
struct collect_reflog_cb {
|
|
|
|
struct collected_reflog **e;
|
|
|
|
int alloc;
|
|
|
|
int nr;
|
|
|
|
};
|
|
|
|
|
2007-01-07 07:32:41 +01:00
|
|
|
#define INCOMPLETE (1u<<10)
|
|
|
|
#define STUDYING (1u<<11)
|
2009-03-31 06:34:14 +02:00
|
|
|
#define REACHABLE (1u<<12)
|
2007-01-07 07:32:41 +01:00
|
|
|
|
2006-12-22 09:46:33 +01:00
|
|
|
static int tree_is_complete(const unsigned char *sha1)
|
|
|
|
{
|
|
|
|
struct tree_desc desc;
|
2007-01-07 07:32:41 +01:00
|
|
|
struct name_entry entry;
|
|
|
|
int complete;
|
|
|
|
struct tree *tree;
|
2006-12-22 09:46:33 +01:00
|
|
|
|
2007-01-07 07:32:41 +01:00
|
|
|
tree = lookup_tree(sha1);
|
|
|
|
if (!tree)
|
2006-12-22 09:46:33 +01:00
|
|
|
return 0;
|
2007-01-07 07:32:41 +01:00
|
|
|
if (tree->object.flags & SEEN)
|
|
|
|
return 1;
|
|
|
|
if (tree->object.flags & INCOMPLETE)
|
|
|
|
return 0;
|
|
|
|
|
2007-03-21 18:08:25 +01:00
|
|
|
if (!tree->buffer) {
|
2007-02-26 20:55:59 +01:00
|
|
|
enum object_type type;
|
2007-03-21 18:08:25 +01:00
|
|
|
unsigned long size;
|
|
|
|
void *data = read_sha1_file(sha1, &type, &size);
|
2007-01-07 07:32:41 +01:00
|
|
|
if (!data) {
|
|
|
|
tree->object.flags |= INCOMPLETE;
|
2006-12-22 09:46:33 +01:00
|
|
|
return 0;
|
|
|
|
}
|
2007-01-07 07:32:41 +01:00
|
|
|
tree->buffer = data;
|
2007-03-21 18:08:25 +01:00
|
|
|
tree->size = size;
|
2006-12-22 09:46:33 +01:00
|
|
|
}
|
2007-03-21 18:08:25 +01:00
|
|
|
init_tree_desc(&desc, tree->buffer, tree->size);
|
2007-01-07 07:32:41 +01:00
|
|
|
complete = 1;
|
|
|
|
while (tree_entry(&desc, &entry)) {
|
|
|
|
if (!has_sha1_file(entry.sha1) ||
|
|
|
|
(S_ISDIR(entry.mode) && !tree_is_complete(entry.sha1))) {
|
|
|
|
tree->object.flags |= INCOMPLETE;
|
|
|
|
complete = 0;
|
|
|
|
}
|
|
|
|
}
|
2013-06-06 00:37:39 +02:00
|
|
|
free_tree_buffer(tree);
|
2006-12-22 09:46:33 +01:00
|
|
|
|
2007-01-07 07:32:41 +01:00
|
|
|
if (complete)
|
|
|
|
tree->object.flags |= SEEN;
|
|
|
|
return complete;
|
|
|
|
}
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
|
|
|
|
static int commit_is_complete(struct commit *commit)
|
|
|
|
{
|
|
|
|
struct object_array study;
|
|
|
|
struct object_array found;
|
|
|
|
int is_incomplete = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* early return */
|
|
|
|
if (commit->object.flags & SEEN)
|
|
|
|
return 1;
|
|
|
|
if (commit->object.flags & INCOMPLETE)
|
|
|
|
return 0;
|
|
|
|
/*
|
|
|
|
* Find all commits that are reachable and are not marked as
|
|
|
|
* SEEN. Then make sure the trees and blobs contained are
|
|
|
|
* complete. After that, mark these commits also as SEEN.
|
|
|
|
* If some of the objects that are needed to complete this
|
|
|
|
* commit are missing, mark this commit as INCOMPLETE.
|
|
|
|
*/
|
|
|
|
memset(&study, 0, sizeof(study));
|
|
|
|
memset(&found, 0, sizeof(found));
|
|
|
|
add_object_array(&commit->object, NULL, &study);
|
|
|
|
add_object_array(&commit->object, NULL, &found);
|
|
|
|
commit->object.flags |= STUDYING;
|
|
|
|
while (study.nr) {
|
|
|
|
struct commit *c;
|
|
|
|
struct commit_list *parent;
|
|
|
|
|
|
|
|
c = (struct commit *)study.objects[--study.nr].item;
|
|
|
|
if (!c->object.parsed && !parse_object(c->object.sha1))
|
|
|
|
c->object.flags |= INCOMPLETE;
|
|
|
|
|
|
|
|
if (c->object.flags & INCOMPLETE) {
|
|
|
|
is_incomplete = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if (c->object.flags & SEEN)
|
|
|
|
continue;
|
|
|
|
for (parent = c->parents; parent; parent = parent->next) {
|
|
|
|
struct commit *p = parent->item;
|
|
|
|
if (p->object.flags & STUDYING)
|
|
|
|
continue;
|
|
|
|
p->object.flags |= STUDYING;
|
|
|
|
add_object_array(&p->object, NULL, &study);
|
|
|
|
add_object_array(&p->object, NULL, &found);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!is_incomplete) {
|
2007-01-07 07:32:41 +01:00
|
|
|
/*
|
|
|
|
* make sure all commits in "found" array have all the
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
* necessary objects.
|
|
|
|
*/
|
2007-01-07 07:32:41 +01:00
|
|
|
for (i = 0; i < found.nr; i++) {
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
struct commit *c =
|
|
|
|
(struct commit *)found.objects[i].item;
|
2007-01-07 07:32:41 +01:00
|
|
|
if (!tree_is_complete(c->tree->object.sha1)) {
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
is_incomplete = 1;
|
2007-01-07 07:32:41 +01:00
|
|
|
c->object.flags |= INCOMPLETE;
|
|
|
|
}
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
}
|
|
|
|
if (!is_incomplete) {
|
|
|
|
/* mark all found commits as complete, iow SEEN */
|
|
|
|
for (i = 0; i < found.nr; i++)
|
|
|
|
found.objects[i].item->flags |= SEEN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* clear flags from the objects we traversed */
|
|
|
|
for (i = 0; i < found.nr; i++)
|
|
|
|
found.objects[i].item->flags &= ~STUDYING;
|
|
|
|
if (is_incomplete)
|
|
|
|
commit->object.flags |= INCOMPLETE;
|
2007-01-07 07:32:41 +01:00
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* If we come here, we have (1) traversed the ancestry chain
|
|
|
|
* from the "commit" until we reach SEEN commits (which are
|
|
|
|
* known to be complete), and (2) made sure that the commits
|
|
|
|
* encountered during the above traversal refer to trees that
|
|
|
|
* are complete. Which means that we know *all* the commits
|
|
|
|
* we have seen during this process are complete.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < found.nr; i++)
|
|
|
|
found.objects[i].item->flags |= SEEN;
|
|
|
|
}
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
/* free object arrays */
|
|
|
|
free(study.objects);
|
|
|
|
free(found.objects);
|
|
|
|
return !is_incomplete;
|
|
|
|
}
|
|
|
|
|
2006-12-19 09:23:12 +01:00
|
|
|
static int keep_entry(struct commit **it, unsigned char *sha1)
|
|
|
|
{
|
2006-12-22 09:46:33 +01:00
|
|
|
struct commit *commit;
|
|
|
|
|
2006-12-19 09:23:12 +01:00
|
|
|
if (is_null_sha1(sha1))
|
|
|
|
return 1;
|
2006-12-22 09:46:33 +01:00
|
|
|
commit = lookup_commit_reference_gently(sha1, 1);
|
|
|
|
if (!commit)
|
|
|
|
return 0;
|
|
|
|
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
/*
|
|
|
|
* Make sure everything in this commit exists.
|
|
|
|
*
|
|
|
|
* We have walked all the objects reachable from the refs
|
|
|
|
* and cache earlier. The commits reachable by this commit
|
|
|
|
* must meet SEEN commits -- and then we should mark them as
|
|
|
|
* SEEN as well.
|
|
|
|
*/
|
|
|
|
if (!commit_is_complete(commit))
|
2006-12-22 09:46:33 +01:00
|
|
|
return 0;
|
|
|
|
*it = commit;
|
|
|
|
return 1;
|
2006-12-19 09:23:12 +01:00
|
|
|
}
|
|
|
|
|
2010-04-07 20:09:12 +02:00
|
|
|
/*
|
|
|
|
* Starting from commits in the cb->mark_list, mark commits that are
|
|
|
|
* reachable from them. Stop the traversal at commits older than
|
|
|
|
* the expire_limit and queue them back, so that the caller can call
|
|
|
|
* us again to restart the traversal with longer expire_limit.
|
|
|
|
*/
|
2014-12-12 09:56:52 +01:00
|
|
|
static void mark_reachable(struct expire_reflog_policy_cb *cb)
|
2009-03-31 18:45:22 +02:00
|
|
|
{
|
2010-04-07 20:09:12 +02:00
|
|
|
struct commit *commit;
|
|
|
|
struct commit_list *pending;
|
|
|
|
unsigned long expire_limit = cb->mark_limit;
|
|
|
|
struct commit_list *leftover = NULL;
|
2009-03-31 18:45:22 +02:00
|
|
|
|
2010-04-07 20:09:12 +02:00
|
|
|
for (pending = cb->mark_list; pending; pending = pending->next)
|
|
|
|
pending->item->object.flags &= ~REACHABLE;
|
2009-03-31 06:34:14 +02:00
|
|
|
|
2010-04-07 20:09:12 +02:00
|
|
|
pending = cb->mark_list;
|
2009-03-31 06:34:14 +02:00
|
|
|
while (pending) {
|
|
|
|
struct commit_list *entry = pending;
|
|
|
|
struct commit_list *parent;
|
|
|
|
pending = entry->next;
|
|
|
|
commit = entry->item;
|
|
|
|
free(entry);
|
|
|
|
if (commit->object.flags & REACHABLE)
|
|
|
|
continue;
|
|
|
|
if (parse_commit(commit))
|
|
|
|
continue;
|
|
|
|
commit->object.flags |= REACHABLE;
|
2010-04-07 20:09:12 +02:00
|
|
|
if (commit->date < expire_limit) {
|
|
|
|
commit_list_insert(commit, &leftover);
|
2009-03-31 06:34:14 +02:00
|
|
|
continue;
|
2010-04-07 20:09:12 +02:00
|
|
|
}
|
|
|
|
commit->object.flags |= REACHABLE;
|
2009-03-31 06:34:14 +02:00
|
|
|
parent = commit->parents;
|
|
|
|
while (parent) {
|
|
|
|
commit = parent->item;
|
|
|
|
parent = parent->next;
|
|
|
|
if (commit->object.flags & REACHABLE)
|
|
|
|
continue;
|
|
|
|
commit_list_insert(commit, &pending);
|
|
|
|
}
|
|
|
|
}
|
2010-04-07 20:09:12 +02:00
|
|
|
cb->mark_list = leftover;
|
|
|
|
}
|
|
|
|
|
2014-12-12 09:56:52 +01:00
|
|
|
static int unreachable(struct expire_reflog_policy_cb *cb, struct commit *commit, unsigned char *sha1)
|
2010-04-07 20:09:12 +02:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We may or may not have the commit yet - if not, look it
|
|
|
|
* up using the supplied sha1.
|
|
|
|
*/
|
|
|
|
if (!commit) {
|
|
|
|
if (is_null_sha1(sha1))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
commit = lookup_commit_reference_gently(sha1, 1);
|
|
|
|
|
|
|
|
/* Not a commit -- keep it */
|
|
|
|
if (!commit)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Reachable from the current ref? Don't prune. */
|
|
|
|
if (commit->object.flags & REACHABLE)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (cb->mark_list && cb->mark_limit) {
|
|
|
|
cb->mark_limit = 0; /* dig down to the root */
|
|
|
|
mark_reachable(cb);
|
|
|
|
}
|
|
|
|
|
|
|
|
return !(commit->object.flags & REACHABLE);
|
2009-03-31 06:34:14 +02:00
|
|
|
}
|
|
|
|
|
2014-12-12 09:56:47 +01:00
|
|
|
/*
|
|
|
|
* Return true iff the specified reflog entry should be expired.
|
|
|
|
*/
|
|
|
|
static int should_expire_reflog_ent(unsigned char *osha1, unsigned char *nsha1,
|
|
|
|
const char *email, unsigned long timestamp, int tz,
|
|
|
|
const char *message, void *cb_data)
|
2006-12-19 09:23:12 +01:00
|
|
|
{
|
2014-12-12 09:56:52 +01:00
|
|
|
struct expire_reflog_policy_cb *cb = cb_data;
|
2006-12-19 09:23:12 +01:00
|
|
|
struct commit *old, *new;
|
|
|
|
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
if (timestamp < cb->cmd->expire_total)
|
2014-12-12 09:56:47 +01:00
|
|
|
return 1;
|
2008-02-22 19:56:50 +01:00
|
|
|
|
2007-01-12 04:56:43 +01:00
|
|
|
old = new = NULL;
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
if (cb->cmd->stalefix &&
|
|
|
|
(!keep_entry(&old, osha1) || !keep_entry(&new, nsha1)))
|
2014-12-12 09:56:47 +01:00
|
|
|
return 1;
|
2006-12-19 09:23:12 +01:00
|
|
|
|
2007-01-12 04:56:43 +01:00
|
|
|
if (timestamp < cb->cmd->expire_unreachable) {
|
2010-04-09 22:20:02 +02:00
|
|
|
if (cb->unreachable_expire_kind == UE_ALWAYS)
|
2014-12-12 09:56:47 +01:00
|
|
|
return 1;
|
2009-03-31 18:45:22 +02:00
|
|
|
if (unreachable(cb, old, osha1) || unreachable(cb, new, nsha1))
|
2014-12-12 09:56:47 +01:00
|
|
|
return 1;
|
2007-01-12 04:56:43 +01:00
|
|
|
}
|
2006-12-19 09:23:12 +01:00
|
|
|
|
2007-10-17 03:50:45 +02:00
|
|
|
if (cb->cmd->recno && --(cb->cmd->recno) == 0)
|
2014-12-12 09:56:47 +01:00
|
|
|
return 1;
|
|
|
|
|
2006-12-19 09:23:12 +01:00
|
|
|
return 0;
|
2014-12-12 09:56:47 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int expire_reflog_ent(unsigned char *osha1, unsigned char *nsha1,
|
|
|
|
const char *email, unsigned long timestamp, int tz,
|
|
|
|
const char *message, void *cb_data)
|
|
|
|
{
|
2014-12-12 09:56:53 +01:00
|
|
|
struct expire_reflog_cb *cb = cb_data;
|
|
|
|
struct expire_reflog_policy_cb *policy_cb = cb->policy_cb;
|
2014-12-12 09:56:47 +01:00
|
|
|
|
2014-12-12 09:56:53 +01:00
|
|
|
if (policy_cb->cmd->rewrite)
|
|
|
|
osha1 = policy_cb->last_kept_sha1;
|
2014-12-12 09:56:47 +01:00
|
|
|
|
|
|
|
if (should_expire_reflog_ent(osha1, nsha1, email, timestamp, tz,
|
2014-12-12 09:56:53 +01:00
|
|
|
message, policy_cb)) {
|
|
|
|
if (!policy_cb->newlog)
|
2014-12-12 09:56:47 +01:00
|
|
|
printf("would prune %s", message);
|
2014-12-12 09:56:53 +01:00
|
|
|
else if (policy_cb->cmd->verbose)
|
2014-12-12 09:56:47 +01:00
|
|
|
printf("prune %s", message);
|
|
|
|
} else {
|
2014-12-12 09:56:53 +01:00
|
|
|
if (policy_cb->newlog) {
|
2014-12-12 09:56:47 +01:00
|
|
|
char sign = (tz < 0) ? '-' : '+';
|
|
|
|
int zone = (tz < 0) ? (-tz) : tz;
|
2014-12-12 09:56:53 +01:00
|
|
|
fprintf(policy_cb->newlog, "%s %s %s %lu %c%04d\t%s",
|
2014-12-12 09:56:47 +01:00
|
|
|
sha1_to_hex(osha1), sha1_to_hex(nsha1),
|
|
|
|
email, timestamp, sign, zone,
|
|
|
|
message);
|
2014-12-12 09:56:53 +01:00
|
|
|
hashcpy(policy_cb->last_kept_sha1, nsha1);
|
2014-12-12 09:56:47 +01:00
|
|
|
}
|
2014-12-12 09:56:53 +01:00
|
|
|
if (policy_cb->cmd->verbose)
|
2014-12-12 09:56:47 +01:00
|
|
|
printf("keep %s", message);
|
|
|
|
}
|
2006-12-19 09:23:12 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-12-12 09:56:52 +01:00
|
|
|
static int push_tip_to_list(const char *refname, const unsigned char *sha1,
|
|
|
|
int flags, void *cb_data)
|
2010-04-09 22:20:02 +02:00
|
|
|
{
|
|
|
|
struct commit_list **list = cb_data;
|
|
|
|
struct commit *tip_commit;
|
|
|
|
if (flags & REF_ISSYMREF)
|
|
|
|
return 0;
|
|
|
|
tip_commit = lookup_commit_reference_gently(sha1, 1);
|
|
|
|
if (!tip_commit)
|
|
|
|
return 0;
|
|
|
|
commit_list_insert(tip_commit, list);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-12-12 09:56:48 +01:00
|
|
|
static void reflog_expiry_prepare(const char *refname,
|
|
|
|
const unsigned char *sha1,
|
2014-12-12 09:56:52 +01:00
|
|
|
struct expire_reflog_policy_cb *cb)
|
2014-12-12 09:56:48 +01:00
|
|
|
{
|
|
|
|
if (!cb->cmd->expire_unreachable || !strcmp(refname, "HEAD")) {
|
|
|
|
cb->tip_commit = NULL;
|
|
|
|
cb->unreachable_expire_kind = UE_HEAD;
|
|
|
|
} else {
|
|
|
|
cb->tip_commit = lookup_commit_reference_gently(sha1, 1);
|
|
|
|
if (!cb->tip_commit)
|
|
|
|
cb->unreachable_expire_kind = UE_ALWAYS;
|
|
|
|
else
|
|
|
|
cb->unreachable_expire_kind = UE_NORMAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cb->cmd->expire_unreachable <= cb->cmd->expire_total)
|
|
|
|
cb->unreachable_expire_kind = UE_ALWAYS;
|
|
|
|
|
|
|
|
cb->mark_list = NULL;
|
|
|
|
cb->tips = NULL;
|
|
|
|
if (cb->unreachable_expire_kind != UE_ALWAYS) {
|
|
|
|
if (cb->unreachable_expire_kind == UE_HEAD) {
|
|
|
|
struct commit_list *elem;
|
|
|
|
for_each_ref(push_tip_to_list, &cb->tips);
|
|
|
|
for (elem = cb->tips; elem; elem = elem->next)
|
|
|
|
commit_list_insert(elem->item, &cb->mark_list);
|
|
|
|
} else {
|
|
|
|
commit_list_insert(cb->tip_commit, &cb->mark_list);
|
|
|
|
}
|
|
|
|
cb->mark_limit = cb->cmd->expire_total;
|
|
|
|
mark_reachable(cb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-12 09:56:52 +01:00
|
|
|
static void reflog_expiry_cleanup(struct expire_reflog_policy_cb *cb)
|
2014-12-12 09:56:48 +01:00
|
|
|
{
|
|
|
|
if (cb->unreachable_expire_kind != UE_ALWAYS) {
|
|
|
|
if (cb->unreachable_expire_kind == UE_HEAD) {
|
|
|
|
struct commit_list *elem;
|
|
|
|
for (elem = cb->tips; elem; elem = elem->next)
|
|
|
|
clear_commit_marks(elem->item, REACHABLE);
|
|
|
|
free_commit_list(cb->tips);
|
|
|
|
} else {
|
|
|
|
clear_commit_marks(cb->tip_commit, REACHABLE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-12 09:56:44 +01:00
|
|
|
static int expire_reflog(const char *refname, const unsigned char *sha1,
|
2014-12-12 09:56:49 +01:00
|
|
|
unsigned int flags, struct cmd_reflog_expire_cb *cmd)
|
2006-12-19 09:23:12 +01:00
|
|
|
{
|
2014-12-12 09:56:46 +01:00
|
|
|
static struct lock_file reflog_lock;
|
2014-12-12 09:56:53 +01:00
|
|
|
struct expire_reflog_cb cb;
|
|
|
|
struct expire_reflog_policy_cb policy_cb;
|
2006-12-19 09:23:12 +01:00
|
|
|
struct ref_lock *lock;
|
2014-12-12 09:56:46 +01:00
|
|
|
char *log_file;
|
2006-12-19 09:23:12 +01:00
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
memset(&cb, 0, sizeof(cb));
|
2014-12-12 09:56:53 +01:00
|
|
|
memset(&policy_cb, 0, sizeof(policy_cb));
|
2014-12-12 09:56:54 +01:00
|
|
|
cb.flags = flags;
|
2014-12-12 09:56:53 +01:00
|
|
|
cb.policy_cb = &policy_cb;
|
2008-06-16 08:48:46 +02:00
|
|
|
|
|
|
|
/*
|
2014-12-12 09:56:46 +01:00
|
|
|
* The reflog file is locked by holding the lock on the
|
|
|
|
* reference itself, plus we might need to update the
|
|
|
|
* reference if --updateref was specified:
|
2006-12-19 09:23:12 +01:00
|
|
|
*/
|
2014-12-12 09:56:44 +01:00
|
|
|
lock = lock_any_ref_for_update(refname, sha1, 0, NULL);
|
2006-12-19 09:23:12 +01:00
|
|
|
if (!lock)
|
2014-12-12 09:56:44 +01:00
|
|
|
return error("cannot lock ref '%s'", refname);
|
2014-12-12 09:56:45 +01:00
|
|
|
if (!reflog_exists(refname)) {
|
|
|
|
unlock_ref(lock);
|
|
|
|
return 0;
|
|
|
|
}
|
2014-12-12 09:56:46 +01:00
|
|
|
|
2014-12-12 09:56:44 +01:00
|
|
|
log_file = git_pathdup("logs/%s", refname);
|
2014-12-12 09:56:50 +01:00
|
|
|
if (!(flags & EXPIRE_REFLOGS_DRY_RUN)) {
|
2014-12-12 09:56:46 +01:00
|
|
|
/*
|
|
|
|
* Even though holding $GIT_DIR/logs/$reflog.lock has
|
|
|
|
* no locking implications, we use the lock_file
|
|
|
|
* machinery here anyway because it does a lot of the
|
|
|
|
* work we need, including cleaning up if the program
|
|
|
|
* exits unexpectedly.
|
|
|
|
*/
|
|
|
|
if (hold_lock_file_for_update(&reflog_lock, log_file, 0) < 0) {
|
|
|
|
struct strbuf err = STRBUF_INIT;
|
|
|
|
unable_to_lock_message(log_file, errno, &err);
|
|
|
|
error("%s", err.buf);
|
|
|
|
strbuf_release(&err);
|
|
|
|
goto failure;
|
|
|
|
}
|
2014-12-12 09:56:53 +01:00
|
|
|
policy_cb.newlog = fdopen_lock_file(&reflog_lock, "w");
|
|
|
|
if (!policy_cb.newlog) {
|
2014-12-12 09:56:46 +01:00
|
|
|
error("cannot fdopen %s (%s)",
|
|
|
|
reflog_lock.filename.buf, strerror(errno));
|
|
|
|
goto failure;
|
|
|
|
}
|
2006-12-19 09:23:12 +01:00
|
|
|
}
|
|
|
|
|
2014-12-12 09:56:53 +01:00
|
|
|
policy_cb.cmd = cmd;
|
2010-04-09 22:20:02 +02:00
|
|
|
|
2014-12-12 09:56:53 +01:00
|
|
|
reflog_expiry_prepare(refname, sha1, &policy_cb);
|
2014-12-12 09:56:44 +01:00
|
|
|
for_each_reflog_ent(refname, expire_reflog_ent, &cb);
|
2014-12-12 09:56:53 +01:00
|
|
|
reflog_expiry_cleanup(&policy_cb);
|
2014-12-12 09:56:45 +01:00
|
|
|
|
2014-12-12 09:56:50 +01:00
|
|
|
if (!(flags & EXPIRE_REFLOGS_DRY_RUN)) {
|
2014-12-12 09:56:46 +01:00
|
|
|
if (close_lock_file(&reflog_lock)) {
|
|
|
|
status |= error("couldn't write %s: %s", log_file,
|
|
|
|
strerror(errno));
|
2014-12-12 09:56:51 +01:00
|
|
|
} else if ((flags & EXPIRE_REFLOGS_UPDATE_REF) &&
|
2008-02-22 20:04:12 +01:00
|
|
|
(write_in_full(lock->lock_fd,
|
2014-12-12 09:56:53 +01:00
|
|
|
sha1_to_hex(policy_cb.last_kept_sha1), 40) != 40 ||
|
use write_str_in_full helper to avoid literal string lengths
In 2d14d65 (Use a clearer style to issue commands to remote helpers,
2009-09-03) I happened to notice two changes like this:
- write_in_full(helper->in, "list\n", 5);
+
+ strbuf_addstr(&buf, "list\n");
+ write_in_full(helper->in, buf.buf, buf.len);
+ strbuf_reset(&buf);
IMHO, it would be better to define a new function,
static inline ssize_t write_str_in_full(int fd, const char *str)
{
return write_in_full(fd, str, strlen(str));
}
and then use it like this:
- strbuf_addstr(&buf, "list\n");
- write_in_full(helper->in, buf.buf, buf.len);
- strbuf_reset(&buf);
+ write_str_in_full(helper->in, "list\n");
Thus not requiring the added allocation, and still avoiding
the maintenance risk of literal string lengths.
These days, compilers are good enough that strlen("literal")
imposes no run-time cost.
Transformed via this:
perl -pi -e \
's/write_in_full\((.*?), (".*?"), \d+\)/write_str_in_full($1, $2)/'\
$(git grep -l 'write_in_full.*"')
Signed-off-by: Jim Meyering <meyering@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-09-12 10:54:32 +02:00
|
|
|
write_str_in_full(lock->lock_fd, "\n") != 1 ||
|
2008-02-22 20:04:12 +01:00
|
|
|
close_ref(lock) < 0)) {
|
2014-12-12 09:56:46 +01:00
|
|
|
status |= error("couldn't write %s",
|
2014-10-01 12:28:32 +02:00
|
|
|
lock->lk->filename.buf);
|
2014-12-12 09:56:46 +01:00
|
|
|
rollback_lock_file(&reflog_lock);
|
|
|
|
} else if (commit_lock_file(&reflog_lock)) {
|
|
|
|
status |= error("unable to commit reflog '%s' (%s)",
|
|
|
|
log_file, strerror(errno));
|
2014-12-12 09:56:51 +01:00
|
|
|
} else if ((flags & EXPIRE_REFLOGS_UPDATE_REF) && commit_ref(lock)) {
|
2014-12-12 09:56:46 +01:00
|
|
|
status |= error("couldn't set %s", lock->ref_name);
|
2006-12-19 09:23:12 +01:00
|
|
|
}
|
|
|
|
}
|
2007-01-26 23:26:05 +01:00
|
|
|
free(log_file);
|
2006-12-19 09:23:12 +01:00
|
|
|
unlock_ref(lock);
|
|
|
|
return status;
|
2014-12-12 09:56:46 +01:00
|
|
|
|
|
|
|
failure:
|
|
|
|
rollback_lock_file(&reflog_lock);
|
|
|
|
free(log_file);
|
|
|
|
unlock_ref(lock);
|
|
|
|
return -1;
|
2006-12-19 09:23:12 +01:00
|
|
|
}
|
|
|
|
|
2008-01-26 08:53:05 +01:00
|
|
|
static int collect_reflog(const char *ref, const unsigned char *sha1, int unused, void *cb_data)
|
|
|
|
{
|
|
|
|
struct collected_reflog *e;
|
|
|
|
struct collect_reflog_cb *cb = cb_data;
|
|
|
|
size_t namelen = strlen(ref);
|
|
|
|
|
|
|
|
e = xmalloc(sizeof(*e) + namelen + 1);
|
|
|
|
hashcpy(e->sha1, sha1);
|
|
|
|
memcpy(e->reflog, ref, namelen + 1);
|
|
|
|
ALLOC_GROW(cb->e, cb->nr + 1, cb->alloc);
|
|
|
|
cb->e[cb->nr++] = e;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-06-16 08:48:46 +02:00
|
|
|
static struct reflog_expire_cfg {
|
|
|
|
struct reflog_expire_cfg *next;
|
|
|
|
unsigned long expire_total;
|
|
|
|
unsigned long expire_unreachable;
|
|
|
|
size_t len;
|
|
|
|
char pattern[FLEX_ARRAY];
|
|
|
|
} *reflog_expire_cfg, **reflog_expire_cfg_tail;
|
|
|
|
|
|
|
|
static struct reflog_expire_cfg *find_cfg_ent(const char *pattern, size_t len)
|
2006-12-27 10:47:57 +01:00
|
|
|
{
|
2008-06-16 08:48:46 +02:00
|
|
|
struct reflog_expire_cfg *ent;
|
|
|
|
|
|
|
|
if (!reflog_expire_cfg_tail)
|
|
|
|
reflog_expire_cfg_tail = &reflog_expire_cfg;
|
|
|
|
|
|
|
|
for (ent = reflog_expire_cfg; ent; ent = ent->next)
|
|
|
|
if (ent->len == len &&
|
|
|
|
!memcmp(ent->pattern, pattern, len))
|
|
|
|
return ent;
|
|
|
|
|
|
|
|
ent = xcalloc(1, (sizeof(*ent) + len));
|
|
|
|
memcpy(ent->pattern, pattern, len);
|
|
|
|
ent->len = len;
|
|
|
|
*reflog_expire_cfg_tail = ent;
|
|
|
|
reflog_expire_cfg_tail = &(ent->next);
|
|
|
|
return ent;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int parse_expire_cfg_value(const char *var, const char *value, unsigned long *expire)
|
|
|
|
{
|
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(var);
|
2013-04-18 00:38:08 +02:00
|
|
|
if (parse_expiry_date(value, expire))
|
|
|
|
return error(_("%s' for '%s' is not a valid timestamp"),
|
|
|
|
value, var);
|
2008-06-16 08:48:46 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* expiry timer slot */
|
|
|
|
#define EXPIRE_TOTAL 01
|
|
|
|
#define EXPIRE_UNREACH 02
|
|
|
|
|
|
|
|
static int reflog_expire_config(const char *var, const char *value, void *cb)
|
|
|
|
{
|
2013-01-23 07:27:37 +01:00
|
|
|
const char *pattern, *key;
|
|
|
|
int pattern_len;
|
2008-06-16 08:48:46 +02:00
|
|
|
unsigned long expire;
|
|
|
|
int slot;
|
|
|
|
struct reflog_expire_cfg *ent;
|
|
|
|
|
2013-01-23 07:27:37 +01:00
|
|
|
if (parse_config_key(var, "gc", &pattern, &pattern_len, &key) < 0)
|
2008-06-16 08:48:46 +02:00
|
|
|
return git_default_config(var, value, cb);
|
|
|
|
|
2013-01-23 07:27:37 +01:00
|
|
|
if (!strcmp(key, "reflogexpire")) {
|
2008-06-16 08:48:46 +02:00
|
|
|
slot = EXPIRE_TOTAL;
|
|
|
|
if (parse_expire_cfg_value(var, value, &expire))
|
|
|
|
return -1;
|
2013-01-23 07:27:37 +01:00
|
|
|
} else if (!strcmp(key, "reflogexpireunreachable")) {
|
2008-06-16 08:48:46 +02:00
|
|
|
slot = EXPIRE_UNREACH;
|
|
|
|
if (parse_expire_cfg_value(var, value, &expire))
|
|
|
|
return -1;
|
|
|
|
} else
|
|
|
|
return git_default_config(var, value, cb);
|
|
|
|
|
2013-01-23 07:27:37 +01:00
|
|
|
if (!pattern) {
|
2008-06-16 08:48:46 +02:00
|
|
|
switch (slot) {
|
|
|
|
case EXPIRE_TOTAL:
|
|
|
|
default_reflog_expire = expire;
|
|
|
|
break;
|
|
|
|
case EXPIRE_UNREACH:
|
|
|
|
default_reflog_expire_unreachable = expire;
|
|
|
|
break;
|
|
|
|
}
|
2008-02-11 19:50:06 +01:00
|
|
|
return 0;
|
|
|
|
}
|
2008-06-16 08:48:46 +02:00
|
|
|
|
2013-01-23 07:27:37 +01:00
|
|
|
ent = find_cfg_ent(pattern, pattern_len);
|
2008-06-16 08:48:46 +02:00
|
|
|
if (!ent)
|
|
|
|
return -1;
|
|
|
|
switch (slot) {
|
|
|
|
case EXPIRE_TOTAL:
|
|
|
|
ent->expire_total = expire;
|
|
|
|
break;
|
|
|
|
case EXPIRE_UNREACH:
|
|
|
|
ent->expire_unreachable = expire;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void set_reflog_expiry_param(struct cmd_reflog_expire_cb *cb, int slot, const char *ref)
|
|
|
|
{
|
|
|
|
struct reflog_expire_cfg *ent;
|
|
|
|
|
|
|
|
if (slot == (EXPIRE_TOTAL|EXPIRE_UNREACH))
|
|
|
|
return; /* both given explicitly -- nothing to tweak */
|
|
|
|
|
|
|
|
for (ent = reflog_expire_cfg; ent; ent = ent->next) {
|
2014-02-15 03:01:46 +01:00
|
|
|
if (!wildmatch(ent->pattern, ref, 0, NULL)) {
|
2008-06-16 08:48:46 +02:00
|
|
|
if (!(slot & EXPIRE_TOTAL))
|
|
|
|
cb->expire_total = ent->expire_total;
|
|
|
|
if (!(slot & EXPIRE_UNREACH))
|
|
|
|
cb->expire_unreachable = ent->expire_unreachable;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-06-29 07:24:49 +02:00
|
|
|
/*
|
|
|
|
* If unconfigured, make stash never expire
|
|
|
|
*/
|
|
|
|
if (!strcmp(ref, "refs/stash")) {
|
|
|
|
if (!(slot & EXPIRE_TOTAL))
|
|
|
|
cb->expire_total = 0;
|
|
|
|
if (!(slot & EXPIRE_UNREACH))
|
|
|
|
cb->expire_unreachable = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-06-16 08:48:46 +02:00
|
|
|
/* Nothing matched -- use the default value */
|
|
|
|
if (!(slot & EXPIRE_TOTAL))
|
|
|
|
cb->expire_total = default_reflog_expire;
|
|
|
|
if (!(slot & EXPIRE_UNREACH))
|
|
|
|
cb->expire_unreachable = default_reflog_expire_unreachable;
|
2006-12-27 10:47:57 +01:00
|
|
|
}
|
|
|
|
|
2006-12-19 09:23:12 +01:00
|
|
|
static int cmd_reflog_expire(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
struct cmd_reflog_expire_cb cb;
|
|
|
|
unsigned long now = time(NULL);
|
|
|
|
int i, status, do_all;
|
2008-06-16 08:48:46 +02:00
|
|
|
int explicit_expiry = 0;
|
2014-12-12 09:56:49 +01:00
|
|
|
unsigned int flags = 0;
|
2006-12-19 09:23:12 +01:00
|
|
|
|
2010-02-27 04:50:03 +01:00
|
|
|
default_reflog_expire_unreachable = now - 30 * 24 * 3600;
|
|
|
|
default_reflog_expire = now - 90 * 24 * 3600;
|
2008-05-14 19:46:53 +02:00
|
|
|
git_config(reflog_expire_config, NULL);
|
2006-12-27 10:47:57 +01:00
|
|
|
|
2006-12-19 09:23:12 +01:00
|
|
|
save_commit_buffer = 0;
|
|
|
|
do_all = status = 0;
|
|
|
|
memset(&cb, 0, sizeof(cb));
|
2006-12-27 10:47:57 +01:00
|
|
|
|
|
|
|
cb.expire_total = default_reflog_expire;
|
|
|
|
cb.expire_unreachable = default_reflog_expire_unreachable;
|
2006-12-19 09:23:12 +01:00
|
|
|
|
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
const char *arg = argv[i];
|
|
|
|
if (!strcmp(arg, "--dry-run") || !strcmp(arg, "-n"))
|
2014-12-12 09:56:50 +01:00
|
|
|
flags |= EXPIRE_REFLOGS_DRY_RUN;
|
2013-11-30 21:55:40 +01:00
|
|
|
else if (starts_with(arg, "--expire=")) {
|
2013-04-18 00:38:08 +02:00
|
|
|
if (parse_expiry_date(arg + 9, &cb.expire_total))
|
|
|
|
die(_("'%s' is not a valid timestamp"), arg);
|
2008-06-16 08:48:46 +02:00
|
|
|
explicit_expiry |= EXPIRE_TOTAL;
|
|
|
|
}
|
2013-11-30 21:55:40 +01:00
|
|
|
else if (starts_with(arg, "--expire-unreachable=")) {
|
2013-04-18 00:38:08 +02:00
|
|
|
if (parse_expiry_date(arg + 21, &cb.expire_unreachable))
|
|
|
|
die(_("'%s' is not a valid timestamp"), arg);
|
2008-06-16 08:48:46 +02:00
|
|
|
explicit_expiry |= EXPIRE_UNREACH;
|
|
|
|
}
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
else if (!strcmp(arg, "--stale-fix"))
|
|
|
|
cb.stalefix = 1;
|
2008-02-22 19:56:50 +01:00
|
|
|
else if (!strcmp(arg, "--rewrite"))
|
|
|
|
cb.rewrite = 1;
|
2008-02-22 20:04:12 +01:00
|
|
|
else if (!strcmp(arg, "--updateref"))
|
2014-12-12 09:56:51 +01:00
|
|
|
flags |= EXPIRE_REFLOGS_UPDATE_REF;
|
2006-12-19 09:23:12 +01:00
|
|
|
else if (!strcmp(arg, "--all"))
|
|
|
|
do_all = 1;
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
else if (!strcmp(arg, "--verbose"))
|
|
|
|
cb.verbose = 1;
|
2006-12-19 09:23:12 +01:00
|
|
|
else if (!strcmp(arg, "--")) {
|
|
|
|
i++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if (arg[0] == '-')
|
|
|
|
usage(reflog_expire_usage);
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
2008-06-16 08:48:46 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We can trust the commits and objects reachable from refs
|
|
|
|
* even in older repository. We cannot trust what's reachable
|
|
|
|
* from reflog if the repository was pruned with older git.
|
|
|
|
*/
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
if (cb.stalefix) {
|
|
|
|
init_revisions(&cb.revs, prefix);
|
|
|
|
if (cb.verbose)
|
|
|
|
printf("Marking reachable objects...");
|
prune: keep objects reachable from recent objects
Our current strategy with prune is that an object falls into
one of three categories:
1. Reachable (from ref tips, reflogs, index, etc).
2. Not reachable, but recent (based on the --expire time).
3. Not reachable and not recent.
We keep objects from (1) and (2), but prune objects in (3).
The point of (2) is that these objects may be part of an
in-progress operation that has not yet updated any refs.
However, it is not always the case that objects for an
in-progress operation will have a recent mtime. For example,
the object database may have an old copy of a blob (from an
abandoned operation, a branch that was deleted, etc). If we
create a new tree that points to it, a simultaneous prune
will leave our tree, but delete the blob. Referencing that
tree with a commit will then work (we check that the tree is
in the object database, but not that all of its referred
objects are), as will mentioning the commit in a ref. But
the resulting repo is corrupt; we are missing the blob
reachable from a ref.
One way to solve this is to be more thorough when
referencing a sha1: make sure that not only do we have that
sha1, but that we have objects it refers to, and so forth
recursively. The problem is that this is very expensive.
Creating a parent link would require traversing the entire
object graph!
Instead, this patch pushes the extra work onto prune, which
runs less frequently (and has to look at the whole object
graph anyway). It creates a new category of objects: objects
which are not recent, but which are reachable from a recent
object. We do not prune these objects, just like the
reachable and recent ones.
This lets us avoid the recursive check above, because if we
have an object, even if it is unreachable, we should have
its referent. We can make a simple inductive argument that
with this patch, this property holds (that there are no
objects with missing referents in the repository):
0. When we have no objects, we have nothing to refer or be
referred to, so the property holds.
1. If we add objects to the repository, their direct
referents must generally exist (e.g., if you create a
tree, the blobs it references must exist; if you create
a commit to point at the tree, the tree must exist).
This is already the case before this patch. And it is
not 100% foolproof (you can make bogus objects using
`git hash-object`, for example), but it should be the
case for normal usage.
Therefore for any sequence of object additions, the
property will continue to hold.
2. If we remove objects from the repository, then we will
not remove a child object (like a blob) if an object
that refers to it is being kept. That is the part
implemented by this patch.
Note, however, that our reachability check and the
actual pruning are not atomic. So it _is_ still
possible to violate the property (e.g., an object
becomes referenced just as we are deleting it). This
patch is shooting for eliminating problems where the
mtimes of dependent objects differ by hours or days,
and one is dropped without the other. It does nothing
to help with short races.
Naively, the simplest way to implement this would be to add
all recent objects as tips to the reachability traversal.
However, this does not perform well. In a recently-packed
repository, all reachable objects will also be recent, and
therefore we have to look at each object twice. This patch
instead performs the reachability traversal, then follows up
with a second traversal for recent objects, skipping any
that have already been marked.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-10-16 00:41:35 +02:00
|
|
|
mark_reachable_objects(&cb.revs, 0, 0, NULL);
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
if (cb.verbose)
|
|
|
|
putchar('\n');
|
|
|
|
}
|
|
|
|
|
2008-01-26 08:53:05 +01:00
|
|
|
if (do_all) {
|
|
|
|
struct collect_reflog_cb collected;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
memset(&collected, 0, sizeof(collected));
|
|
|
|
for_each_reflog(collect_reflog, &collected);
|
|
|
|
for (i = 0; i < collected.nr; i++) {
|
|
|
|
struct collected_reflog *e = collected.e[i];
|
2008-06-16 08:48:46 +02:00
|
|
|
set_reflog_expiry_param(&cb, explicit_expiry, e->reflog);
|
2014-12-12 09:56:49 +01:00
|
|
|
status |= expire_reflog(e->reflog, e->sha1, flags, &cb);
|
2008-01-26 08:53:05 +01:00
|
|
|
free(e);
|
|
|
|
}
|
|
|
|
free(collected.e);
|
|
|
|
}
|
|
|
|
|
2008-08-10 22:22:21 +02:00
|
|
|
for (; i < argc; i++) {
|
|
|
|
char *ref;
|
2006-12-19 09:23:12 +01:00
|
|
|
unsigned char sha1[20];
|
2008-08-10 22:22:21 +02:00
|
|
|
if (!dwim_log(argv[i], strlen(argv[i]), sha1, &ref)) {
|
|
|
|
status |= error("%s points nowhere!", argv[i]);
|
2006-12-19 09:23:12 +01:00
|
|
|
continue;
|
|
|
|
}
|
2008-06-16 08:48:46 +02:00
|
|
|
set_reflog_expiry_param(&cb, explicit_expiry, ref);
|
2014-12-12 09:56:49 +01:00
|
|
|
status |= expire_reflog(ref, sha1, flags, &cb);
|
2006-12-19 09:23:12 +01:00
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2007-10-17 03:50:45 +02:00
|
|
|
static int count_reflog_ent(unsigned char *osha1, unsigned char *nsha1,
|
|
|
|
const char *email, unsigned long timestamp, int tz,
|
|
|
|
const char *message, void *cb_data)
|
|
|
|
{
|
|
|
|
struct cmd_reflog_expire_cb *cb = cb_data;
|
|
|
|
if (!cb->expire_total || timestamp < cb->expire_total)
|
|
|
|
cb->recno++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cmd_reflog_delete(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
struct cmd_reflog_expire_cb cb;
|
|
|
|
int i, status = 0;
|
2014-12-12 09:56:49 +01:00
|
|
|
unsigned int flags = 0;
|
2007-10-17 03:50:45 +02:00
|
|
|
|
|
|
|
memset(&cb, 0, sizeof(cb));
|
|
|
|
|
|
|
|
for (i = 1; i < argc; i++) {
|
2008-02-22 22:08:59 +01:00
|
|
|
const char *arg = argv[i];
|
|
|
|
if (!strcmp(arg, "--dry-run") || !strcmp(arg, "-n"))
|
2014-12-12 09:56:50 +01:00
|
|
|
flags |= EXPIRE_REFLOGS_DRY_RUN;
|
2008-02-22 19:56:50 +01:00
|
|
|
else if (!strcmp(arg, "--rewrite"))
|
|
|
|
cb.rewrite = 1;
|
2008-02-22 20:04:12 +01:00
|
|
|
else if (!strcmp(arg, "--updateref"))
|
2014-12-12 09:56:51 +01:00
|
|
|
flags |= EXPIRE_REFLOGS_UPDATE_REF;
|
2008-02-22 22:08:59 +01:00
|
|
|
else if (!strcmp(arg, "--verbose"))
|
|
|
|
cb.verbose = 1;
|
|
|
|
else if (!strcmp(arg, "--")) {
|
|
|
|
i++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if (arg[0] == '-')
|
|
|
|
usage(reflog_delete_usage);
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (argc - i < 1)
|
|
|
|
return error("Nothing to delete?");
|
|
|
|
|
|
|
|
for ( ; i < argc; i++) {
|
2007-10-17 03:50:45 +02:00
|
|
|
const char *spec = strstr(argv[i], "@{");
|
|
|
|
unsigned char sha1[20];
|
|
|
|
char *ep, *ref;
|
|
|
|
int recno;
|
|
|
|
|
|
|
|
if (!spec) {
|
2008-01-05 02:11:37 +01:00
|
|
|
status |= error("Not a reflog: %s", argv[i]);
|
2007-10-17 03:50:45 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2008-08-11 08:21:25 +02:00
|
|
|
if (!dwim_log(argv[i], spec - argv[i], sha1, &ref)) {
|
|
|
|
status |= error("no reflog for '%s'", argv[i]);
|
2007-10-17 03:50:45 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
recno = strtoul(spec + 2, &ep, 10);
|
|
|
|
if (*ep == '}') {
|
|
|
|
cb.recno = -recno;
|
|
|
|
for_each_reflog_ent(ref, count_reflog_ent, &cb);
|
|
|
|
} else {
|
|
|
|
cb.expire_total = approxidate(spec + 2);
|
|
|
|
for_each_reflog_ent(ref, count_reflog_ent, &cb);
|
|
|
|
cb.expire_total = 0;
|
|
|
|
}
|
|
|
|
|
2014-12-12 09:56:49 +01:00
|
|
|
status |= expire_reflog(ref, sha1, flags, &cb);
|
2007-10-17 03:50:45 +02:00
|
|
|
free(ref);
|
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
reflog expire --fix-stale
The logic in an earlier round to detect reflog entries that
point at a broken commit was not sufficient. Just like we do
not trust presense of a commit during pack transfer (we trust
only our refs), we should not trust a commit's presense, even if
the tree of that commit is complete.
A repository that had reflog enabled on some of the refs that
was rewound and then run git-repack or git-prune from older
versions of git can have reflog entries that point at a commit
that still exist but lack commits (or trees and blobs needed for
that commit) between it and some commit that is reachable from
one of the refs.
This revamps the logic -- the definition of "broken commit"
becomes: a commit that is not reachable from any of the refs and
there is a missing object among the commit, tree, or blob
objects reachable from it that is not reachable from any of the
refs. Entries in the reflog that refer to such a commit are
expired.
Since this computation involves traversing all the reachable
objects, i.e. it has the same cost as 'git prune', it is enabled
only when a new option --fix-stale. Fortunately, once this is
run, we should not have to ever worry about missing objects,
because the current prune and pack-objects know about reflogs
and protect objects referred by them.
Unfortunately, this will be absolutely necessary to help people
migrate to the newer prune and repack.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-06 11:16:19 +01:00
|
|
|
/*
|
|
|
|
* main "reflog"
|
|
|
|
*/
|
|
|
|
|
2006-12-19 09:23:12 +01:00
|
|
|
static const char reflog_usage[] =
|
2009-08-05 17:36:28 +02:00
|
|
|
"git reflog [ show | expire | delete ]";
|
2006-12-19 09:23:12 +01:00
|
|
|
|
|
|
|
int cmd_reflog(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2009-11-09 16:05:01 +01:00
|
|
|
if (argc > 1 && !strcmp(argv[1], "-h"))
|
|
|
|
usage(reflog_usage);
|
|
|
|
|
2007-02-08 18:51:56 +01:00
|
|
|
/* With no command, we default to showing it. */
|
|
|
|
if (argc < 2 || *argv[1] == '-')
|
|
|
|
return cmd_log_reflog(argc, argv, prefix);
|
|
|
|
|
|
|
|
if (!strcmp(argv[1], "show"))
|
|
|
|
return cmd_log_reflog(argc - 1, argv + 1, prefix);
|
|
|
|
|
|
|
|
if (!strcmp(argv[1], "expire"))
|
2006-12-19 09:23:12 +01:00
|
|
|
return cmd_reflog_expire(argc - 1, argv + 1, prefix);
|
2007-02-08 18:51:56 +01:00
|
|
|
|
2007-10-17 03:50:45 +02:00
|
|
|
if (!strcmp(argv[1], "delete"))
|
|
|
|
return cmd_reflog_delete(argc - 1, argv + 1, prefix);
|
|
|
|
|
2011-08-01 13:20:42 +02:00
|
|
|
return cmd_log_reflog(argc, argv, prefix);
|
2006-12-19 09:23:12 +01:00
|
|
|
}
|