Provided by: ocfs2-tools_1.1.5-0ubuntu5_i386 bug

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
       consistenty  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 exent 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
       inaccesible.

   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_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 decreses  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.

       Answerying 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 delted.
       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 and so deletes 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 directorie’s inode and so
       deletes 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.

SEE ALSO

       fsck.ocfs2(8)

AUTHORS

       Oracle Corporation.

COPYRIGHT

       Copyright © 2004, 2005 Oracle. All rights reserved.