Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
xfs_db(8)		     System Manager's Manual		       xfs_db(8)

NAME
     xfs_db - debug an XFS filesystem

SYNOPSIS
     xfs_db [ -c cmd ] ... [ -i|r|x|F ] [ -f ] [ -l logdev ] [ -p progname ] de-
     vice
     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 argu-
	    ments on the command line. Multiple -c arguments may be  given.  The
	    commands are run in the sequence given, then the program exits.

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

     -i     Allows  execution  on  a  mounted filesystem, provided it is mounted
	    read-only.	Useful for shell scripts  which  must  only  operate  on
	    filesystems  in  a	guaranteed 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 descrip-
	    tion of the XFS log.

     -p progname
	    Set the program name to progname for prompts  and  some  error  mes-
	    sages, 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 com-
	    mands.

     -V     Prints the 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  mul-
     tiple  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 ma-
     nipulated 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 manipu-
     lated by some commands. The initial allocation group is 0.

COMMANDS
     Many commands have extensive online help. Use the help command for more de-
     tails 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.

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

	       -i  is used to specify inode numbers about which verbose informa-
		   tion 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 path-
		   names will be printed for inodes that have problems. This op-
		   tion 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).

	       -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 block-
		   get 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 al-
	    ternate 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 com-
		      mand)
	       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	fragmen-
	    tation  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 ex-
		   amined.  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 exam-
	    ined 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  pow-
		   ers 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 de-
	    pends 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 cur-
	    rent 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  argu-
	    ment 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  en-
	    abled  using  the  attr1 or attr2 option. Once enabled, extended at-
	    tributes 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 [-c] [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 al-
	    lowed commands.

	       -c  Skip write verifiers and CRC  recalculation;  allows  invalid
		   data to be written to disk.

TYPES
     This  section  gives  the fields in each structure type and their meanings.
     Note that some types of block cover multiple  actual  structures,	for  in-
     stance 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 en-
			       try.
		   fllast      index into the AGFL block of the last active  en-
			       try.
		   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 allo-
	       cator; 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 des-
	       ignate  which entries are currently active.  Entry space is allo-
	       cated in a circular manner within the  AGFL  block.   Fields  de-
	       fined:
		   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 in-
			       ode 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_un-
			       linked 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  blk-
	       info  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,  used-
			       bytes  total bytes of names and values, the firs-
			       tused 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 in-
			       complete, 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: value-
			       blk (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 con-
	       tains 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        [non-leaf 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        [non-leaf  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  correspond-
	       ing  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        [non-leaf blocks  only]	array  of  key	records.
			       These  are  the	first value of each block in the
			       level below this one. Each record contains start-
			       block and blockcount.
		   ptrs        [non-leaf  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 correspond-
	       ing 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        [non-leaf  blocks  only]  array	of  key records.
			       These are the first value of each  block  in  the
			       level below this one. Each record contains block-
			       count and startblock.
		   ptrs        [non-leaf  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 dis-
	       played 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  blk-
	       info 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 hash-
			       val 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 embed-
	       ded  at the end of the block, data blocks in multi-block directo-
	       ries 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 free-
	       space 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 ad-
			       dress.  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  repre-
			       sent  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 su-
	       perblock 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 com-
	       mand is used to locate these entries in the filesystem.	The file
	       entries are indexed by the user or project identifier  to  deter-
	       mine  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  alloca-
	       tion  Btree  for  each  allocation  group. The root block of this
	       Btree is designated by the root field in  the  corresponding  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  rela-
			       tive inode number, freecount count of free inodes
			       in  this  chunk, and free bitmap, LSB corresponds
			       to inode 0.
		   keys        [non-leaf 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        [non-leaf  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 num-
	       bers 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  re-
	       gions:  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  in-
			       direct 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: ex-
			       tent 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 di-
			       rectory, followed by an array list  of  hdr.count
			       entries.  Each such entry contains inumber, name-
			       len, 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  con-
			       tains  namelen,	a saved offset used when the di-
			       rectory 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 ex-
	       ists:
		   bmbt        bmap Btree root, as above.
		   bmx	       array of extent descriptors.
		   sfattr      shortform (in-inode) attribute values. This  con-
			       sists  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 con-
	       trolled	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 real-
	       time summary data. The summary file  contains  a  two-dimensional
	       array of 16-bit values.	Each value counts the number of free ex-
	       tent 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 real-
			       time 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 "exter-
			       nal".
		   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 addi-
			       tional  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:  un-
			       written	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 com-
			       pleting 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 un-
			       used.
		   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: quo-
			       tacheck has been run on project quotas).
		   flags       random flags. 0x01: only read-only mounts are al-
			       lowed.
		   shared_vn   shared version number (shared  readonly	filesys-
			       tems).
		   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 dis-
	       played  in  two	columns:  Hexadecimal format and printable ASCII
	       chars.

DIAGNOSTICS
     Many messages can come from the check (blockget) command.	If the	filesys-
     tem  is  completely  corrupt,  a core dump might be produced instead of the
     message
	    device is not a valid filesystem

     If the filesystem is very large (has many files) then check might	run  out
     of memory. In this case the message
	    out of memory
     is printed.

     The  following is a description of the most likely problems and the associ-
     ated messages.  Most of the diagnostics produced are only	meaningful  with
     an understanding of the structure of the filesystem.

     agf_freeblks n, counted m in ag a
	    The  freeblocks  count in the allocation group header for allocation
	    group a doesn't match the number of blocks counted free.

     agf_longest n, counted m in ag a
	    The longest free extent in the allocation group header  for  alloca-
	    tion  group a doesn't match the longest free extent found in the al-
	    location group.

     agi_count n, counted m in ag a
	    The allocated inode count in the allocation group header for alloca-
	    tion group a doesn't match the number of inodes counted in the allo-
	    cation group.

     agi_freecount n, counted m in ag a
	    The free inode count in the allocation group header  for  allocation
	    group a doesn't match the number of inodes counted free in the allo-
	    cation group.

     block a/b expected inum 0 got i
	    The  block	number	is specified as a pair (allocation group number,
	    block in the allocation group).  The block is  used  multiple  times
	    (shared),  between	multiple inodes.  This message usually follows a
	    message of the next type.

     block a/b expected type unknown got y
	    The block is used multiple times (shared).

     block a/b type unknown not expected

SEE ALSO
     mkfs.xfs(8), xfs_admin(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)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=xfs_db&sektion=8&manpath=FreeBSD+Ports+15.1.quarterly>

home | help