2008-02-26 00:46:04 +03:00
|
|
|
#ifndef GIT_FSCK_H
|
|
|
|
#define GIT_FSCK_H
|
|
|
|
|
2008-02-26 00:46:08 +03:00
|
|
|
#define FSCK_ERROR 1
|
|
|
|
#define FSCK_WARN 2
|
2015-06-22 18:26:48 +03:00
|
|
|
#define FSCK_IGNORE 3
|
2008-02-26 00:46:08 +03:00
|
|
|
|
2015-06-22 18:25:00 +03:00
|
|
|
struct fsck_options;
|
|
|
|
|
2015-06-22 18:25:25 +03:00
|
|
|
void fsck_set_msg_type(struct fsck_options *options,
|
|
|
|
const char *msg_id, const char *msg_type);
|
|
|
|
void fsck_set_msg_types(struct fsck_options *options, const char *values);
|
2015-06-22 18:25:31 +03:00
|
|
|
int is_valid_msg_type(const char *msg_id, const char *msg_type);
|
2015-06-22 18:25:25 +03:00
|
|
|
|
2008-02-26 00:46:04 +03:00
|
|
|
/*
|
|
|
|
* callback function for fsck_walk
|
|
|
|
* type is the expected type of the object or OBJ_ANY
|
|
|
|
* the return value is:
|
|
|
|
* 0 everything OK
|
|
|
|
* <0 error signaled and abort
|
|
|
|
* >0 error signaled and do not abort
|
|
|
|
*/
|
2015-06-22 18:25:00 +03:00
|
|
|
typedef int (*fsck_walk_func)(struct object *obj, int type, void *data, struct fsck_options *options);
|
2008-02-26 00:46:04 +03:00
|
|
|
|
2008-02-26 00:46:08 +03:00
|
|
|
/* callback for fsck_object, type is FSCK_ERROR or FSCK_WARN */
|
2016-07-17 13:59:57 +03:00
|
|
|
typedef int (*fsck_error)(struct fsck_options *o,
|
|
|
|
struct object *obj, int type, const char *message);
|
2008-02-26 00:46:08 +03:00
|
|
|
|
2016-07-17 13:59:57 +03:00
|
|
|
int fsck_error_function(struct fsck_options *o,
|
|
|
|
struct object *obj, int type, const char *message);
|
2008-02-26 00:46:09 +03:00
|
|
|
|
2015-06-22 18:25:00 +03:00
|
|
|
struct fsck_options {
|
|
|
|
fsck_walk_func walk;
|
|
|
|
fsck_error error_func;
|
|
|
|
unsigned strict:1;
|
2015-06-22 18:25:25 +03:00
|
|
|
int *msg_type;
|
2017-03-31 04:40:00 +03:00
|
|
|
struct oid_array *skiplist;
|
2016-07-17 13:59:49 +03:00
|
|
|
struct decoration *object_names;
|
2015-06-22 18:25:00 +03:00
|
|
|
};
|
|
|
|
|
2015-06-22 18:25:25 +03:00
|
|
|
#define FSCK_OPTIONS_DEFAULT { NULL, fsck_error_function, 0, NULL }
|
|
|
|
#define FSCK_OPTIONS_STRICT { NULL, fsck_error_function, 1, NULL }
|
2015-06-22 18:25:00 +03:00
|
|
|
|
2008-02-26 00:46:04 +03:00
|
|
|
/* descend in all linked child objects
|
|
|
|
* the return value is:
|
|
|
|
* -1 error in processing the object
|
|
|
|
* <0 return value of the callback, which lead to an abort
|
2009-04-17 22:13:30 +04:00
|
|
|
* >0 return value of the first signaled error >0 (in the case of no other errors)
|
2008-02-26 00:46:04 +03:00
|
|
|
* 0 everything OK
|
|
|
|
*/
|
2015-06-22 18:25:00 +03:00
|
|
|
int fsck_walk(struct object *obj, void *data, struct fsck_options *options);
|
2014-09-10 17:52:51 +04:00
|
|
|
/* If NULL is passed for data, we assume the object is local and read it. */
|
|
|
|
int fsck_object(struct object *obj, void *data, unsigned long size,
|
2015-06-22 18:25:00 +03:00
|
|
|
struct fsck_options *options);
|
2008-02-26 00:46:04 +03:00
|
|
|
|
fsck: detect gitmodules files
In preparation for performing fsck checks on .gitmodules
files, this commit plumbs in the actual detection of the
files. Note that unlike most other fsck checks, this cannot
be a property of a single object: we must know that the
object is found at a ".gitmodules" path at the root tree of
a commit.
Since the fsck code only sees one object at a time, we have
to mark the related objects to fit the puzzle together. When
we see a commit we mark its tree as a root tree, and when
we see a root tree with a .gitmodules file, we mark the
corresponding blob to be checked.
In an ideal world, we'd check the objects in topological
order: commits followed by trees followed by blobs. In that
case we can avoid ever loading an object twice, since all
markings would be complete by the time we get to the marked
objects. And indeed, if we are checking a single packfile,
this is the order in which Git will generally write the
objects. But we can't count on that:
1. git-fsck may show us the objects in arbitrary order
(loose objects are fed in sha1 order, but we may also
have multiple packs, and we process each pack fully in
sequence).
2. The type ordering is just what git-pack-objects happens
to write now. The pack format does not require a
specific order, and it's possible that future versions
of Git (or a custom version trying to fool official
Git's fsck checks!) may order it differently.
3. We may not even be fscking all of the relevant objects
at once. Consider pushing with transfer.fsckObjects,
where one push adds a blob at path "foo", and then a
second push adds the same blob at path ".gitmodules".
The blob is not part of the second push at all, but we
need to mark and check it.
So in the general case, we need to make up to three passes
over the objects: once to make sure we've seen all commits,
then once to cover any trees we might have missed, and then
a final pass to cover any .gitmodules blobs we found in the
second pass.
We can simplify things a bit by loosening the requirement
that we find .gitmodules only at root trees. Technically
a file like "subdir/.gitmodules" is not parsed by Git, but
it's not unreasonable for us to declare that Git is aware of
all ".gitmodules" files and make them eligible for checking.
That lets us drop the root-tree requirement, which
eliminates one pass entirely. And it makes our worst case
much better: instead of potentially queueing every root tree
to be re-examined, the worst case is that we queue each
unique .gitmodules blob for a second look.
This patch just adds the boilerplate to find .gitmodules
files. The actual content checks will come in a subsequent
commit.
Signed-off-by: Jeff King <peff@peff.net>
2018-05-03 00:20:08 +03:00
|
|
|
/*
|
|
|
|
* Some fsck checks are context-dependent, and may end up queued; run this
|
|
|
|
* after completing all fsck_object() calls in order to resolve any remaining
|
|
|
|
* checks.
|
|
|
|
*/
|
|
|
|
int fsck_finish(struct fsck_options *options);
|
|
|
|
|
2008-02-26 00:46:04 +03:00
|
|
|
#endif
|