Provided by: xfsprogs_3.1.9ubuntu2_amd64 bug

NAME

       xfs_db - debug an XFS filesystem

SYNOPSIS

       xfs_db [ -c cmd ] ... [ -i|r|x|F ] [ -f ] [ -l logdev ] [ -p progname ] device
       xfs_db -V

DESCRIPTION

       xfs_db  is used to examine an XFS filesystem. Under rare circumstances it can also be used
       to modify an XFS filesystem, but that task is normally left to xfs_repair(8) or to scripts
       such as xfs_admin(8) that run xfs_db.

OPTIONS

       -c cmd xfs_db  commands  may  be  run  interactively  (the default) or as arguments on the
              command line. Multiple -c arguments may be given.  The  commands  are  run  in  the
              sequence  given,  then  the  program exits. This is the mechanism used to implement
              xfs_check(8).

       -f     Specifies that the filesystem image to be processed is stored in a regular file  at
              device (see the mkfs.xfs(8) -d file option).  This might happen if an image copy of
              a filesystem has been made into an ordinary file with xfs_copy(8).

       -F     Specifies that we want to continue even if the superblock  magic  is  not  correct.
              For use in xfs_check and xfs_metadump.

       -i     Allows execution on a mounted filesystem, provided it is mounted read-only.  Useful
              for shell scripts such as xfs_check(8), which must only operate on filesystems in a
              guarenteed   consistent  state  (either  unmounted  or  mounted  read-only).  These
              semantics are slightly different to that of the -r option.

       -l logdev
              Specifies the device where the filesystems external log resides.   Only  for  those
              filesystems  which use an external log. See the mkfs.xfs(8) -l option, and refer to
              xfs(5) for a detailed description of the XFS log.

       -p progname
              Set the program name to progname for prompts and some error messages,  the  default
              value is xfs_db.

       -r     Open  device  or  filename  read-only. This option is required if the filesystem is
              mounted.  It is only necessary to omit this flag if a  command  that  changes  data
              (write, blocktrash) is to be used.

       -x     Specifies expert mode.  This enables the write and blocktrash commands.

       -V     Prints out the current version number and exits.

CONCEPTS

       xfs_db  commands  can  be broken up into two classes. Most commands are for the navigation
       and display of data structures in the filesystem.  Other commands  are  for  scanning  the
       filesystem in some way.

       Commands  which are used to navigate the filesystem structure take arguments which reflect
       the names of filesystem structure fields.  There can be multiple field names separated  by
       dots  when  the underlying structures are nested, as in C.  The field names can be indexed
       (as an array index) if the underlying field  is  an  array.   The  array  indices  can  be
       specified as a range, two numbers separated by a dash.

       xfs_db maintains a current address in the filesystem.  The granularity of the address is a
       filesystem structure.  This can be a filesystem block, an inode or quota (smaller  than  a
       filesystem  block), or a directory block (could be larger than a filesystem block).  There
       are a variety of commands to set the current address.  Associated with the current address
       is  the  current  data  type,  which  is the structural type of this data.  Commands which
       follow the structure of the filesystem always  set  the  type  as  well  as  the  address.
       Commands  which  examine pieces of an individual file (inode) need the current inode to be
       set, this is done with the inode command.

       The current address/type information is  actually  maintained  in  a  stack  that  can  be
       explicitly  manipulated  with  the  push,  pop,  and stack commands.  This allows for easy
       examination of a nested filesystem structure.  Also, the last  several  locations  visited
       are  stored  in  a  ring  buffer which can be manipulated with the forward, back, and ring
       commands.

       XFS filesystems are divided into a small number of allocation groups.  xfs_db maintains  a
       notion  of the current allocation group which is manipulated by some commands. The initial
       allocation group is 0.

