fsck.ocfs2.checks man page on Oracle

Man page or keyword search:  
man Server   33470 pages
apropos Keyword Search (all sections)
Output format
Oracle logo
[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.

   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.

SEE ALSO
       fsck.ocfs2(8)

AUTHORS
       Oracle Corporation.

COPYRIGHT
       Copyright © 2004, 2010 Oracle. All rights reserved.

Version 1.8.0			September 2010		  fsck.ocfs2.checks(8)
[top]

List of man pages available for Oracle

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]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net