Linux Certif

Toute la documentation sur la certification Linux LPI

fsck.ocfs2.checks

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 generation 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 referenced.

EB_GEN_FIX

Extent blocks are created with a generation number to match the generation 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_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.

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 generation number in the volume.

GROUP_PARENT

Group descriptors contain a pointer to the allocator inode which contains 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 contains 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.

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 actually 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 actually 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 truncate 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 referenced 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 walking 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.

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 volume'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 previously 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 previously 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 clusters which partially extends beyond the number of clusters in the volume.

Answering yes will clear the truncate record. This may result in previously 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 incorrect 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 recreate 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 target string.

LINK_BLOCKS

Links can not be sparse. There must be exactly as many blocks allocated 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 deleting 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 symlink 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_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 number of blocks that were associated with the file.

LALLOC_REPAIR

An active local allocator did not accurately reflect the set of clusters 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 bitmap. An allocator was found whose used value doesn't reflect the number 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.

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 corresponds 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 corresponds 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 parent 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 directories 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 collide 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.

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 directory.

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 parent.

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 directory 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 system directory. Fsck has found some journal file is whether empty or has bad journal superblock and would like to fix it for future use.

Answering yes reformats the journal file in the system directory.

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 recommended 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.

SEE ALSO

fsck.ocfs2(8)

AUTHORS

Oracle Corporation.

COPYRIGHT

Copyright © 2004, 2008 Oracle. All rights reserved.