COMMANDS

       Many commands have extensive online help. Use the help command for  more  details  on  any
       command.

       a      See the addr command.

       ablock filoff
              Set  current  address  to  the  offset  filoff  (a  filesystem block number) in the
              attribute area of the current inode.

       addr [field-expression]
              Set current address to the value of the field-expression.  This is used to "follow"
              a  reference  in  one  structure to the object being referred to. If no argument is
              given, the current address is printed.

       agf [agno]
              Set current address to the AGF block for allocation group agno.  If no argument  is
              given, use the current allocation group.

       agfl [agno]
              Set current address to the AGFL block for allocation group agno.  If no argument is
              given, use the current allocation group.

       agi [agno]
              Set current address to the AGI block for allocation group agno.  If no argument  is
              given, use the current allocation group.

       b      See the back command.

       back   Move to the previous location in the position ring.

       blockfree
              Free  block  usage  information  collected  by  the  last execution of the blockget
              command. This must be done before another blockget command can be given, presumably
              with different arguments than the previous one.

       blockget [-npvs] [-b bno] ... [-i ino] ...
              Get block usage and check filesystem consistency.  The information is saved for use
              by a subsequent blockuse, ncheck, or blocktrash command. See xfs_check(8) for  more
              information.

                 -b  is  used to specify filesystem block numbers about which verbose information
                     should be printed.

                 -i  is used to specify inode numbers about which verbose information  should  be
                     printed.

                 -n  is  used  to  save pathnames for inodes visited, this is used to support the
                     xfs_ncheck(8) command. It also means that  pathnames  will  be  printed  for
                     inodes  that  have  problems.  This  option  uses  a lot of memory so is not
                     enabled by default.

                 -p  causes error  messages  to  be  prefixed  with  the  filesystem  name  being
                     processed. This is useful if several copies of xfs_db are run in parallel.

                 -s  restricts  output to severe errors only. This is useful if the output is too
                     long otherwise.

                 -v  enables verbose output. Messages will be printed for every block  and  inode
                     processed.

       blocktrash [-n count] [-x min] [-y max] [-s seed] [-0|1|2|3] [-t type] ...
              Trash  randomly  selected  filesystem metadata blocks.  Trashing occurs to randomly
              selected bits in the chosen blocks.  This command is available  only  in  debugging
              versions of xfs_db.  It is useful for testing xfs_repair(8) and xfs_check(8).

                 -0 | -1 | -2 | -3
                     These  are  used  to set the operating mode for blocktrash.  Only one can be
                     used: -0 changed bits are cleared; -1 changed bits are set; -2 changed  bits
                     are inverted; -3 changed bits are randomized.

                 -n  supplies the count of block-trashings to perform (default 1).

                 -s  supplies a seed to the random processing.

                 -t  gives  a type of blocks to be selected for trashing. Multiple -t options may
                     be given. If no -t options are given then all metadata types can be trashed.

                 -x  sets the minimum size of bit range to be trashed. The default value is 1.

                 -y  sets the maximum size of bit range to be trashed. The default value is 1024.

       blockuse [-n] [-c count]
              Print usage for current filesystem block(s).  For each block, the type and (if any)
              inode are printed.

                 -c  specifies  a count of blocks to process. The default value is 1 (the current
                     block only).

                 -n  specifies that file names should be printed. The prior blockget command must
                     have also specified the -n option.

       bmap [-a] [-d] [block [len]]
              Show  the block map for the current inode.  The map display can be restricted to an
              area of the file with the block and len arguments. If block is  given  and  len  is
              omitted then 1 is assumed for len.

              The  -a  and -d options are used to select the attribute or data area of the inode,
              if neither option is given then both areas are shown.

       check  See the blockget command.

       convert type number [type number] ... type
              Convert from one address form to another.  The known types, with  alternate  names,
              are:
                 agblock or agbno (filesystem block within an allocation group)
                 agino or aginode (inode number within an allocation group)
                 agnumber or agno (allocation group number)
                 bboff or daddroff (byte offset in a daddr)
                 blkoff or fsboff or agboff (byte offset in a agblock or fsblock)
                 byte or fsbyte (byte address in filesystem)
                 daddr or bb (disk address, 512-byte blocks)
                 fsblock or fsb or fsbno (filesystem block, see the fsblock command)
                 ino or inode (inode number)
                 inoidx or offset (index of inode in filesystem block)
                 inooff or inodeoff (byte offset in inode)

              Only  conversions that "make sense" are allowed.  The compound form (with more than
              three arguments) is useful for conversions  such  as  convert  agno  ag  agbno  agb
              fsblock.

       daddr [d]
              Set current address to the daddr (512 byte block) given by d.  If no value for d is
              given, the current address is printed, expressed as a daddr.  The type  is  set  to
              data (uninterpreted).

       dblock filoff
              Set  current  address  to the offset filoff (a filesystem block number) in the data
              area of the current inode.

       debug [flagbits]
              Set debug option bits. These are used for debugging xfs_db.  If no value  is  given
              for  flagbits,  print  the  current debug option bits. These are for the use of the
              implementor.

       dquot [projectid_or_userid]
              Set current address to a project or user quota block.

       echo [arg] ...
              Echo the arguments to the output.

       f      See the forward command.

       forward
              Move forward to the next entry in the position ring.

       frag [-adflqRrv]
              Get file fragmentation data. This prints information about  fragmentation  of  file
              data in the filesystem (as opposed to fragmentation of freespace, for which see the
              freesp command). Every file in the filesystem is examined to see how far from ideal
              its extent mappings are. A summary is printed giving the totals.

                 -v  sets  verbosity,  every inode has information printed for it.  The remaining
                     options select which inodes and extents are examined.   If  no  options  are
                     given then all are assumed set, otherwise just those given are enabled.

                 -a  enables processing of attribute data.

                 -d  enables processing of directory data.

                 -f  enables processing of regular file data.

                 -l  enables processing of symbolic link data.

                 -q  enables processing of quota file data.

                 -R  enables processing of realtime control file data.

                 -r  enables processing of realtime file data.

       freesp [-bcds] [-a ag] ... [-e i] [-h h1] ... [-m m]
              Summarize free space for the filesystem. The free blocks are examined and totalled,
              and displayed in the form of a histogram, with a count of extents in each range  of
              free extent sizes.

                 -a  adds  ag  to the list of allocation groups to be processed. If no -a options
                     are given then all allocation groups are processed.

                 -b  specifies that the histogram buckets are  binary-sized,  with  the  starting
                     sizes being the powers of 2.

                 -c  specifies  that  freesp will search the by-size (cnt) space Btree instead of
                     the default by-block (bno) space Btree.

                 -d  specifies that every free extent will be displayed.

                 -e  specifies  that  the  histogram  buckets  are  equal-sized,  with  the  size
                     specified as i.

                 -h  specifies  a  starting  block number for a histogram bucket as h1.  Multiple
                     -h's are given to specify the complete set of buckets.

                 -m  specifies that the histogram starting block numbers are powers of  m.   This
                     is the general case of -b.

                 -s  specifies  that  a final summary of total free extents, free blocks, and the
                     average free extent size is printed.

       fsb    See the fsblock command.

       fsblock [fsb]
              Set current address to the fsblock value given by fsb.  If  no  value  for  fsb  is
              given the current address is printed, expressed as an fsb.  The type is set to data
              (uninterpreted). XFS filesystem block numbers are computed  ((agno  <<  agshift)  |
              agblock)  where agshift depends on the size of an allocation group. Use the convert
              command to convert to and from this form. Block numbers given for file blocks  (for
              instance from the bmap command) are in this form.

       hash string
              Prints  the  hash  value of string using the hash function of the XFS directory and
              attribute implementation.

       help [command]
              Print help for one or all commands.

       inode [inode#]
              Set the current inode number. If no  inode#  is  given,  print  the  current  inode
              number.

       label [label]
              Set  the  filesystem label. The filesystem label can be used by mount(8) instead of
              using a device special file.  The maximum length of an XFS label is 12 characters -
              use of a longer label will result in truncation and a warning will be issued. If no
              label is given, the current filesystem label is printed.

       log [stop | start filename]
              Start logging output to filename,  stop  logging,  or  print  the  current  logging
              status.

       metadump [-egow] filename
              Dumps metadata to a file. See xfs_metadump(8) for more information.

       ncheck [-s] [-i ino] ...
              Print  name-inode  pairs.  A  blockget  -n  command must be run first to gather the
              information.

                 -i  specifies an inode number to be printed. If no -i options are given then all
                     inodes are printed.

                 -s  specifies that only setuid and setgid files are printed.

       p      See the print command.

       pop    Pop location from the stack.

       print [field-expression] ...
              Print  field  values.   If  no  argument  is given, print all fields in the current
              structure.

       push [command]
              Push location to the stack. If command is supplied, set the current location to the
              results of command after pushing the old location.

       q      See the quit command.

       quit   Exit xfs_db.

       ring [index]
              Show  position ring (if no index argument is given), or move to a specific entry in
              the position ring given by index.

       sb [agno]
              Set current address to SB header in allocation group agno.  If no  agno  is  given,
              use the current allocation group number.

       source source-file
              Process commands from source-file.  source commands can be nested.

       stack  View the location stack.

       type [type]
              Set  the current data type to type.  If no argument is given, show the current data
              type.  The possible data types are: agf, agfl, agi, attr, bmapbta, bmapbtd,  bnobt,
              cntbt,  data, dir, dir2, dqblk, inobt, inode, log, rtbitmap, rtsummary, sb, symlink
              and text.  See the TYPES section below for more information on these data types.

       uuid [uuid | generate | rewrite]
              Set the filesystem universally unique identifier (UUID).  The filesystem  UUID  can
              be  used  by  mount(8) instead of using a device special file.  The uuid can be set
              directly to the desired UUID, or  it  can  be  automatically  generated  using  the
              generate  option.  These  options  will  both write the UUID into every copy of the
              superblock in the filesystem.  rewrite copies the current  UUID  from  the  primary
              superblock to all secondary copies of the superblock.  If no argument is given, the
              current filesystem UUID is printed.

       version [feature | versionnum features2]
              Enable selected features for a filesystem (certain features can be  enabled  on  an
              unmounted  filesystem,  after mkfs.xfs(8) has created the filesystem).  Support for
              unwritten extents can be enabled using the extflg option. Support for version 2 log
              format can be enabled using the log2 option. Support for extended attributes can be
              enabled using the attr1 or attr2 option. Once enabled, extended  attributes  cannot
              be disabled, but the user may toggle between attr1 and attr2 at will (older kernels
              may not support the newer version).

              If no argument is given, the current version and feature bits  are  printed.   With
              one argument, this command will write the updated version number into every copy of
              the superblock in the filesystem.  If two arguments are given, they will be used as
              numeric values for the versionnum and features2 bits respectively, and their string
              equivalent reported (but no modifications are made).

       write [field value] ...
              Write a value to disk.  Specific fields can be set in structures (struct mode),  or
              a  block  can  be  set  to data values (data mode), or a block can be set to string
              values (string mode, for symlink blocks).  The operation happens immediately: there
              is no buffering.

              Struct  mode  is  in effect when the current type is structural, i.e. not data. For
              struct mode, the syntax is "write field value".

              Data mode is in effect when the current type is data. In this case the contents  of
              the  block  can  be  shifted or rotated left or right, or filled with a sequence, a
              constant value, or a random value. In this mode write with no arguments gives  more
              information on the allowed commands.

TYPES

       This  section  gives the fields in each structure type and their meanings.  Note that some
       types of block cover multiple actual structures, for instance directory blocks.

       agf       The AGF block is the header for block  allocation  information;  it  is  in  the
                 second  512-byte  block  of  each  allocation  group.   The following fields are
                 defined:
                     magicnum    AGF block magic number, 0x58414746 ('XAGF').
                     versionnum  version number, currently 1.
                     seqno       sequence number starting from 0.
                     length      size  in  filesystem  blocks  of  the  allocation   group.   All
                                 allocation groups except the last one of the filesystem have the
                                 superblock's agblocks value here.
                     bnoroot     block number of  the  root  of  the  Btree  holding  free  space
                                 information sorted by block number.
                     cntroot     block  number  of  the  root  of  the  Btree  holding free space
                                 information sorted by block count.
                     bnolevel    number of levels in the by-block-number Btree.
                     cntlevel    number of levels in the by-block-count Btree.
                     flfirst     index into the AGFL block of the first active entry.
                     fllast      index into the AGFL block of the last active entry.
                     flcount     count of active entries in the AGFL block.
                     freeblks    count of blocks represented in the freespace Btrees.
                     longest     longest free space represented in the freespace Btrees.
                     btreeblks   number of blocks held in the AGF Btrees.

       agfl      The AGFL block contains block numbers for use of the block allocator; it  is  in
                 the  fourth  512-byte  block of each allocation group.  Each entry in the active
                 list is a block number within the allocation group that  can  be  used  for  any
                 purpose  if  space  runs low.  The AGF block fields flfirst, fllast, and flcount
                 designate which entries are currently active.  Entry space  is  allocated  in  a
                 circular manner within the AGFL block.  Fields defined:
                     bno         array  of all block numbers. Even those which are not active are
                                 printed.

       agi       The AGI block is the header for inode allocation information; it is in the third
                 512-byte block of each allocation group.  Fields defined:
                     magicnum    AGI block magic number, 0x58414749 ('XAGI').
                     versionnum  version number, currently 1.
                     seqno       sequence number starting from 0.
                     length      size in filesystem blocks of the allocation group.
                     count       count of inodes allocated.
                     root        block  number  of the root of the Btree holding inode allocation
                                 information.
                     level       number of levels in the inode allocation Btree.
                     freecount   count of allocated inodes that are not in use.
                     newino      last inode number allocated.
                     dirino      unused.
                     unlinked    an array of inode  numbers  within  the  allocation  group.  The
                                 entries  in  the  AGI  block  are  the  heads of lists which run
                                 through the inode next_unlinked field. These inodes  are  to  be
                                 unlinked the next time the filesystem is mounted.

       attr      An  attribute  fork is organized as a Btree with the actual data embedded in the
                 leaf blocks. The root of the Btree is found in block 0 of the fork.   The  index
                 (sort  order)  of  the  Btree  is the hash value of the attribute name.  All the
                 blocks contain a blkinfo  structure  at  the  beginning,  see  type  dir  for  a
                 description.  Nonleaf  blocks are identical in format to those for version 1 and
                 version 2 directories, see type dir for a description. Leaf blocks can refer  to
                 "local"  or  "remote"  attribute values. Local values are stored directly in the
                 leaf block.  Remote values are stored in an independent block in  the  attribute
                 fork (with no structure). Leaf blocks contain the following fields:
                     hdr         header   containing  a  blkinfo  structure  info  (magic  number
                                 0xfbee), a count of active entries,  usedbytes  total  bytes  of
                                 names and values, the firstused byte in the name area, holes set
                                 if the block needs compaction, and array freemap as for dir leaf
                                 blocks.
                     entries     array  of  structures  containing a hashval, nameidx (index into
                                 the block of the name), and flags incomplete, root, and local.
                     nvlist      array of structures describing the attribute names  and  values.
                                 Fields  always  present:  valuelen  (length  of value in bytes),
                                 namelen, and name.   Fields  present  for  local  values:  value
                                 (value string). Fields present for remote values: valueblk (fork
                                 block number of containing the value).

       bmapbt    Files with many extents in their data or attribute fork will  have  the  extents
                 described  by  the  contents  of  a Btree for that fork, instead of being stored
                 directly in the inode.  Each bmap Btree  starts  with  a  root  block  contained
                 within  the  inode.   The  other  levels  of  the Btree are stored in filesystem
                 blocks.  The blocks are linked to sibling left and right blocks at  each  level,
                 as  well  as  by  pointers from parent to child blocks.  Each block contains the
                 following fields:
                     magic       bmap Btree block magic number, 0x424d4150 ('BMAP').
                     level       level of this block above the leaf level.
                     numrecs     number of records or keys in the block.
                     leftsib     left (logically lower) sibling block, 0 if none.
                     rightsib    right (logically higher) sibling block, 0 if none.
                     recs        [leaf  blocks  only]  array  of  extent  records.   Each  record
                                 contains  startoff, startblock, blockcount, and extentflag (1 if
                                 the extent is unwritten).
                     keys        [nonleaf blocks only] array of key records. These are the  first
                                 key value of each block in the level below this one. Each record
                                 contains startoff.
                     ptrs        [nonleaf blocks only]  array  of  child  block  pointers.   Each
                                 pointer  is  a  filesystem block number to the next level in the
                                 Btree.

       bnobt     There is one set of filesystem blocks  forming  the  by-block-number  allocation
                 Btree  for  each allocation group. The root block of this Btree is designated by
                 the bnoroot field in the coresponding AGF  block.   The  blocks  are  linked  to
                 sibling  left and right blocks at each level, as well as by pointers from parent
                 to child blocks.  Each block has the following fields:
                     magic       BNOBT block magic number, 0x41425442 ('ABTB').
                     level       level number of this block, 0 is a leaf.
                     numrecs     number of data entries in the block.
                     leftsib     left (logically lower) sibling block, 0 if none.
                     rightsib    right (logically higher) sibling block, 0 if none.
                     recs        [leaf blocks only]  array  of  freespace  records.  Each  record
                                 contains startblock and blockcount.
                     keys        [nonleaf  blocks only] array of key records. These are the first
                                 value of each block in the level below  this  one.  Each  record
                                 contains startblock and blockcount.
                     ptrs        [nonleaf  blocks  only]  array  of  child  block  pointers. Each
                                 pointer is a block number within the  allocation  group  to  the
                                 next level in the Btree.

       cntbt     There  is  one  set  of  filesystem blocks forming the by-block-count allocation
                 Btree for each allocation group. The root block of this Btree is  designated  by
                 the  cntroot  field  in  the  coresponding  AGF  block. The blocks are linked to
                 sibling left and right blocks at each level, as well as by pointers from  parent
                 to child blocks. Each block has the following fields:
                     magic       CNTBT block magic number, 0x41425443 ('ABTC').
                     level       level number of this block, 0 is a leaf.
                     numrecs     number of data entries in the block.
                     leftsib     left (logically lower) sibling block, 0 if none.
                     rightsib    right (logically higher) sibling block, 0 if none.
                     recs        [leaf  blocks  only]  array  of  freespace  records. Each record
                                 contains startblock and blockcount.
                     keys        [nonleaf blocks only] array of key records. These are the  first
                                 value  of  each  block  in the level below this one. Each record
                                 contains blockcount and startblock.
                     ptrs        [nonleaf blocks  only]  array  of  child  block  pointers.  Each
                                 pointer  is  a  block  number within the allocation group to the
                                 next level in the Btree.

       data      User file blocks, and other blocks whose type is unknown,  have  this  type  for
                 display purposes in xfs_db.  The block data is displayed in hexadecimal format.

       dir       A  version  1 directory is organized as a Btree with the directory data embedded
                 in the leaf blocks. The root of the Btree is found in block 0 of the  file.  The
                 index  (sort  order)  of  the Btree is the hash value of the entry name. All the
                 blocks contain a blkinfo structure at the beginning with the following fields:
                     forw        next sibling block.
                     back        previous sibling block.
                     magic       magic number for this block type.
                 The non-leaf (node) blocks have the following fields:
                     hdr         header  containing  a  blkinfo  structure  info  (magic   number
                                 0xfebe),  the  count  of  active  entries, and the level of this
                                 block above the leaves.
                     btree       array of entries  containing  hashval  and  before  fields.  The
                                 before  value is a block number within the directory file to the
                                 child block, the hashval is the last hash value in that block.
                 The leaf blocks have the following fields:
                     hdr         header  containing  a  blkinfo  structure  info  (magic   number
                                 0xfeeb),  the  count  of  active  entries, namebytes (total name
                                 string bytes), holes flag (block needs compaction), and  freemap
                                 (array of base, size entries for free regions).
                     entries     array of structures containing hashval, nameidx (byte index into
                                 the block of the name string), and namelen.
                     namelist    array of structures containing inumber and name.

       dir2      A version 2 directory has four kinds of blocks.  Data blocks start at  offset  0
                 in  the file.  There are two kinds of data blocks: single-block directories have
                 the leaf information embedded at the end of the block,  data  blocks  in  multi-
                 block  directories  do  not.   Node  and leaf blocks start at offset 32GiB (with
                 either a single leaf block or the root node block).  Freespace blocks  start  at
                 offset  64GiB.   The  node  and leaf blocks form a Btree, with references to the
                 data in the data blocks.  The freespace blocks form an  index  of  longest  free
                 spaces within the data blocks.

                 A single-block directory block contains the following fields:
                     bhdr        header  containing magic number 0x58443242 ('XD2B') and an array
                                 bestfree of the longest 3 free  spaces  in  the  block  (offset,
                                 length).
                     bu          array  of union structures. Each element is either an entry or a
                                 freespace.   For  entries,  there  are  the  following   fields:
                                 inumber,  namelen,  name, and tag.  For freespace, there are the
                                 following fields: freetag (0xffff), length, and  tag.   The  tag
                                 value  is the byte offset in the block of the start of the entry
                                 it is contained in.
                     bleaf       array of leaf  entries  containing  hashval  and  address.   The
                                 address is a 64-bit word offset into the file.
                     btail       tail  structure  containing  the total count of leaf entries and
                                 stale count of unused leaf entries.
                 A data block contains the following fields:
                     dhdr        header containing magic number 0x58443244 ('XD2D') and an  array
                                 bestfree  of  the  longest  3  free spaces in the block (offset,
                                 length).
                     du          array of union structures as for bu.
                 Leaf blocks have two possible forms. If the Btree consists of a single leaf then
                 the  freespace  information  is  in  the leaf block, otherwise it is in separate
                 blocks and the root of the Btree is a node block.  A  leaf  block  contains  the
                 following fields:
                     lhdr        header  containing a blkinfo structure info (magic number 0xd2f1
                                 for the single leaf case, 0xd2ff for the true Btree  case),  the
                                 total  count  of  leaf  entries,  and stale count of unused leaf
                                 entries.
                     lents       leaf entries, as for bleaf.
                     lbests      [single leaf only] array of values which represent  the  longest
                                 freespace in each data block in the directory.
                     ltail       [single  leaf only] tail structure containing bestcount count of
                                 lbests.
                 A node block is identical to that for types attr and dir.

                 A freespace block contains the following fields:
                     fhdr        header containing  magic  number  0x58443246  ('XD2F'),  firstdb
                                 first  data block number covered by this freespace block, nvalid
                                 number  of  valid  entries,  and   nused   number   of   entries
                                 representing real data blocks.
                     fbests      array of values as for lbests.

       dqblk     The  quota information is stored in files referred to by the superblock uquotino
                 and pquotino fields. Each filesystem block in a quota file contains  a  constant
                 number  of quota entries. The quota entry size is currently 136 bytes, so with a
                 4KiB filesystem block size there are 30  quota  entries  per  block.  The  dquot
                 command is used to locate these entries in the filesystem.  The file entries are
                 indexed by the user or project identifier to determine  the  block  and  offset.
                 Each quota entry has the following fields:
                     magic          magic number, 0x4451 ('DQ').
                     version        version number, currently 1.
                     flags          flags,  values  include 0x01 for user quota, 0x02 for project
                                    quota.
                     id             user or project identifier.
                     blk_hardlimit  absolute limit on blocks in use.
                     blk_softlimit  preferred limit on blocks in use.
                     ino_hardlimit  absolute limit on inodes in use.
                     ino_softlimit  preferred limit on inodes in use.
                     bcount         blocks actually in use.
                     icount         inodes actually in use.
                     itimer         time when service will be refused if soft limit  is  violated
                                    for inodes.
                     btimer         time  when  service will be refused if soft limit is violated
                                    for blocks.
                     iwarns         number of warnings issued about inode limit violations.
                     bwarns         number of warnings issued about block limit violations.
                     rtb_hardlimit  absolute limit on realtime blocks in use.
                     rtb_softlimit  preferred limit on realtime blocks in use.
                     rtbcount       realtime blocks actually in use.
                     rtbtimer       time when service will be refused if soft limit  is  violated
                                    for realtime blocks.
                     rtbwarns       number   of   warnings  issued  about  realtime  block  limit
                                    violations.

       inobt     There is one set of filesystem blocks forming the  inode  allocation  Btree  for
                 each  allocation  group.  The root block of this Btree is designated by the root
                 field in the coresponding AGI block.  The blocks are linked to sibling left  and
                 right  blocks at each level, as well as by pointers from parent to child blocks.
                 Each block has the following fields:
                     magic       INOBT block magic number, 0x49414254 ('IABT').
                     level       level number of this block, 0 is a leaf.
                     numrecs     number of data entries in the block.
                     leftsib     left (logically lower) sibling block, 0 if none.
                     rightsib    right (logically higher) sibling block, 0 if none.
                     recs        [leaf blocks only] array of inode records. Each record  contains
                                 startino allocation-group relative inode number, freecount count
                                 of free inodes in this chunk, and free bitmap,  LSB  corresponds
                                 to inode 0.
                     keys        [nonleaf  blocks only] array of key records. These are the first
                                 value of each block in the level below  this  one.  Each  record
                                 contains startino.
                     ptrs        [nonleaf  blocks  only]  array  of  child  block  pointers. Each
                                 pointer is a block number within the  allocation  group  to  the
                                 next level in the Btree.

       inode     Inodes  are allocated in "chunks" of 64 inodes each. Usually a chunk is multiple
                 filesystem blocks, although there are cases with large filesystem blocks where a
                 chunk  is  less  than one block. The inode Btree (see inobt above) refers to the
                 inode numbers per allocation group.  The  inode  numbers  directly  reflect  the
                 location  of the inode block on disk. Use the inode command to point xfs_db to a
                 specific inode. Each inode contains four regions: core, next_unlinked, u, and a.
                 core  contains  the fixed information.  next_unlinked is separated from the core
                 due to journaling considerations, see type agi field unlinked.   u  is  a  union
                 structure  that  is  different  in  size  and  format  depending on the type and
                 representation of the file data ("data fork").  a is an optional union structure
                 to  describe  attribute  data,  that  is different in size, format, and location
                 depending on the presence and representation of attribute data, and the size  of
                 the  u  data  ("attribute fork").  xfs_db automatically selects the proper union
                 members based on information in the inode.

                 The following are fields in the inode core:
                     magic       inode magic number, 0x494e ('IN').
                     mode        mode and type of file, as described in chmod(2),  mknod(2),  and
                                 stat(2).
                     version     inode version, 1 or 2.
                     format      format  of  u union data (0: xfs_dev_t, 1: local file - in-inode
                                 directory or symlink, 2: extent list, 3: Btree root,  4:  unique
                                 id [unused]).
                     nlinkv1     number of links to the file in a version 1 inode.
                     nlinkv2     number of links to the file in a version 2 inode.
                     projid_lo   owner's  project id (low word; version 2 inode only).  projid_hi
                                 owner's project id (high word; version 2 inode only).
                     uid         owner's user id.
                     gid         owner's group id.
                     atime       time last accessed (seconds and nanoseconds).
                     mtime       time last modified.
                     ctime       time created or inode last modified.
                     size        number of bytes in the file.
                     nblocks     total number of  blocks  in  the  file  including  indirect  and
                                 attribute.
                     extsize     basic/minimum extent size for the file.
                     nextents    number of extents in the data fork.
                     naextents   number of extents in the attribute fork.
                     forkoff     attribute  fork  offset  in  the inode, in 64-bit words from the
                                 start of u.
                     aformat     format of a data (1: local attribute data, 2:  extent  list,  3:
                                 Btree root).
                     dmevmask    DMAPI event mask.
                     dmstate     DMAPI state information.
                     newrtbm     file is the realtime bitmap and is "new" format.
                     prealloc    file has preallocated data space after EOF.
                     realtime    file data is in the realtime subvolume.
                     gen         inode generation number.
                 The following fields are in the u data fork union:
                     bmbt        bmap  Btree root. This looks like a bmapbtd block with redundant
                                 information removed.
                     bmx         array of extent descriptors.
                     dev         dev_t for the block or character device.
                     sfdir       shortform (in-inode) version 1 directory. This consists of a hdr
                                 containing the parent inode number and a count of active entries
                                 in the  directory,  followed  by  an  array  list  of  hdr.count
                                 entries.  Each  such  entry  contains inumber, namelen, and name
                                 string.
                     sfdir2      shortform (in-inode) version 2 directory. This consists of a hdr
                                 containing  a  count  of  active  entries  in  the directory, an
                                 i8count of entries with inumbers that  don't  fit  in  a  32-bit
                                 value, and the parent inode number, followed by an array list of
                                 hdr.count entries. Each such entry  contains  namelen,  a  saved
                                 offset  used when the directory is converted to a larger form, a
                                 name string, and the inumber.
                     symlink     symbolic link string value.
                 The following fields are in the a attribute fork union if it exists:
                     bmbt        bmap Btree root, as above.
                     bmx         array of extent descriptors.
                     sfattr      shortform (in-inode) attribute values. This consists  of  a  hdr
                                 containing a totsize (total size in bytes) and a count of active
                                 entries, followed by an array list of  hdr.count  entries.  Each
                                 such  entry  contains  namelen,  valuelen,  root flag, name, and
                                 value.

       log       Log blocks contain the journal entries for XFS.   It's  not  useful  to  examine
                 these with xfs_db, use xfs_logprint(8) instead.

       rtbitmap  If  the  filesystem  has  a  realtime  subvolume,  then  the rbmino field in the
                 superblock refers to a file that contains the realtime bitmap.  Each bit in  the
                 bitmap  file  controls the allocation of a single realtime extent (set == free).
                 The bitmap is processed in 32-bit words, the LSB of a word is used for the first
                 extent  controlled  by  that bitmap word. The atime field of the realtime bitmap
                 inode contains a counter that is used to control where  the  next  new  realtime
                 file will start.

       rtsummary If  the  filesystem  has  a  realtime  subvolume,  then the rsumino field in the
                 superblock refers to a file that contains the realtime summary data. The summary
                 file  contains  a two-dimensional array of 16-bit values.  Each value counts the
                 number of free extent runs (consecutive free realtime extents) of a given  range
                 of  sizes  that  starts  in  a  given  bitmap block.  The size ranges are binary
                 buckets (low size in the bucket is a power of 2).  There are as many size ranges
                 as  are necessary given the size of the realtime subvolume.  The first dimension
                 is the size range, the second dimension is  the  starting  bitmap  block  number
                 (adjacent entries are for the same size, adjacent bitmap blocks).

       sb        There  is  one  sb (superblock) structure per allocation group.  It is the first
                 disk block in the allocation  group.   Only  the  first  one  (block  0  of  the
                 filesystem)  is  actually  used;  the other blocks are redundant information for
                 xfs_repair(8) to use if the first superblock is damaged. Fields defined:
                     magicnum    superblock magic number, 0x58465342 ('XFSB').
                     blocksize   filesystem block size in bytes.
                     dblocks     number of filesystem blocks present in the data subvolume.
                     rblocks     number of filesystem blocks present in the realtime subvolume.
                     rextents    number of realtime extents that rblocks contain.
                     uuid        unique identifier of the filesystem.
                     logstart    starting filesystem block number of the log (journal).  If  this
                                 value is 0 the log is "external".
                     rootino     root inode number.
                     rbmino      realtime bitmap inode number.
                     rsumino     realtime summary data inode number.
                     rextsize    realtime extent size in filesystem blocks.
                     agblocks    size of an allocation group in filesystem blocks.
                     agcount     number of allocation groups.
                     rbmblocks   number of realtime bitmap blocks.
                     logblocks   number of log blocks (filesystem blocks).
                     versionnum  filesystem  version  information.  This value is currently 1, 2,
                                 3, or 4 in the low 4 bits.  If the low bits are 4 then the other
                                 bits  have  additional  meanings.   1  is the original value.  2
                                 means that attributes were used.  3 means that version 2  inodes
                                 (large  link counts) were used.  4 is the bitmask version of the
                                 version number.  In this case, the other bits are used as  flags
                                 (0x0010:  attributes  were  used,  0x0020: version 2 inodes were
                                 used, 0x0040: quotas were used, 0x0080: inode cluster  alignment
                                 is  in force, 0x0100: data stripe alignment is in force, 0x0200:
                                 the shared_vn field is used, 0x1000: unwritten  extent  tracking
                                 is on, 0x2000: version 2 directories are in use).
                     sectsize    sector size in bytes, currently always 512.  This is the size of
                                 the superblock and the other header blocks.
                     inodesize   inode size in bytes.
                     inopblock   number of inodes per filesystem block.
                     fname       obsolete, filesystem name.
                     fpack       obsolete, filesystem pack name.
                     blocklog    log2 of blocksize.
                     sectlog     log2 of sectsize.
                     inodelog    log2 of inodesize.
                     inopblog    log2 of inopblock.
                     agblklog    log2 of agblocks (rounded up).
                     rextslog    log2 of rextents.
                     inprogress  mkfs.xfs(8)  or  xfs_copy(8)  aborted  before  completing   this
                                 filesystem.
                     imax_pct    maximum percentage of filesystem space used for inode blocks.
                     icount      number of allocated inodes.
                     ifree       number of allocated inodes that are not in use.
                     fdblocks    number of free data blocks.
                     frextents   number of free realtime extents.
                     uquotino    user quota inode number.
                     pquotino    project quota inode number; this is currently unused.
                     qflags      quota  status  flags  (0x01:  user quota accounting is on, 0x02:
                                 user quota limits are enforced, 0x04: quotacheck has been run on
                                 user quotas, 0x08: project quota accounting is on, 0x10: project
                                 quota limits are enforced, 0x20:  quotacheck  has  been  run  on
                                 project quotas).
                     flags       random flags. 0x01: only read-only mounts are allowed.
                     shared_vn   shared version number (shared readonly filesystems).
                     inoalignmt  inode chunk alignment in filesystem blocks.
                     unit        stripe or RAID unit.
                     width       stripe or RAID width.
                     dirblklog   log2 of directory block size (filesystem blocks).

       symlink   Symbolic  link  blocks  are  used only when the symbolic link value does not fit
                 inside the inode. The block content is just the string value.   Bytes  past  the
                 logical end of the symbolic link value have arbitrary values.

       text      User  file  blocks,  and  other blocks whose type is unknown, have this type for
                 display purposes in xfs_db.   The  block  data  is  displayed  in  two  columns:
                 Hexadecimal format and printable ASCII chars.

DIAGNOSTICS

       Many  messages  can  come  from  the  check  (blockget)  command;  these are documented in
       xfs_check(8).

SEE ALSO

       mkfs.xfs(8), xfs_admin(8), xfs_check(8),  xfs_copy(8),  xfs_logprint(8),  xfs_metadump(8),
       xfs_ncheck(8), xfs_repair(8), mount(8), chmod(2), mknod(2), stat(2), xfs(5).

                                                                                        xfs_db(8)