Man Linux: Main Page and Category List

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.

   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
       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_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
       symlink  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
       maximum 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
       number 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
       number 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
       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.

   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.

   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.

   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
       referencing 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
       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 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
       journals  on the filesystem have only known features, so this is likely
       a corruption.  If you think your filesystem  may  be  newer  than  this
       version  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
       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.

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

SEE ALSO

       fsck.ocfs2(8)

AUTHORS

       Oracle Corporation.

COPYRIGHT

       Copyright © 2004, 2009 Oracle. All rights reserved.