fsck.ocfs2.checks man page on OpenSuSE
[printable version]
fsck.ocfs2.checks(8) OCFS2 Manual Pages fsck.ocfs2.checks(8)
NAME
fsck.ocfs2.checks - Consistency checks that fsck.ocfs2(8) performs and
its means for fixing inconsistencies.
DESCRIPTION
fsck.ocfs2(8) is used to check an OCFS2 file system. It performs many
consistency checks and will offer to fix faults that it finds. This
man page lists the problems it may find and describes their fixes. The
problems are indexed by the error number that fsck.ocfs2(8) emits when
it describes the problem and asks if it should be fixed.
The prompts are constructed such that answering 'no' results in no
changes to the file system. This may result in errors later on that
stop fsck.ocfs2(8) from proceeding.
CHECKS
EB_BLKNO
Extent blocks contain a record of the disk block where they are
located. An extent block was found at a block that didn't match its
recorded location.
Answering yes will update the data structure in the extent block to
reflect its real location on disk.
EB_GEN
Extent blocks are created with a generation number to match the genera‐
tion number of the volume at the time of creation. An extent block was
found which contains a generation number that doesn't match.
Answering yes implies that the generation number is correct and that
the extent block is from a previous file system. The extent block will
be ignored and the file that contains it will lose the data it refer‐
enced.
EB_GEN_FIX
Extent blocks are created with a generation number to match the genera‐
tion number of the volume at the time of creation. An extent block was
found which contains a generation number that doesn't match.
Answering yes implies that the generation number in the extent block is
incorrect and that the extent block is valid. The generation number in
the block is updated to match the generation number in the volume.
EXTENT_MARKED_UNWRITTEN
An extent record has the UNWRITTEN flag set, but the filesystem feature
set does not include unwritten extents.
Answering yes clears the UNWRITTEN flag. This is safe to do; as the
feature is disabled anyway.
EXTENT_MARKED_REFCOUNTED
An extent record has the REFCOUNTED flag set, but neither the filesys‐
tem nor the file has the REFCOUNTED flag set.
Answering yes clears the REFCOUNTED flag.
EXTENT_BLKNO_UNALIGNED
The block that marks the start of an extent should always fall on the
start of a cluster. An extent was found that starts part-way into a
cluster.
Answering yes moves the start of the extent back to the start of the
addressed cluster. This may add data to the middle of the file that
contains this extent.
EXTENT_CLUSTERS_OVERRUN
An extent was found which claims to contain clusters which are beyond
the end of the volume.
Answering yes clamps the extent to the end of the volume. This may
result in a reduced file size for the file that contains the extent,
but it couldn't have addressed those final clusters anyway. One can
imagine this problem arising if there are problems shrinking a volume.
EXTENT_EB_INVALID
Deep extent trees are built by forming a tree out of extent blocks. An
extent tree references an invalid extent block.
Answering yes stops the tree from referencing the invalid extent block.
This may truncate data from the file which contains the tree.
EXTENT_LIST_DEPTH
Extent lists contain a record of their depth in the tree. An extent
list was found whose recorded depth doesn't match the position they
have in the tree.
Answering yes updates the depth field in the list to match the tree on
disk.
EXTENT_LIST_COUNT
The number of entries in an extent list is bounded by either the size
of the inode or the size of the block which contains it. An extent
list was found which claims to have more entries than would fit in its
container.
Answering yes updates the count field in the extent list to match the
container. Answering no to this question may stop further fixes from
being done because the count value can not be trusted.
EXTENT_LIST_FREE
The number of free entries in an extent list must be less than the
total number of entries in the list. A list was found which claims to
have more free entries than possible entries.
Answering yes sets the number of free entries in the list equal to the
total possible entries.
EXTENT_BLKNO_RANGE
An extent record was found which references a block which can not be
referenced by an extent. The referenced block is either very early in
the volume, and thus reserved, or beyond the end of the volume.
Answering yes removes this extent record from the tree. This may
remove data from the file which owns the tree but any such data was
inaccessible.
CHAIN_CPG
The bitmap inode indicates a different clusters per group than the
group descriptor. This value is typically static and only modified by
tunefs during volume resize and that too only on volumes having only
one cluster group.
Answering yes updates the clusters per group on the bitmap inode to the
corresponding value in the group descriptor.
SUPERBLOCK_CLUSTERS
The super block indicates a different total clusters value than the
global bitmap. This is only possible due to a failed volume resize
operation.
Answering yes updates the total clusters in the super block to the
value specified in the global bitmap.
FIXED_CHAIN_CLUSTERS
The global bitmap inode was repaired, resulting in a change to the
total cluster count of the filesystem.
Answering yes updates the total clusters in the super block to the
value specified in the global bitmap.
GROUP_UNEXPECTED_DESC
The group descriptors that make up the global bitmap chain allocator
reside at predictable locations on disk. A group descriptor was found
in the global bitmap allocator which isn't at one of these locations
and so shouldn't be in the allocator.
Answering yes removes this descriptor from the global bitmap allocator.
GROUP_EXPECTED_DESC
The group descriptors that make up the global bitmap chain allocator
reside at predictable locations on disk. A group descriptor at one of
these locations was not linked into the global bitmap allocator.
Answering yes will relink this group into the allocator.
GROUP_GEN
A group descriptor was found with a generation number that doesn't
match the generation number of the volume.
Answering yes sets the group descriptor's generation equal to the gen‐
eration number in the volume.
GROUP_PARENT
Group descriptors contain a pointer to the allocator inode which con‐
tains the chain they belong to. A group descriptor was found in an
allocator inode that doesn't match the descriptor's parent pointer.
Answering yes updates the group descriptor's parent pointer to match
the inode it resides in.
GROUP_DUPLICATE
Group descriptors contain a pointer to the allocator inode which con‐
tains the chain they belong to. A group descriptor was found in two
allocator inodes so it may be duplicated.
Answering yes removes the group descriptor from current allocator
inode.
GROUP_BLKNO
Group descriptors have a field which records their block location on
disk. A group descriptor was found at a given location but is recorded
as being located somewhere else.
Answering yes updates the group descriptor's recorded location to match
where it actually is found on disk.
GROUP_CHAIN
Group descriptors are found in a number of different singly-linked
chains in an allocator inode. A group descriptor records the chain
number that it is linked in. A group descriptor was found whose chain
field doesn't match the chain it was found in.
Answering yes sets the group descriptor's chain field to match the
chain it is found in.
GROUP_FREE_BITS
A group descriptor records the number of bits in its bitmap that are
free. A group descriptor was found which claims to have more free bits
than are valid in its bitmap.
Answering yes decreases the number of recorded free bits so that it
equals the total number of bits in the group descriptor's bitmap.
GROUP_CHAIN_LOOP
A chain may loop if the next field of the group descriptor points to
one of the previous group descriptors in the chain. This causes the
ocfs2 code, both user space and kernel module to loop forever.
Answering yes breaks the loop at an optimum location so that all the
existing group descriptors are in the chain. However, it cannot re-con‐
nect stray group descriptors and must rely on the rest of the fsck code
to fix it.
CHAIN_COUNT
The chain list embedded in an inode is limited by the block size and
the number of bytes consumed by the rest of the inode. A chain list
header was found which claimed that there are more entries in the list
then could fit in the inode.
Answering yes resets the header's cl_count member to the maximum size
allowed by the block size after accounting for the space consumed by
the inode.
CHAIN_NEXT_FREE
This is identical to CHAIN_COUNT except that it is testing and fixing
the pointer to the next free list entry recorded in the
cl_next_free_rec member instead of the total number of entries.
CHAIN_EMPTY
Chain entries need to be packed such that there are no chains without
descriptors found before the chain that is marked as free by the chain
header. A chain without descriptors was found found before that chain
that was marked free.
Answering yes will remove the unused chain and shift the remaining
chains forward in the list.
CHAIN_I_CLUSTERS
Chain allocator inodes have an i_clusters value that represents the
number of clusters used by the allocator. An inode was found whose
i_clusters value doesn't match the number of clusters its chains cover.
Answering yes updates i_clusters in the inode to reflect what was actu‐
ally found by walking the chain.
CHAIN_I_SIZE
Chain allocator inodes multiply the number of bytes per cluster by the
their i_clusters value and store it in i_size. An inode was found
which didn't have the correct value in its i_size.
Answering yes updates i_size to be the product of i_clusters and the
cluster size. Nothing else uses this value, and previous versions of
tools didn't calculate it properly, so don't be too worried if this
error appears.
CHAIN_GROUP_BITS
The inode that contains an embedded chain list has fields which record
the total number of bits covered by the chain as well as the amount
free. These fields didn't match what was found in the chain.
Answering yes updates the fields in the inode to reflect what was actu‐
ally found by walking the chain.
CHAIN_HEAD_LINK_RANGE
The header that starts a chain tried to reference a group descriptor at
a block number that couldn't be valid.
Answering yes will clear the reference to this invalid block and trun‐
cate the chain that it started.
CHAIN_LINK_GEN
A reference was made to a group descriptor whose generation number
doesn't match the generation of the volume.
Answering yes to this question implies that the group descriptor is
invalid and the chain is truncated at the point that it referred to
this invalid group descriptor. Answering no to this question considers
the group descriptor as valid and its generation may be fixed.
CHAIN_LINK_MAGIC
Chains are built by chain headers and group descriptors which are
linked together by block references. A reference was made to a group
descriptor at a given block but a valid group descriptor signature
wasn't found at that block.
Answering yes clears the reference to this invalid block and truncates
the chain at the point of the reference.
CHAIN_LINK_RANGE
Chains are built by chain headers and group descriptors which are
linked together by block references. A reference a block was found
which can't possibly be valid because it was either too small or
extended beyond the volume.
Answering yes truncates the chain in question by zeroing the invalid
block reference. This shortens the chain in question and could result
in more fixes later if the part of the chain that couldn't be refer‐
enced was valid at some point.
CHAIN_BITS
A chain's header contains members which record the total number of bits
in the chain as well as the number of bits that are free. After walk‐
ing through a chain it was found that the number of bits recorded in
its header don't match what was found by totalling up the group
descriptors.
Answering yes updates the c_total and c_free members of the header to
reflect what was found in the group descriptors in the chain.
DISCONTIG_BG_DEPTH
A discontiguous block group has an extent list which records all the
clusters allocated to it. Discontiguous block groups only support
extent lists with a tree depth of 0. A block group claims to have a
tree depth greater than 0.
Answering yes will set the tree depth of the extent list to 0.
DISCONTIG_BG_COUNT
A discontiguous block group has an extent list which records all the
clusters allocated to it. A block group claims to have more records
than can actually fit.
Answering yes will set the record count to the maximum possible.
DISCONTIG_BG_REC_RANGE
Block groups set aside clusters to be used for metadata. A discontigu‐
ous block group claims to contain clusters beyond the end of the vol‐
ume.
Answering yes will remove the block group.
DISCONTIG_BG_CORRUPT_LEAVES
A discontiguous block group has an extent list which records all the
clusters allocated to it. A group has more than one extent claiming to
have an impossible number of clusters.
Answering yes will remove the block group.
DISCONTIG_BG_CLUSTERS
Extent records in a discontiguous block group were found having more
clusters allocated then a block group can have.
Answering yes will remove the block group.
DISCONTIG_BG_LESS_CLUSTERS
Extent records in a discontiguous block group were found having less
clusters allocated then a block group can have.
Answering yes will remove the block group.
DISCONTIG_BG_NEXT_FREE_REC
A discontiguous block group has an extent list which records all the
clusters allocated to it. A group was found with fewer filled in
extents than it claims to have. The filled in extents describe a com‐
plete and correct group.
Answering yes will set the used extent count to the number of filled
extents.
DISCONTIG_BG_LIST_CORRUPT
A discontiguous block group has an extent list which records all the
clusters allocated to it. The group claims to have more extents than
is possible, and the existing extents contain errors.
Answering yes will remove the block group.
DISCONTIG_BG_REC_CORRUPT
A discontiguous block group has a extent list which records all the
clusters allocated to it. A group was found with one extent claiming
too many clusters but the sum of the remaining extents are equal to the
total clusters a group must have.
Answering yes will remove the block group.
DISCONTIG_BG_LEAF_CLUSTERS
A discontiguous block group has a extent list which records all the
clusters allocated to it. A group was found with one extent claiming
too many clusters, but the remaining extents are correct.
Answering yes will set the number of the clusters on the broken extent
to the difference between the total clusters a group must have and the
sum of the remaining extents.
INODE_ALLOC_REPAIR
The inode allocator did not accurately reflect the set of inodes that
are free and in use in the volume.
Answering yes will update the inode allocator bitmaps. Each bit that
doesn't match the state of its inode will be inverted.
INODE_SUBALLOC
Each inode records the node whose allocator is responsible for the
inode. An inode was found in a given node's allocator but the inode
itself claimed to belong to a different node.
Answering yes will correct the inode to point to the node's allocator
that it belongs to.
LALLOC_SIZE
Each node has a local allocator contained in a block that is used to
allocate clusters in batches. A node's local allocator claims to
reflect more bytes than are possible for the volume's block size.
Answering yes decreases the local allocator's size to reflect the vol‐
ume's block size.
LALLOC_NZ_USED
A given node's local allocator isn't in use but it claims to have bits
in use in its bitmap.
Answering yes zeros this used field.
LALLOC_NZ_BM
A given node's local allocator isn't in use but it has a field which
records the bitmap as starting at a non-zero cluster offset.
Answering yes zeros the bm_off field.
LALLOC_BM_OVERRUN
Each local allocator contains a reference to the first cluster that its
bitmap addresses. A given local allocator was found which references a
starting cluster that is beyond the end of the volume.
Answering yes resets the given local allocator. No allocated data will
be lost.
LALLOC_BM_SIZE
The given local allocator claims to cover more bits than are possible
for the size in bytes of its bitmap.
Answering yes decreases the number of bits the allocator covers to
reflect the size in bytes of the bitmap and resets the allocator. No
allocated data will be lost.
LALLOC_BM_STRADDLE
The given local allocator claims to cover a region of clusters which
extents beyond the end of the volume.
Answering yes resets the given local allocator. No allocated data will
be lost.
LALLOC_USED_OVERRUN
The given local allocator claims to have more bits in use than it has
total bits in its bitmap.
Answering yes decreases the number of bits used so that it equals the
total number of available bits.
LALLOC_CLEAR
A local allocator inode was found to have problems. This gives the
operator a chance to just reset the local allocator inode.
Answering yes clears the local allocator. No information is lost but
the global bitmap allocator may need to be updated to reflect clusters
that were reserved for the local allocator but were free.
DEALLOC_COUNT
The given truncate log inode contains a count that is greater than the
value that is possible given the size of the inode.
Answering yes resets the count value to the possible maximum.
DEALLOC_USED
The given truncate log inode claims to have more records in use than it
is possible to store in the inode.
Answering yes resets the record of the number used to the maximum value
possible.
TRUNCATE_REC_START_RANGE
A truncate record was found which claims to start at a cluster that is
beyond the number of clusters in the volume.
Answering yes will clear the truncate record. This may result in pre‐
viously freed space being marked as allocated. This will be fixed up
later as the allocator is updated to match what is used by the file
system.
TRUNCATE_REC_WRAP
Clusters are recorded as 32bit values. A truncate record was found
which claims to have enough clusters to cause this value to wrap. This
could never be the case and is a sure sign of corruption.
Answering yes will clear the truncate record. This may result in pre‐
viously freed space being marked as allocated. This will be fixed up
later as the allocator is updated to match what is used by the file
system.
TRUNCATE_REC_RANGE
A truncate record was found which claims to reference a region of clus‐
ters which partially extends beyond the number of clusters in the vol‐
ume.
Answering yes will clear the truncate record. This may result in pre‐
viously freed space being marked as allocated. This will be fixed up
later as the allocator is updated to match what is used by the file
system.
INODE_GEN
Inodes are created with a generation number to match the generation
number of the volume at the time of creation. An Inode was found which
contains a generation number that doesn't match.
Answering yes implies that the generation number is correct and that
the inode is from a previous file system. The inode will be recorded
as free.
INODE_GEN_FIX
Inodes are created with a generation number to match the generation
number of the volume at the time of creation. An inode was found which
contains a generation number that doesn't match.
Answering yes implies that the generation number in the inode is incor‐
rect and that the inode is valid. The generation number in the inode
is updated to match the generation number in the volume.
INODE_BLKNO
Inodes contain a field that must match the block that they reside in.
An inode was found at a block that doesn't match the field in the
inode.
Answering yes updates the field to match the inode's position on disk.
ROOT_NOTDIR
The super block contains a reference to the inode that contains the
root directory. This block was found to contain an inode that isn't a
directory.
Answering yes clears this inode. The operator will be asked to recre‐
ate the root directory at a point in the near future.
INODE_NZ_DTIME
Inodes contain a field describing the time at which they were deleted.
This can not be set for an inode that is still in use. An inode was
found which is in use but which contains a non-zero dtime.
Answering yes implies that the inode is still valid and resets its
dtime to zero.
LINK_FAST_DATA
The target name for a symbolic link is stored either as file contents
for that inode or in the inode structure itself on disk. Only small
destination names are stored in the inode structure. The i_blocks
field of the inode indicates that the name is stored in the inode when
it is zero. An inode was found that has both i_blocks set to zero and
file contents.
Answering yes clears the inode and so deletes the link.
LINK_NULLTERM
The targets of links on disk must be null terminated. A link was found
whose target wasn't null terminated.
Answering yes clears the inode and so deletes the link.
LINK_SIZE
The size of a link on disk must match the length of its target string.
A link was found whose size does not.
Answering yes updates the link's size to reflect the length of its tar‐
get string.
LINK_BLOCKS
Links can not be sparse. There must be exactly as many blocks allo‐
cated as are needed to cover its size. A link was found which doesn't
have enough blocks allocated to cover its size.
Answering yes clears the link's inode thus deleting the link.
DIR_ZERO
Directories must at least contain a block that has the "." and ".."
entries. A directory was found which doesn't contain any blocks.
Answering yes to this question clears the directory's inode thus delet‐
ing the directory.
INODE_SIZE
Certain inodes record the size of the data they reference in an i_size
field. This can be the number of bytes in a file, directory, or sym‐
link target which are stored in data mapped by extents of clusters.
This error occurs when the extent lists are walked and the amount of
data found does not match what is stored in i_size.
Answering yes to this question updates the inode's i_size to match the
amount of data referenced by the extent lists. It is vitally important
that i_size matches the extent lists and so answering yes is strongly
encouraged.
INODE_SPARSE_SIZE
Certain inodes record the size of the data they reference in an i_size
field. This can be the number of bytes in a file, directory, or sym‐
link target which are stored in data mapped by extents of clusters.
This error occurs when a sparse inode was found that had data allocated
past its i_size.
Answering yes to this question will update the inode's i_size to cover
all of its allocated storage. It is vitally important that i_size
matches the extent lists and so answering yes is strongly encouraged.
INODE_INLINE_SIZE
Inodes can only fit a certain amount of inline data. This inode has
its data inline but claims an i_size larger than will actually fit.
Answering yes to this question updates the inode's i_size to the maxi‐
mum available inline space.
INODE_CLUSTERS
Inodes contain a record of how many clusters are allocated to them. An
inode was found whose recorded number of clusters doesn't match the
number of blocks that were found associated with the inode.
Answering yes resets the inode's number of clusters to reflect the num‐
ber of blocks that were associated with the file.
INODE_SPARSE_CLUSTERS
Inodes contain a record of how many clusters are allocated to them. An
sparse inode was found whose recorded number of clusters doesn't match
the number of blocks that were found associated with the inode.
Answering yes resets the inode's number of clusters to reflect the num‐
ber of blocks that were associated with the file.
INODE_INLINE_CLUSTERS
Inlined inode should not have allocated clusters. An inode who has
inline data flag set was found with clusters allocated.
Answering yes resets the inode's number of clusters to zero.
LALLOC_REPAIR
An active local allocator did not accurately reflect the set of clus‐
ters that are free and in use in its region.
Answering yes will update the local allocator bitmap. Each bit that
doesn't match the use of its cluster will be inverted.
LALLOC_USED
A local allocator records the number of bits that are used in its bit‐
map. An allocator was found whose used value doesn't reflect the num‐
ber of bits that are set in its bitmap.
Answering yes sets the used value to match the number of bits set in
the allocator's bitmap.
CLUSTER_ALLOC_BIT
A specific cluster's use didn't match the setting of its bit in the
cluster allocator.
Answering yes will invert the bit in the allocator to match the use of
the cluster -- either allocated and in use or free.
REFCOUNT_FLAG_INVALID
Refcount file can only exist in a volume with refcount supported, Fsck
has found that a file in a non-refcount volume has refcount flag set.
Answering yes remove this flag from the file.
REFCOUNT_LOC_INVALID
Refcount loc can only be valid if the file has refcount flag set. Fsck
has found that a file has refcount loc while it does't have refcount
flag set.
Answering yes reset refcount loc to zero for the file.
RB_BLKNO
refcount blocks contain a record of the disk block where they are
located. An refcount block was found at a block that didn't match its
recorded location.
Answering yes will update the data structure in the refcount block to
reflect its real location on disk.
RB_GEN
Refcount blocks are created with a generation number to match the gen‐
eration number of the volume at the time of creation. An refcount
block was found which contains a generation number that doesn't match.
Answering yes implies that the generation number is correct and that
the refcount block is from a previous file system. The refcount block
will be removed and the file that uses it will lose the refcounted
information, but it may be regenerated later.
RB_GEN_FIX
Refcount blocks are created with a generation number to match the gen‐
eration number of the volume at the time of creation. An refcount
block was found which contains a generation number that doesn't match.
Answering yes implies that the generation number in the refcount block
is incorrect and that the refcount block is valid. The generation num‐
ber in the block is updated to match the generation number in the vol‐
ume.
RB_PARENT
refcount blocks contain a record of the parent this disk block belongs
to. An refcount block was found storing a wrong parent location.
Answering yes will update the data structure in the refcount block to
reflect its parent's real location on disk.
REFCOUNT_LIST_COUNT
The number of entries in a refcount list is bounded by the size of the
block which contains it. An refcount list was found which claims to
have more entries than would fit in its container.
Answering yes updates the count field in the refcount list to match the
container. Answering no to this question may stop further fixes from
being done because the count value can not be trusted.
REFCOUNT_LIST_USED
The number of free entries in a refcount list must be less than the
total number of entries in the list. A list was found which claims to
have more free entries than possible entries.
Answering yes sets the number of free entries in the list equal to the
total possible entries.
REFCOUNT_CLUSTER_RANGE
A refcount record was found which references a cluster which can not be
referenced by a refcount. The referenced cluster is either very early
in the volume, and thus reserved, or beyond the end of the volume.
Answering yes removes this refcount record from the tree.
REFCOUNT_CLUSTER_COLLISION
A refcount record was found which references a cluster which has a col‐
lision with the previous valid refcount record.
Answering yes removes this refcount record from the tree.
REFCOUNT_LIST_EMPTY
A refcount list was found which has no refcount record in it. It is
normally caused by a corrupted refcount record.
Answering yes removes this refcount block from the tree. It will be re-
generated in refcounted extent records handler if all the other infor‐
mation is sane.
REFCOUNT_BLOCK_INVALID
Refcount block stores the refcount record for physical clusters of a
file. It is found refering an invalid refcount block.
Answering yes remove this refcount block.
REFCOUNT_CLUSTERS
Refcount tree contains a record of how many clusters are allocated to
them. A tree was found whose recorded number of clusters doesn't match
the number of blocks that were found associated with it.
Answering yes resets the number of clusters to reflect the real number
of clusters that were associated with the tree.
REFCOUNT_ROOT_BLOCK_INVALID
Root refcount block is the root of the refcount record for a file. It
is found refering an invalid refcount block.
Answering yes remove this refcount block and clear refcount flag from
this file.
REFCOUNT_REC_REDUNDANT
Refcount record is used to store the refcount for physical clusters.
Some refcount record is found to have no physical clusters correspond‐
ing to it.
Answering yes remove the refcount record.
REFCOUNT_COUNT_INVALID
Refcount record is used to store the refcount for physical clusters. A
record record is found whichs claims the wrong refcount for some physi‐
cal clusters.
Answering yes update the corresponding refcount record.
REFCOUNT_COUNT
Refcount tree contains a record of how many files refering to this
tree. A tree was found whose recorded number of files doesn't match
the real files refering to the tree.
Answering yes resets the number of files to reflect the real number of
files that were associated with the tree.
DUP_CLUSTERS_SYSFILE_CLONE
A system file inode claims clusters that are also claimed by another
inode. ocfs2 does not allow this. System files may be cloned but may
not be deleted. Allocation system files may not be cloned or deleted.
Answering yes will copy the data of this inode to newly allocated
extents. This will break the claim on the overcommitted clusters.
DUP_CLUSTERS_CLONE
An inode claims clusters that are also claimed by another inode. ocfs2
does not allow this.
Answering yes will copy the data of this inode to newly allocated
extents. This will break the claim on the overcommitted clusters.
DUP_CLUSTERS_DELETE
An inode claims clusters that are also claimed by another inode. ocfs2
does not allow this.
Answering yes will remove this inode, thus breaking its claim on the
overcommitted clusters.
DUP_CLUSTERS_ADD_REFCOUNT
An inode claims clusters that are also claimed by another inode. ocfs2
does not allow this.
Answering yes will try to add a refcount record for all these inodes,
so that they will share the cluster.
DIRENT_DOTTY_DUP
There can be only one instance of both the "." and ".." entries in a
directory. A directory entry was found which duplicated one of these
entries.
Answering yes will remove the duplicate directory entry.
DIRENT_NOT_DOTTY
The first and second directory entries in a directory must be "." and
".." respectively. One of these directory entries was found to not
match these rules.
Answering yes will force the directory entry to be either "." or "..".
This might consume otherwise valid entries and cause some files to
appear in lost+found.
DIRENT_DOT_INODE
The inode field of the "." directory entry must refer to the directory
inode that contains the given directory block. A "." entry was found
which doesn't do so.
Answering yes sets the directory entry's inode reference to the parent
directory that contains the entry.
DIRENT_DOT_EXCESS
A "." directory entry was found whose lengths exceeds the amount
required for the single dot in the name.
Answering yes creates another empty directory entry in this excess
space.
DIRENT_ZERO
A directory entry was found with a zero length name.
Answering yes clears the directory entry so its space can be reused.
DIRENT_NAME_CHARS
Directory entries can not contain either the NULL character (ASCII 0)
or the forward slash (ASCII 47). A directory entry was found which
contains either.
Answering yes will change each instance of these forbidden characters
into a period (ASCII 46).
DIRENT_INODE_RANGE
Each directory entry contains a inode field which the entry's name cor‐
responds to. An entry was found which referenced an inode number that
is invalid for the current volume.
Answering yes clears this entry so its space can be reused. If the
entry once corresponded to a real inode and was corrupted this inode
may appear in lost+found.
DIRENT_INODE_FREE
Each directory entry contains a inode field which the entry's name cor‐
responds to. An entry was found which referenced an inode number that
isn't in use.
Answering yes clears this directory entry.
DIRENT_TYPE
Each directory entry contains a field which describes the type of file
that the entry refers to. An entry was found whose type doesn't match
the inode it is referring to.
Answering yes resets the entry's type to match the target inode.
DIR_PARENT_DUP
Each directory can only be pointed to by one directory entry in a par‐
ent directory. A directory entry was found which was the second entry
to point to a given directory inode.
Answering yes clears this entry which was the second to refer to a
given directory. This reflects the policy that hard links to directo‐
ries are not allowed.
DIRENT_DUPLICATE
File names within a directory must be unique. A file name occurred in
more than one directory entry in a given directory.
Answering yes renames the duplicate entry to a name that doesn't col‐
lide with recent entries and is unlikely to collide with future entries
in the directory.
DIRENT_LENGTH
There are very few directory entry lengths that are valid. The lengths
must be greater than the minimum required to record a single character
directory, be rounded to 12 bytes, be within the amount of space
remaining in a directory block, and be properly rounded for the size of
the name of the directory entry. An entry was found which didn't meet
these criteria.
Answering yes will try to repair the directory entry. This runs a very
good chance of invalidating all the entries in the directory block.
Orphaned inodes may appear in lost+found.
DIR_TRAILER_INODE
A directory block trailer is a fake directory entry at the end of the
block. The trailer has compatibility fields for when it is viewed as a
directory entry. The inode field must be zero.
Answering yes will set the inode field to zero.
DIR_TRAILER_NAME_LEN
A directory block trailer is a fake directory entry at the end of the
block. The trailer has compatibility fields for when it is viewed as a
directory entry. The name length field must be zero.
Answering yes will set the name length field to zero.
DIR_TRAILER_REC_LEN
A directory block trailer is a fake directory entry at the end of the
block. The trailer has compatibility fields for when it is viewed as a
directory entry. The record length field must be equal to the size of
the trailer.
Answering yes will set the record length field to the size of the
trailer.
DIR_TRAILER_BLKNO
A directory block trailer is a fake directory entry at the end of the
block. The self-referential block number is incorrect.
Answering yes will set the block number to the correct block on disk.
DIR_TRAILER_PARENT_INODE
A directory block trailer is a fake directory entry at the end of the
block. It has a pointer to the directory inode it belongs to. This
pointer is incorrect.
Answering yes will set the parent inode pointer to the inode referenc‐
ing this directory block.
ROOT_DIR_MISSING
The super block contains a reference to the inode that serves as the
root directory. This reference points to an inode that isn't in use.
Answering yes will create a new inode and update the super block to
refer to this inode as the root directory.
LOSTFOUND_MISSING
The super block contains a reference to the inode that serves as the
lost+found directory. This reference points to an inode that isn't in
use.
Answering yes will create a new lost+found directory in the root direc‐
tory.
DIR_NOT_CONNECTED
Every directory in the file system should be reachable by a directory
entry in its parent directory. This is verified by walking every
directory in the system. A directory inode was found during this walk
which doesn't have a parent directory entry.
Answering yes moves this directory entry into the lost+found directory
and gives it a name based on its inode number.
DIR_DOTDOT
A directory inode's ".." directory entry must refer to the parent
directory. A directory was found whose ".." doesn't refer to its par‐
ent.
Answering yes will read the directory block for the given directory and
update its ".." entry to reflect its parent.
INODE_NOT_CONNECTED
Most all inodes in the system should be referenced by a directory
entry. An inode was found which isn't referred to by any directory
entry.
Answering yes moves this inode into the lost+found directory and gives
it a name based on its inode number.
INODE_COUNT
Each inode records the number of directory entries that refer to it.
An inode was found whose recorded count doesn't match the number of
entries that refer to it.
Answering yes sets the inode's count to match the number of referring
directory entries.
INODE_ORPHANED
While files are being deleted they are placed in an internal directory.
If the machine crashes while this is taking place the files will be
left in this directory. Fsck has found an inode in this directory and
would like to finish the job of truncating and removing it.
Answering yes removes the file data associated with the inode and frees
the inode.
RECOVER_BACKUP_SUPERBLOCK
When fsck.ocfs2 successfully uses the specified backup superblock, it
provides the user with this option to overwrite the existing superblock
with that backup.
Answering yes will refresh the superblock from the backup. Answering no
will only disable the copying of the backup superblock and will not
effect the remaining fsck.ocfs2 processing.
ORPHAN_DIR_MISSING
While files are being deleted they are placed in an internal directory,
named orphan directory. If an orphan directory does not exist, an OCFS2
volume cannot be mounted successfully. Fsck has found the orphan direc‐
tory is missing and would like to create it for future use.
Answering yes creates the orphan directory in the system directory.
JOURNAL_FILE_INVALID
OCFS2 uses JDB for journalling and some journal files exist in the sys‐
tem directory. Fsck has found some journal files that are invalid.
Answering yes to this question will regenerate the invalid journal
files.
JOURNAL_UNKNOWN_FEATURE
Fsck has found some journal files with unknown features. Other jour‐
nals on the filesystem have only known features, so this is likely a
corruption. If you think your filesystem may be newer than this ver‐
sion of fsck.ocfs2, say N here and grab the latest version of
fsck.ocfs2.
Answering yes resets the journal features to match other journals.
JOURNAL_MISSING_FEATURE
Fsck has found some journal files have features that are not set on all
journal files. All journals on filesystem should have the same set of
features.
Answering yes will set all journals to the union of set features.
JOURNAL_TOO_SMALL
Fsck has found some journal files are too small.
Answering yes extends these journals.
RECOVER_CLUSTER_INFO
The currently active cluster stack is different than the one the
filesystem is configured for. Thus, fsck.ocfs2 cannot determine
whether the filesystem is mounted on an another node or not. The recom‐
mended solution is to exit and run fsck.ocfs2 on this device from a
node that has the appropriate active cluster stack. However, you can
proceed with the fsck if you are sure that the volume is not in use on
any node.
Answering yes reconfigures the filesystem to use the current cluster
stack. DANGER: YOU MUST BE ABSOLUTELY SURE THAT NO OTHER NODE IS USING
THIS FILESYSTEM BEFORE CONTINUING. OTHERWISE, YOU CAN CORRUPT THE
FILESYSTEM AND LOSE DATA.
INLINE_DATA_FLAG_INVALID
Inline file can only exist in a volume with inline supported, Fsck has
found that a file in a non-inline volume has inline flag set.
Answering yes remove this flag from the file.
INLINE_DATA_COUNT_INVALID
For an inline file, there is a limit for id2.id_data.id_count. Fsck has
found that this value isn't right.
Answering yes change this value to the right number.
XATTR_BLOCK_INVALID
Extended attributes are stored off an extended attribute block refer‐
enced by the inode. This inode references an invalid extended
attribute block.
Answering yes will remove this block.
XATTR_COUNT_INVALID
The count of extended attributes in an inode, block, or bucket does not
match the number of entries found by fsck.
Answering yes will change this to the correct count.
XATTR_ENTRY_INVALID
An extended attribute entry points to already used space.
Answering yes will remove this entry.
XATTR_NAME_OFFSET_INVALID
The name_offset field of an extended attribute entry is not correct.
Without a correct name_offset field, the entry cannot be used.
Answering yes will remove this entry.
XATTR_VALUE_INVALID
The value region of an extended attribute points to already used space.
Answering yes will remove this entry.
XATTR_LOCATION_INVALID
The xe_local field and xe_value_size field of an extended attribute
entry does not match. So the entry cannot be used.
Answering yes will remove this entry.
XATTR_HASH_INVALID
Extended attributes use a hash of their name for lookup purposes. The
name_hash of this extended attribute entry is not correct.
Answering yes will change this to the correct hash.
XATTR_FREE_START_INVALID
Extended attributes use free_start to indicate the offset of the free
space in inode, block, or bucket. The free_start field of this object
is not correct.
Answering yes will change this to the correct offset.
XATTR_VALUE_LEN_INVALID
Extended attributes use name_value_len to store the total length of all
entry's name and value in inode, block or bucket. the name_value_len
filed of this object is not correct.
Answering yes will change this to the correct value.
XATTR_BUCKET_COUNT_INVALID
The count of extended attributes bucket pointed by one extent record
does not match the number of buckets found by fsck.
Answering yes will change this to the correct count.
QMAGIC_INVALID
The magic number in the header of quota file does not match the proper
number.
Answering yes will make fsck use values in the quota file header any‐
way.
QTREE_BLK_INVALID
Block with references to other blocks with quota data is corrupted.
Answering yes will make fsck use references in the block.
DQBLK_INVALID
The structure with quota limits was found in a corrupted block.
Answering yes will use the values of limits for the user / group.
DUP_DQBLK_INVALID
The structure with quota limits was found in a corrupted block and fsck
has already found quota limits for this user / group.
Answering yes will use new values of limits for the user / group.
DUP_DQBLK_VALID
The structure with quota limits was found in a correct block but fsck
has already found quota limits for this user / group.
Answering yes will use new values of limits for the user / group.
IV_DX_TREE
A directory index was found on an inode but that feature is not enabled
on the file system.
Answering yes will truncate the invalid index.
DX_LOOKUP_FAILED
A directory entry is missing an entry in the directory index. The miss‐
ing index entry will cause lookups on this name to fail.
Answering yes will rebuild the directory index, restoring the missing
entry.
NO_HOLES
A metadata structure encountered a hole where it should not. Examples
of such structures are directories, refcount trees, dx_trees etc.
Answering yes will remove the hole by updating the offset to the
expected value.
EXTENT_OVERLAP
The extents of the file overlap, which means there could be two or more
possible data for a particular offset for the file.
Answering yes will serialize the extents.
DX_TREE_CORRUPT
The index tree of the directory is corrupt.
Answering yes will rebuild the directory index, in pass 2.
DX_TREE_MISSING
The index of this directory is missing.
Answering yes will rebuild the directory index.
SEE ALSO
debugfs.ocfs2(8) fsck.ocfs2(8) mkfs.ocfs2(8) mount.ocfs2(8)
mounted.ocfs2(8) o2cluster(8) o2image(8) o2info(1) tunefs.ocfs2(8)
AUTHORS
Oracle Corporation.
COPYRIGHT
Copyright © 2004, 2012 Oracle. All rights reserved.
Version 1.8.2 January 2012 fsck.ocfs2.checks(8)
[top]
List of man pages available for OpenSuSE
Copyright (c) for man pages and the logo by the respective OS vendor.
For those who want to learn more, the polarhome community provides shell access and support.
[legal]
[privacy]
[GNU]
[policy]
[cookies]
[netiquette]
[sponsors]
[FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
|
|
Vote for polarhome
|
