2006-12-19 08:23:12 +00:00
|
|
|
#include "cache.h"
|
|
|
|
#include "builtin.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "refs.h"
|
|
|
|
#include "dir.h"
|
2006-12-22 08:46:33 +00: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 10:16:19 +00:00
|
|
|
#include "diff.h"
|
|
|
|
#include "revision.h"
|
|
|
|
#include "reachable.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* reflog expire
|
|
|
|
*/
|
|
|
|
|
|
|
|
static const char reflog_expire_usage[] =
|
2007-02-08 17:51:56 +00:00
|
|
|
"git-reflog (show|expire) [--verbose] [--dry-run] [--stale-fix] [--expire=<time>] [--expire-unreachable=<time>] [--all] <refs>...";
|
2006-12-19 08:23:12 +00:00
|
|
|
|
2006-12-27 09:47:57 +00:00
|
|
|
static unsigned long default_reflog_expire;
|
|
|
|
static unsigned long default_reflog_expire_unreachable;
|
|
|
|
|
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 10:16:19 +00:00
|
|
|
struct cmd_reflog_expire_cb {
|
|
|
|
struct rev_info revs;
|
|
|
|
int dry_run;
|
|
|
|
int stalefix;
|
|
|
|
int verbose;
|
|
|
|
unsigned long expire_total;
|
|
|
|
unsigned long expire_unreachable;
|
|
|
|
};
|
|
|
|
|
2006-12-19 08:23:12 +00:00
|
|
|
struct expire_reflog_cb {
|
|
|
|
FILE *newlog;
|
|
|
|
const char *ref;
|
|
|
|
struct commit *ref_commit;
|
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 10:16:19 +00:00
|
|
|
struct cmd_reflog_expire_cb *cmd;
|
2006-12-19 08:23:12 +00:00
|
|
|
};
|
|
|
|
|
2007-01-07 06:32:41 +00:00
|
|
|
#define INCOMPLETE (1u<<10)
|
|
|
|
#define STUDYING (1u<<11)
|
|
|
|
|
2006-12-22 08:46:33 +00:00
|
|
|
static int tree_is_complete(const unsigned char *sha1)
|
|
|
|
{
|
|
|
|
struct tree_desc desc;
|
2007-01-07 06:32:41 +00:00
|
|
|
struct name_entry entry;
|
|
|
|
int complete;
|
|
|
|
struct tree *tree;
|
2006-12-22 08:46:33 +00:00
|
|
|
|
2007-01-07 06:32:41 +00:00
|
|
|
tree = lookup_tree(sha1);
|
|
|
|
if (!tree)
|
2006-12-22 08:46:33 +00:00
|
|
|
return 0;
|
2007-01-07 06:32:41 +00:00
|
|
|
if (tree->object.flags & SEEN)
|
|
|
|
return 1;
|
|
|
|
if (tree->object.flags & INCOMPLETE)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
desc.buf = tree->buffer;
|
|
|
|
desc.size = tree->size;
|
|
|
|
if (!desc.buf) {
|
2007-02-26 19:55:59 +00:00
|
|
|
enum object_type type;
|
|
|
|
void *data = read_sha1_file(sha1, &type, &desc.size);
|
2007-01-07 06:32:41 +00:00
|
|
|
if (!data) {
|
|
|
|
tree->object.flags |= INCOMPLETE;
|
2006-12-22 08:46:33 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2007-01-07 06:32:41 +00:00
|
|
|
desc.buf = data;
|
|
|
|
tree->buffer = data;
|
2006-12-22 08:46:33 +00:00
|
|
|
}
|
2007-01-07 06:32:41 +00: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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(tree->buffer);
|
|
|
|
tree->buffer = NULL;
|
2006-12-22 08:46:33 +00:00
|
|
|
|
2007-01-07 06:32:41 +00: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 10:16:19 +00: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 06:32:41 +00: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 10:16:19 +00:00
|
|
|
* necessary objects.
|
|
|
|
*/
|
2007-01-07 06:32:41 +00: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 10:16:19 +00:00
|
|
|
struct commit *c =
|
|
|
|
(struct commit *)found.objects[i].item;
|
2007-01-07 06:32:41 +00: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 10:16:19 +00:00
|
|
|
is_incomplete = 1;
|
2007-01-07 06:32:41 +00: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 10:16:19 +00: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 06:32:41 +00: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 10:16:19 +00:00
|
|
|
/* free object arrays */
|
|
|
|
free(study.objects);
|
|
|
|
free(found.objects);
|
|
|
|
return !is_incomplete;
|
|
|
|
}
|
|
|
|
|
2006-12-19 08:23:12 +00:00
|
|
|
static int keep_entry(struct commit **it, unsigned char *sha1)
|
|
|
|
{
|
2006-12-22 08:46:33 +00:00
|
|
|
struct commit *commit;
|
|
|
|
|
2006-12-19 08:23:12 +00:00
|
|
|
if (is_null_sha1(sha1))
|
|
|
|
return 1;
|
2006-12-22 08:46:33 +00: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 10:16:19 +00: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 08:46:33 +00:00
|
|
|
return 0;
|
|
|
|
*it = commit;
|
|
|
|
return 1;
|
2006-12-19 08:23:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int expire_reflog_ent(unsigned char *osha1, unsigned char *nsha1,
|
2007-01-08 00:59:54 +00:00
|
|
|
const char *email, unsigned long timestamp, int tz,
|
|
|
|
const char *message, void *cb_data)
|
2006-12-19 08:23:12 +00:00
|
|
|
{
|
|
|
|
struct expire_reflog_cb *cb = cb_data;
|
|
|
|
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 10:16:19 +00:00
|
|
|
if (timestamp < cb->cmd->expire_total)
|
2006-12-19 08:23:12 +00:00
|
|
|
goto prune;
|
|
|
|
|
2007-01-12 03:56:43 +00: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 10:16:19 +00:00
|
|
|
if (cb->cmd->stalefix &&
|
|
|
|
(!keep_entry(&old, osha1) || !keep_entry(&new, nsha1)))
|
2006-12-19 08:23:12 +00:00
|
|
|
goto prune;
|
|
|
|
|
2007-01-12 03:56:43 +00:00
|
|
|
if (timestamp < cb->cmd->expire_unreachable) {
|
|
|
|
if (!cb->ref_commit)
|
|
|
|
goto prune;
|
|
|
|
if (!old && !is_null_sha1(osha1))
|
|
|
|
old = lookup_commit_reference_gently(osha1, 1);
|
|
|
|
if (!new && !is_null_sha1(nsha1))
|
|
|
|
new = lookup_commit_reference_gently(nsha1, 1);
|
2007-02-14 00:50:32 +00:00
|
|
|
if ((old && !in_merge_bases(old, &cb->ref_commit, 1)) ||
|
|
|
|
(new && !in_merge_bases(new, &cb->ref_commit, 1)))
|
2007-01-12 03:56:43 +00:00
|
|
|
goto prune;
|
|
|
|
}
|
2006-12-19 08:23:12 +00:00
|
|
|
|
2007-01-08 00:59:54 +00:00
|
|
|
if (cb->newlog) {
|
|
|
|
char sign = (tz < 0) ? '-' : '+';
|
|
|
|
int zone = (tz < 0) ? (-tz) : tz;
|
|
|
|
fprintf(cb->newlog, "%s %s %s %lu %c%04d\t%s",
|
|
|
|
sha1_to_hex(osha1), sha1_to_hex(nsha1),
|
|
|
|
email, timestamp, sign, zone,
|
|
|
|
message);
|
|
|
|
}
|
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 10:16:19 +00:00
|
|
|
if (cb->cmd->verbose)
|
2007-01-08 00:59:54 +00:00
|
|
|
printf("keep %s", message);
|
2006-12-19 08:23:12 +00:00
|
|
|
return 0;
|
|
|
|
prune:
|
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 10:16:19 +00:00
|
|
|
if (!cb->newlog || cb->cmd->verbose)
|
2007-01-08 00:59:54 +00:00
|
|
|
printf("%sprune %s", cb->newlog ? "" : "would ", message);
|
2006-12-19 08:23:12 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int expire_reflog(const char *ref, const unsigned char *sha1, int unused, void *cb_data)
|
|
|
|
{
|
|
|
|
struct cmd_reflog_expire_cb *cmd = cb_data;
|
|
|
|
struct expire_reflog_cb cb;
|
|
|
|
struct ref_lock *lock;
|
2007-01-26 22:26:05 +00:00
|
|
|
char *log_file, *newlog_path = NULL;
|
2006-12-19 08:23:12 +00:00
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
memset(&cb, 0, sizeof(cb));
|
|
|
|
/* we take the lock for the ref itself to prevent it from
|
|
|
|
* getting updated.
|
|
|
|
*/
|
2007-02-03 18:25:43 +00:00
|
|
|
lock = lock_any_ref_for_update(ref, sha1);
|
2006-12-19 08:23:12 +00:00
|
|
|
if (!lock)
|
|
|
|
return error("cannot lock ref '%s'", ref);
|
2007-01-26 22:26:05 +00:00
|
|
|
log_file = xstrdup(git_path("logs/%s", ref));
|
|
|
|
if (!file_exists(log_file))
|
2006-12-19 08:23:12 +00:00
|
|
|
goto finish;
|
|
|
|
if (!cmd->dry_run) {
|
|
|
|
newlog_path = xstrdup(git_path("logs/%s.lock", ref));
|
|
|
|
cb.newlog = fopen(newlog_path, "w");
|
|
|
|
}
|
|
|
|
|
|
|
|
cb.ref_commit = lookup_commit_reference_gently(sha1, 1);
|
|
|
|
cb.ref = ref;
|
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 10:16:19 +00:00
|
|
|
cb.cmd = cmd;
|
2006-12-19 08:23:12 +00:00
|
|
|
for_each_reflog_ent(ref, expire_reflog_ent, &cb);
|
|
|
|
finish:
|
|
|
|
if (cb.newlog) {
|
|
|
|
if (fclose(cb.newlog))
|
|
|
|
status |= error("%s: %s", strerror(errno),
|
|
|
|
newlog_path);
|
2007-01-26 22:26:05 +00:00
|
|
|
if (rename(newlog_path, log_file)) {
|
2006-12-19 08:23:12 +00:00
|
|
|
status |= error("cannot rename %s to %s",
|
2007-01-26 22:26:05 +00:00
|
|
|
newlog_path, log_file);
|
2006-12-19 08:23:12 +00:00
|
|
|
unlink(newlog_path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(newlog_path);
|
2007-01-26 22:26:05 +00:00
|
|
|
free(log_file);
|
2006-12-19 08:23:12 +00:00
|
|
|
unlock_ref(lock);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-12-27 09:47:57 +00:00
|
|
|
static int reflog_expire_config(const char *var, const char *value)
|
|
|
|
{
|
|
|
|
if (!strcmp(var, "gc.reflogexpire"))
|
|
|
|
default_reflog_expire = approxidate(value);
|
|
|
|
else if (!strcmp(var, "gc.reflogexpireunreachable"))
|
|
|
|
default_reflog_expire_unreachable = approxidate(value);
|
|
|
|
else
|
|
|
|
return git_default_config(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-12-19 08:23:12 +00: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;
|
|
|
|
|
2006-12-27 09:47:57 +00:00
|
|
|
git_config(reflog_expire_config);
|
|
|
|
|
2006-12-19 08:23:12 +00:00
|
|
|
save_commit_buffer = 0;
|
|
|
|
do_all = status = 0;
|
|
|
|
memset(&cb, 0, sizeof(cb));
|
2006-12-27 09:47:57 +00:00
|
|
|
|
|
|
|
if (!default_reflog_expire_unreachable)
|
|
|
|
default_reflog_expire_unreachable = now - 30 * 24 * 3600;
|
|
|
|
if (!default_reflog_expire)
|
|
|
|
default_reflog_expire = now - 90 * 24 * 3600;
|
|
|
|
cb.expire_total = default_reflog_expire;
|
|
|
|
cb.expire_unreachable = default_reflog_expire_unreachable;
|
2006-12-19 08:23:12 +00: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 10:16:19 +00: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.
|
|
|
|
*/
|
|
|
|
|
2006-12-19 08:23:12 +00:00
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
const char *arg = argv[i];
|
|
|
|
if (!strcmp(arg, "--dry-run") || !strcmp(arg, "-n"))
|
|
|
|
cb.dry_run = 1;
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
else if (!prefixcmp(arg, "--expire="))
|
2006-12-19 08:23:12 +00:00
|
|
|
cb.expire_total = approxidate(arg + 9);
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
else if (!prefixcmp(arg, "--expire-unreachable="))
|
2006-12-19 08:23:12 +00:00
|
|
|
cb.expire_unreachable = approxidate(arg + 21);
|
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 10:16:19 +00:00
|
|
|
else if (!strcmp(arg, "--stale-fix"))
|
|
|
|
cb.stalefix = 1;
|
2006-12-19 08:23:12 +00: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 10:16:19 +00:00
|
|
|
else if (!strcmp(arg, "--verbose"))
|
|
|
|
cb.verbose = 1;
|
2006-12-19 08:23:12 +00:00
|
|
|
else if (!strcmp(arg, "--")) {
|
|
|
|
i++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if (arg[0] == '-')
|
|
|
|
usage(reflog_expire_usage);
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
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 10:16:19 +00:00
|
|
|
if (cb.stalefix) {
|
|
|
|
init_revisions(&cb.revs, prefix);
|
|
|
|
if (cb.verbose)
|
|
|
|
printf("Marking reachable objects...");
|
|
|
|
mark_reachable_objects(&cb.revs, 0);
|
|
|
|
if (cb.verbose)
|
|
|
|
putchar('\n');
|
|
|
|
}
|
|
|
|
|
2006-12-19 08:23:12 +00:00
|
|
|
if (do_all)
|
2007-02-03 18:25:43 +00:00
|
|
|
status |= for_each_reflog(expire_reflog, &cb);
|
2006-12-19 08:23:12 +00:00
|
|
|
while (i < argc) {
|
|
|
|
const char *ref = argv[i++];
|
|
|
|
unsigned char sha1[20];
|
|
|
|
if (!resolve_ref(ref, sha1, 1, NULL)) {
|
|
|
|
status |= error("%s points nowhere!", ref);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
status |= expire_reflog(ref, sha1, 0, &cb);
|
|
|
|
}
|
|
|
|
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 10:16:19 +00:00
|
|
|
/*
|
|
|
|
* main "reflog"
|
|
|
|
*/
|
|
|
|
|
2006-12-19 08:23:12 +00:00
|
|
|
static const char reflog_usage[] =
|
|
|
|
"git-reflog (expire | ...)";
|
|
|
|
|
|
|
|
int cmd_reflog(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2007-02-08 17:51:56 +00: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 08:23:12 +00:00
|
|
|
return cmd_reflog_expire(argc - 1, argv + 1, prefix);
|
2007-02-08 17:51:56 +00:00
|
|
|
|
|
|
|
/* Not a recognized reflog command..*/
|
|
|
|
usage(reflog_usage);
|
2006-12-19 08:23:12 +00:00
|
|
|
}
|