Quelle  dir.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) 2017-2023 Oracle.  All Rights Reserved.
 * Author: Darrick J. Wong <djwong@kernel.org>
 */
#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_shared.h"
#include "xfs_format.h"
#include "xfs_trans_resv.h"
#include "xfs_mount.h"
#include "xfs_log_format.h"
#include "xfs_trans.h"
#include "xfs_inode.h"
#include "xfs_icache.h"
#include "xfs_dir2.h"
#include "xfs_dir2_priv.h"
#include "xfs_health.h"
#include "xfs_attr.h"
#include "xfs_parent.h"
#include "scrub/scrub.h"
#include "scrub/common.h"
#include "scrub/dabtree.h"
#include "scrub/readdir.h"
#include "scrub/health.h"
#include "scrub/repair.h"
#include "scrub/trace.h"
#include "scrub/xfile.h"
#include "scrub/xfarray.h"
#include "scrub/xfblob.h"

/* Set us up to scrub directories. */
int
xchk_setup_directory(
 struct xfs_scrub *sc)
{
 int   error;

 if (xchk_could_repair(sc)) {
  error = xrep_setup_directory(sc);
  if (error)
   return error;
 }

 return xchk_setup_inode_contents(sc, 0);
}

/* Directories */

/* Deferred directory entry that we saved for later. */
struct xchk_dirent {
 /* Cookie for retrieval of the dirent name. */
 xfblob_cookie  name_cookie;

 /* Child inode number. */
 xfs_ino_t  ino;

 /* Length of the pptr name. */
 uint8_t   namelen;
};

struct xchk_dir {
 struct xfs_scrub *sc;

 /* information for parent pointer validation. */
 struct xfs_parent_rec pptr_rec;
 struct xfs_da_args pptr_args;

 /* Fixed-size array of xchk_dirent structures. */
 struct xfarray  *dir_entries;

 /* Blobs containing dirent names. */
 struct xfblob  *dir_names;

 /* If we've cycled the ILOCK, we must revalidate deferred dirents. */
 bool   need_revalidate;

 /* Name buffer for dirent revalidation. */
 struct xfs_name  xname;
 uint8_t   namebuf[MAXNAMELEN];
};

/* Scrub a directory entry. */

/* Check that an inode's mode matches a given XFS_DIR3_FT_* type. */
STATIC void
xchk_dir_check_ftype(
 struct xfs_scrub *sc,
 xfs_fileoff_t  offset,
 struct xfs_inode *ip,
 int   ftype)
{
 struct xfs_mount *mp = sc->mp;

 if (!xfs_has_ftype(mp)) {
  if (ftype != XFS_DIR3_FT_UNKNOWN && ftype != XFS_DIR3_FT_DIR)
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
  return;
 }

 if (xfs_mode_to_ftype(VFS_I(ip)->i_mode) != ftype)
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);

 /*
  * Metadata and regular inodes cannot cross trees.  This property
  * cannot change without a full inode free and realloc cycle, so it's
  * safe to check this without holding locks.
 */
 if (xfs_is_metadir_inode(ip) != xfs_is_metadir_inode(sc->ip))
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
}

/*
 * Try to lock a child file for checking parent pointers.  Returns the inode
 * flags for the locks we now hold, or zero if we failed.
 */
STATIC unsigned int
xchk_dir_lock_child(
 struct xfs_scrub *sc,
 struct xfs_inode *ip)
{
 if (!xfs_ilock_nowait(ip, XFS_IOLOCK_SHARED))
  return 0;

 if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED)) {
  xfs_iunlock(ip, XFS_IOLOCK_SHARED);
  return 0;
 }

 if (!xfs_inode_has_attr_fork(ip) || !xfs_need_iread_extents(&ip->i_af))
  return XFS_IOLOCK_SHARED | XFS_ILOCK_SHARED;

 xfs_iunlock(ip, XFS_ILOCK_SHARED);

 if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
  xfs_iunlock(ip, XFS_IOLOCK_SHARED);
  return 0;
 }

 return XFS_IOLOCK_SHARED | XFS_ILOCK_EXCL;
}

/* Check the backwards link (parent pointer) associated with this dirent. */
STATIC int
xchk_dir_parent_pointer(
 struct xchk_dir  *sd,
 const struct xfs_name *name,
 struct xfs_inode *ip)
{
 struct xfs_scrub *sc = sd->sc;
 int   error;

 xfs_inode_to_parent_rec(&sd->pptr_rec, sc->ip);
 error = xfs_parent_lookup(sc->tp, ip, name, &sd->pptr_rec,
   &sd->pptr_args);
 if (error == -ENOATTR)
  xchk_fblock_xref_set_corrupt(sc, XFS_DATA_FORK, 0);

 return 0;
}

/* Look for a parent pointer matching this dirent, if the child isn't busy. */
STATIC int
xchk_dir_check_pptr_fast(
 struct xchk_dir  *sd,
 xfs_dir2_dataptr_t dapos,
 const struct xfs_name *name,
 struct xfs_inode *ip)
{
 struct xfs_scrub *sc = sd->sc;
 unsigned int  lockmode;
 int   error;

 /* dot and dotdot entries do not have parent pointers */
 if (xfs_dir2_samename(name, &xfs_name_dot) ||
     xfs_dir2_samename(name, &xfs_name_dotdot))
  return 0;

 /* No self-referential non-dot or dotdot dirents. */
 if (ip == sc->ip) {
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
  return -ECANCELED;
 }

 /* Try to lock the inode. */
 lockmode = xchk_dir_lock_child(sc, ip);
 if (!lockmode) {
  struct xchk_dirent save_de = {
   .namelen = name->len,
   .ino  = ip->i_ino,
  };

  /* Couldn't lock the inode, so save the dirent for later. */
  trace_xchk_dir_defer(sc->ip, name, ip->i_ino);

  error = xfblob_storename(sd->dir_names, &save_de.name_cookie,
    name);
  if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0,
     &error))
   return error;

  error = xfarray_append(sd->dir_entries, &save_de);
  if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0,
     &error))
   return error;

  return 0;
 }

 error = xchk_dir_parent_pointer(sd, name, ip);
 xfs_iunlock(ip, lockmode);
 return error;
}

/*
 * Scrub a single directory entry.
 *
 * Check the inode number to make sure it's sane, then we check that we can
 * look up this filename.  Finally, we check the ftype.
 */
STATIC int
xchk_dir_actor(
 struct xfs_scrub *sc,
 struct xfs_inode *dp,
 xfs_dir2_dataptr_t dapos,
 const struct xfs_name *name,
 xfs_ino_t  ino,
 void   *priv)
{
 struct xfs_mount *mp = dp->i_mount;
 struct xfs_inode *ip;
 struct xchk_dir  *sd = priv;
 xfs_ino_t  lookup_ino;
 xfs_dablk_t  offset;
 int   error = 0;

 offset = xfs_dir2_db_to_da(mp->m_dir_geo,
   xfs_dir2_dataptr_to_db(mp->m_dir_geo, dapos));

 if (xchk_should_terminate(sc, &error))
  return error;

 /* Does this inode number make sense? */
 if (!xfs_verify_dir_ino(mp, ino)) {
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
  return -ECANCELED;
 }

 /* Does this name make sense? */
 if (!xfs_dir2_namecheck(name->name, name->len)) {
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
  return -ECANCELED;
 }

 if (xfs_dir2_samename(name, &xfs_name_dot)) {
  /* If this is "." then check that the inum matches the dir. */
  if (ino != dp->i_ino)
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
 } else if (xfs_dir2_samename(name, &xfs_name_dotdot)) {
  /*
   * If this is ".." in the root inode, check that the inum
   * matches this dir.
 */
  if (xchk_inode_is_dirtree_root(dp) && ino != dp->i_ino)
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
 }

 /* Verify that we can look up this name by hash. */
 error = xchk_dir_lookup(sc, dp, name, &lookup_ino);
 /* ENOENT means the hash lookup failed and the dir is corrupt */
 if (error == -ENOENT)
  error = -EFSCORRUPTED;
 if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, offset, &error))
  goto out;
 if (lookup_ino != ino) {
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
  return -ECANCELED;
 }

 /*
  * Grab the inode pointed to by the dirent.  We release the inode
  * before we cancel the scrub transaction.
  *
  * If _iget returns -EINVAL or -ENOENT then the child inode number is
  * garbage and the directory is corrupt.  If the _iget returns
  * -EFSCORRUPTED or -EFSBADCRC then the child is corrupt which is a
  *  cross referencing error.  Any other error is an operational error.
 */
 error = xchk_iget(sc, ino, &ip);
 if (error == -EINVAL || error == -ENOENT) {
  error = -EFSCORRUPTED;
  xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error);
  goto out;
 }
 if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, offset, &error))
  goto out;

 xchk_dir_check_ftype(sc, offset, ip, name->type);

 if (xfs_has_parent(mp)) {
  error = xchk_dir_check_pptr_fast(sd, dapos, name, ip);
  if (error)
   goto out_rele;
 }

out_rele:
 xchk_irele(sc, ip);
out:
 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
  return -ECANCELED;
 return error;
}

/* Scrub a directory btree record. */
STATIC int
xchk_dir_rec(
 struct xchk_da_btree  *ds,
 int    level)
{
 struct xfs_name   dname = { };
 struct xfs_da_state_blk  *blk = &ds->state->path.blk[level];
 struct xfs_mount  *mp = ds->state->mp;
 struct xfs_inode  *dp = ds->dargs.dp;
 struct xfs_da_geometry  *geo = mp->m_dir_geo;
 struct xfs_dir2_data_entry *dent;
 struct xfs_buf   *bp;
 struct xfs_dir2_leaf_entry *ent;
 unsigned int   end;
 unsigned int   iter_off;
 xfs_ino_t   ino;
 xfs_dablk_t   rec_bno;
 xfs_dir2_db_t   db;
 xfs_dir2_data_aoff_t  off;
 xfs_dir2_dataptr_t  ptr;
 xfs_dahash_t   calc_hash;
 xfs_dahash_t   hash;
 struct xfs_dir3_icleaf_hdr hdr;
 unsigned int   tag;
 int    error;

 ASSERT(blk->magic == XFS_DIR2_LEAF1_MAGIC ||
        blk->magic == XFS_DIR2_LEAFN_MAGIC);

 xfs_dir2_leaf_hdr_from_disk(mp, &hdr, blk->bp->b_addr);
 ent = hdr.ents + blk->index;

 /* Check the hash of the entry. */
 error = xchk_da_btree_hash(ds, level, &ent->hashval);
 if (error)
  goto out;

 /* Valid hash pointer? */
 ptr = be32_to_cpu(ent->address);
 if (ptr == 0)
  return 0;

 /* Find the directory entry's location. */
 db = xfs_dir2_dataptr_to_db(geo, ptr);
 off = xfs_dir2_dataptr_to_off(geo, ptr);
 rec_bno = xfs_dir2_db_to_da(geo, db);

 if (rec_bno >= geo->leafblk) {
  xchk_da_set_corrupt(ds, level);
  goto out;
 }
 error = xfs_dir3_data_read(ds->dargs.trans, dp, ds->dargs.owner,
   rec_bno, XFS_DABUF_MAP_HOLE_OK, &bp);
 if (!xchk_fblock_process_error(ds->sc, XFS_DATA_FORK, rec_bno,
   &error))
  goto out;
 if (!bp) {
  xchk_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
  goto out;
 }
 xchk_buffer_recheck(ds->sc, bp);

 if (ds->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
  goto out_relse;

 dent = bp->b_addr + off;

 /* Make sure we got a real directory entry. */
 iter_off = geo->data_entry_offset;
 end = xfs_dir3_data_end_offset(geo, bp->b_addr);
 if (!end) {
  xchk_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
  goto out_relse;
 }
 for (;;) {
  struct xfs_dir2_data_entry *dep = bp->b_addr + iter_off;
  struct xfs_dir2_data_unused *dup = bp->b_addr + iter_off;

  if (iter_off >= end) {
   xchk_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
   goto out_relse;
  }

  if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
   iter_off += be16_to_cpu(dup->length);
   continue;
  }
  if (dep == dent)
   break;
  iter_off += xfs_dir2_data_entsize(mp, dep->namelen);
 }

 /* Retrieve the entry, sanity check it, and compare hashes. */
 ino = be64_to_cpu(dent->inumber);
 hash = be32_to_cpu(ent->hashval);
 tag = be16_to_cpup(xfs_dir2_data_entry_tag_p(mp, dent));
 if (!xfs_verify_dir_ino(mp, ino) || tag != off)
  xchk_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
 if (dent->namelen == 0) {
  xchk_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
  goto out_relse;
 }

 /* Does the directory hash match? */
 dname.name = dent->name;
 dname.len = dent->namelen;
 calc_hash = xfs_dir2_hashname(mp, &dname);
 if (calc_hash != hash)
  xchk_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);

out_relse:
 xfs_trans_brelse(ds->dargs.trans, bp);
out:
 return error;
}

/*
 * Is this unused entry either in the bestfree or smaller than all of
 * them?  We've already checked that the bestfrees are sorted longest to
 * shortest, and that there aren't any bogus entries.
 */
STATIC void
xchk_directory_check_free_entry(
 struct xfs_scrub  *sc,
 xfs_dablk_t   lblk,
 struct xfs_dir2_data_free *bf,
 struct xfs_dir2_data_unused *dup)
{
 struct xfs_dir2_data_free *dfp;
 unsigned int   dup_length;

 dup_length = be16_to_cpu(dup->length);

 /* Unused entry is shorter than any of the bestfrees */
 if (dup_length < be16_to_cpu(bf[XFS_DIR2_DATA_FD_COUNT - 1].length))
  return;

 for (dfp = &bf[XFS_DIR2_DATA_FD_COUNT - 1]; dfp >= bf; dfp--)
  if (dup_length == be16_to_cpu(dfp->length))
   return;

 /* Unused entry should be in the bestfrees but wasn't found. */
 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
}

/* Check free space info in a directory data block. */
STATIC int
xchk_directory_data_bestfree(
 struct xfs_scrub  *sc,
 xfs_dablk_t   lblk,
 bool    is_block)
{
 struct xfs_dir2_data_unused *dup;
 struct xfs_dir2_data_free *dfp;
 struct xfs_buf   *bp;
 struct xfs_dir2_data_free *bf;
 struct xfs_mount  *mp = sc->mp;
 u16    tag;
 unsigned int   nr_bestfrees = 0;
 unsigned int   nr_frees = 0;
 unsigned int   smallest_bestfree;
 int    newlen;
 unsigned int   offset;
 unsigned int   end;
 int    error;

 if (is_block) {
  /* dir block format */
  if (lblk != XFS_B_TO_FSBT(mp, XFS_DIR2_DATA_OFFSET))
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
  error = xfs_dir3_block_read(sc->tp, sc->ip, sc->ip->i_ino, &bp);
 } else {
  /* dir data format */
  error = xfs_dir3_data_read(sc->tp, sc->ip, sc->ip->i_ino, lblk,
    0, &bp);
 }
 if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, lblk, &error))
  goto out;
 xchk_buffer_recheck(sc, bp);

 /* XXX: Check xfs_dir3_data_hdr.pad is zero once we start setting it. */

 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
  goto out_buf;

 /* Do the bestfrees correspond to actual free space? */
 bf = xfs_dir2_data_bestfree_p(mp, bp->b_addr);
 smallest_bestfree = UINT_MAX;
 for (dfp = &bf[0]; dfp < &bf[XFS_DIR2_DATA_FD_COUNT]; dfp++) {
  offset = be16_to_cpu(dfp->offset);
  if (offset == 0)
   continue;
  if (offset >= mp->m_dir_geo->blksize) {
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
   goto out_buf;
  }
  dup = bp->b_addr + offset;
  tag = be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup));

  /* bestfree doesn't match the entry it points at? */
  if (dup->freetag != cpu_to_be16(XFS_DIR2_DATA_FREE_TAG) ||
      be16_to_cpu(dup->length) != be16_to_cpu(dfp->length) ||
      tag != offset) {
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
   goto out_buf;
  }

  /* bestfree records should be ordered largest to smallest */
  if (smallest_bestfree < be16_to_cpu(dfp->length)) {
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
   goto out_buf;
  }

  smallest_bestfree = be16_to_cpu(dfp->length);
  nr_bestfrees++;
 }

 /* Make sure the bestfrees are actually the best free spaces. */
 offset = mp->m_dir_geo->data_entry_offset;
 end = xfs_dir3_data_end_offset(mp->m_dir_geo, bp->b_addr);

 /* Iterate the entries, stopping when we hit or go past the end. */
 while (offset < end) {
  dup = bp->b_addr + offset;

  /* Skip real entries */
  if (dup->freetag != cpu_to_be16(XFS_DIR2_DATA_FREE_TAG)) {
   struct xfs_dir2_data_entry *dep = bp->b_addr + offset;

   newlen = xfs_dir2_data_entsize(mp, dep->namelen);
   if (newlen <= 0) {
    xchk_fblock_set_corrupt(sc, XFS_DATA_FORK,
      lblk);
    goto out_buf;
   }
   offset += newlen;
   continue;
  }

  /* Spot check this free entry */
  tag = be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup));
  if (tag != offset) {
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
   goto out_buf;
  }

  /*
   * Either this entry is a bestfree or it's smaller than
   * any of the bestfrees.
 */
  xchk_directory_check_free_entry(sc, lblk, bf, dup);
  if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
   goto out_buf;

  /* Move on. */
  newlen = be16_to_cpu(dup->length);
  if (newlen <= 0) {
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
   goto out_buf;
  }
  offset += newlen;
  if (offset <= end)
   nr_frees++;
 }

 /* We're required to fill all the space. */
 if (offset != end)
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);

 /* Did we see at least as many free slots as there are bestfrees? */
 if (nr_frees < nr_bestfrees)
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
out_buf:
 xfs_trans_brelse(sc->tp, bp);
out:
 return error;
}

/*
 * Does the free space length in the free space index block ($len) match
 * the longest length in the directory data block's bestfree array?
 * Assume that we've already checked that the data block's bestfree
 * array is in order.
 */
STATIC void
xchk_directory_check_freesp(
 struct xfs_scrub  *sc,
 xfs_dablk_t   lblk,
 struct xfs_buf   *dbp,
 unsigned int   len)
{
 struct xfs_dir2_data_free *dfp;

 dfp = xfs_dir2_data_bestfree_p(sc->mp, dbp->b_addr);

 if (len != be16_to_cpu(dfp->length))
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);

 if (len > 0 && be16_to_cpu(dfp->offset) == 0)
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
}

/* Check free space info in a directory leaf1 block. */
STATIC int
xchk_directory_leaf1_bestfree(
 struct xfs_scrub  *sc,
 struct xfs_da_args  *args,
 xfs_dir2_db_t   last_data_db,
 xfs_dablk_t   lblk)
{
 struct xfs_dir3_icleaf_hdr leafhdr;
 struct xfs_dir2_leaf_tail *ltp;
 struct xfs_dir2_leaf  *leaf;
 struct xfs_buf   *dbp;
 struct xfs_buf   *bp;
 struct xfs_da_geometry  *geo = sc->mp->m_dir_geo;
 __be16    *bestp;
 __u16    best;
 __u32    hash;
 __u32    lasthash = 0;
 __u32    bestcount;
 unsigned int   stale = 0;
 int    i;
 int    error;

 /* Read the free space block. */
 error = xfs_dir3_leaf_read(sc->tp, sc->ip, sc->ip->i_ino, lblk, &bp);
 if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, lblk, &error))
  return error;
 xchk_buffer_recheck(sc, bp);

 leaf = bp->b_addr;
 xfs_dir2_leaf_hdr_from_disk(sc->ip->i_mount, &leafhdr, leaf);
 ltp = xfs_dir2_leaf_tail_p(geo, leaf);
 bestcount = be32_to_cpu(ltp->bestcount);
 bestp = xfs_dir2_leaf_bests_p(ltp);

 if (xfs_has_crc(sc->mp)) {
  struct xfs_dir3_leaf_hdr *hdr3 = bp->b_addr;

  if (hdr3->pad != cpu_to_be32(0))
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
 }

 /*
  * There must be enough bestfree slots to cover all the directory data
  * blocks that we scanned.  It is possible for there to be a hole
  * between the last data block and i_disk_size.  This seems like an
  * oversight to the scrub author, but as we have been writing out
  * directories like this (and xfs_repair doesn't mind them) for years,
  * that's what we have to check.
 */
 if (bestcount != last_data_db + 1) {
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
  goto out;
 }

 /* Is the leaf count even remotely sane? */
 if (leafhdr.count > geo->leaf_max_ents) {
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
  goto out;
 }

 /* Leaves and bests don't overlap in leaf format. */
 if ((char *)&leafhdr.ents[leafhdr.count] > (char *)bestp) {
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
  goto out;
 }

 /* Check hash value order, count stale entries.  */
 for (i = 0; i < leafhdr.count; i++) {
  hash = be32_to_cpu(leafhdr.ents[i].hashval);
  if (i > 0 && lasthash > hash)
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
  lasthash = hash;
  if (leafhdr.ents[i].address ==
      cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
   stale++;
 }
 if (leafhdr.stale != stale)
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
  goto out;

 /* Check all the bestfree entries. */
 for (i = 0; i < bestcount; i++, bestp++) {
  best = be16_to_cpu(*bestp);
  error = xfs_dir3_data_read(sc->tp, sc->ip, args->owner,
    xfs_dir2_db_to_da(args->geo, i),
    XFS_DABUF_MAP_HOLE_OK, &dbp);
  if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, lblk,
    &error))
   break;

  if (!dbp) {
   if (best != NULLDATAOFF) {
    xchk_fblock_set_corrupt(sc, XFS_DATA_FORK,
      lblk);
    break;
   }
   continue;
  }

  if (best == NULLDATAOFF)
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
  else
   xchk_directory_check_freesp(sc, lblk, dbp, best);
  xfs_trans_brelse(sc->tp, dbp);
  if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
   break;
 }
out:
 xfs_trans_brelse(sc->tp, bp);
 return error;
}

/* Check free space info in a directory freespace block. */
STATIC int
xchk_directory_free_bestfree(
 struct xfs_scrub  *sc,
 struct xfs_da_args  *args,
 xfs_dablk_t   lblk)
{
 struct xfs_dir3_icfree_hdr freehdr;
 struct xfs_buf   *dbp;
 struct xfs_buf   *bp;
 __u16    best;
 unsigned int   stale = 0;
 int    i;
 int    error;

 /* Read the free space block */
 error = xfs_dir2_free_read(sc->tp, sc->ip, sc->ip->i_ino, lblk, &bp);
 if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, lblk, &error))
  return error;
 xchk_buffer_recheck(sc, bp);

 if (xfs_has_crc(sc->mp)) {
  struct xfs_dir3_free_hdr *hdr3 = bp->b_addr;

  if (hdr3->pad != cpu_to_be32(0))
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
 }

 /* Check all the entries. */
 xfs_dir2_free_hdr_from_disk(sc->ip->i_mount, &freehdr, bp->b_addr);
 for (i = 0; i < freehdr.nvalid; i++) {
  best = be16_to_cpu(freehdr.bests[i]);
  if (best == NULLDATAOFF) {
   stale++;
   continue;
  }
  error = xfs_dir3_data_read(sc->tp, sc->ip, args->owner,
    (freehdr.firstdb + i) * args->geo->fsbcount,
    0, &dbp);
  if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, lblk,
    &error))
   goto out;
  xchk_directory_check_freesp(sc, lblk, dbp, best);
  xfs_trans_brelse(sc->tp, dbp);
 }

 if (freehdr.nused + stale != freehdr.nvalid)
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
out:
 xfs_trans_brelse(sc->tp, bp);
 return error;
}

/* Check free space information in directories. */
STATIC int
xchk_directory_blocks(
 struct xfs_scrub *sc)
{
 struct xfs_bmbt_irec got;
 struct xfs_da_args args = {
  .dp  = sc->ip,
  .whichfork = XFS_DATA_FORK,
  .geo  = sc->mp->m_dir_geo,
  .trans  = sc->tp,
  .owner  = sc->ip->i_ino,
 };
 struct xfs_ifork *ifp = xfs_ifork_ptr(sc->ip, XFS_DATA_FORK);
 struct xfs_mount *mp = sc->mp;
 xfs_fileoff_t  leaf_lblk;
 xfs_fileoff_t  free_lblk;
 xfs_fileoff_t  lblk;
 struct xfs_iext_cursor icur;
 xfs_dablk_t  dabno;
 xfs_dir2_db_t  last_data_db = 0;
 bool   found;
 bool   is_block = false;
 int   error;

 /* Ignore local format directories. */
 if (ifp->if_format != XFS_DINODE_FMT_EXTENTS &&
     ifp->if_format != XFS_DINODE_FMT_BTREE)
  return 0;

 lblk = XFS_B_TO_FSB(mp, XFS_DIR2_DATA_OFFSET);
 leaf_lblk = XFS_B_TO_FSB(mp, XFS_DIR2_LEAF_OFFSET);
 free_lblk = XFS_B_TO_FSB(mp, XFS_DIR2_FREE_OFFSET);

 /* Is this a block dir? */
 if (xfs_dir2_format(&args, &error) == XFS_DIR2_FMT_BLOCK)
  is_block = true;
 if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, lblk, &error))
  goto out;

 /* Iterate all the data extents in the directory... */
 found = xfs_iext_lookup_extent(sc->ip, ifp, lblk, &icur, &got);
 while (found && !(sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)) {
  /* No more data blocks... */
  if (got.br_startoff >= leaf_lblk)
   break;

  /*
   * Check each data block's bestfree data.
   *
   * Iterate all the fsbcount-aligned block offsets in
   * this directory.  The directory block reading code is
   * smart enough to do its own bmap lookups to handle
   * discontiguous directory blocks.  When we're done
   * with the extent record, re-query the bmap at the
   * next fsbcount-aligned offset to avoid redundant
   * block checks.
 */
  for (lblk = roundup((xfs_dablk_t)got.br_startoff,
    args.geo->fsbcount);
       lblk < got.br_startoff + got.br_blockcount;
       lblk += args.geo->fsbcount) {
   last_data_db = xfs_dir2_da_to_db(args.geo, lblk);
   error = xchk_directory_data_bestfree(sc, lblk,
     is_block);
   if (error)
    goto out;
  }
  dabno = got.br_startoff + got.br_blockcount;
  lblk = roundup(dabno, args.geo->fsbcount);
  found = xfs_iext_lookup_extent(sc->ip, ifp, lblk, &icur, &got);
 }

 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
  goto out;

 /* Look for a leaf1 block, which has free info. */
 if (xfs_iext_lookup_extent(sc->ip, ifp, leaf_lblk, &icur, &got) &&
     got.br_startoff == leaf_lblk &&
     got.br_blockcount == args.geo->fsbcount &&
     !xfs_iext_next_extent(ifp, &icur, &got)) {
  if (is_block) {
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
   goto out;
  }
  error = xchk_directory_leaf1_bestfree(sc, &args, last_data_db,
    leaf_lblk);
  if (error)
   goto out;
 }

 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
  goto out;

 /* Scan for free blocks */
 lblk = free_lblk;
 found = xfs_iext_lookup_extent(sc->ip, ifp, lblk, &icur, &got);
 while (found && !(sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)) {
  /*
   * Dirs can't have blocks mapped above 2^32.
   * Single-block dirs shouldn't even be here.
 */
  lblk = got.br_startoff;
  if (lblk & ~0xFFFFFFFFULL) {
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
   goto out;
  }
  if (is_block) {
   xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
   goto out;
  }

  /*
   * Check each dir free block's bestfree data.
   *
   * Iterate all the fsbcount-aligned block offsets in
   * this directory.  The directory block reading code is
   * smart enough to do its own bmap lookups to handle
   * discontiguous directory blocks.  When we're done
   * with the extent record, re-query the bmap at the
   * next fsbcount-aligned offset to avoid redundant
   * block checks.
 */
  for (lblk = roundup((xfs_dablk_t)got.br_startoff,
    args.geo->fsbcount);
       lblk < got.br_startoff + got.br_blockcount;
       lblk += args.geo->fsbcount) {
   error = xchk_directory_free_bestfree(sc, &args,
     lblk);
   if (error)
    goto out;
  }
  dabno = got.br_startoff + got.br_blockcount;
  lblk = roundup(dabno, args.geo->fsbcount);
  found = xfs_iext_lookup_extent(sc->ip, ifp, lblk, &icur, &got);
 }
out:
 return error;
}

/*
 * Revalidate a dirent that we collected in the past but couldn't check because
 * of lock contention.  Returns 0 if the dirent is still valid, -ENOENT if it
 * has gone away on us, or a negative errno.
 */
STATIC int
xchk_dir_revalidate_dirent(
 struct xchk_dir  *sd,
 const struct xfs_name *xname,
 xfs_ino_t  ino)
{
 struct xfs_scrub *sc = sd->sc;
 xfs_ino_t  child_ino;
 int   error;

 /*
  * Look up the directory entry.  If we get -ENOENT, the directory entry
  * went away and there's nothing to revalidate.  Return any other
  * error.
 */
 error = xchk_dir_lookup(sc, sc->ip, xname, &child_ino);
 if (error)
  return error;

 /* The inode number changed, nothing to revalidate. */
 if (ino != child_ino)
  return -ENOENT;

 return 0;
}

/*
 * Check a directory entry's parent pointers the slow way, which means we cycle
 * locks a bunch and put up with revalidation until we get it done.
 */
STATIC int
xchk_dir_slow_dirent(
 struct xchk_dir  *sd,
 struct xchk_dirent *dirent,
 const struct xfs_name *xname)
{
 struct xfs_scrub *sc = sd->sc;
 struct xfs_inode *ip;
 unsigned int  lockmode;
 int   error;

 /* Check that the deferred dirent still exists. */
 if (sd->need_revalidate) {
  error = xchk_dir_revalidate_dirent(sd, xname, dirent->ino);
  if (error == -ENOENT)
   return 0;
  if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0,
     &error))
   return error;
 }

 error = xchk_iget(sc, dirent->ino, &ip);
 if (error == -EINVAL || error == -ENOENT) {
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
  return 0;
 }
 if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0, &error))
  return error;

 /*
  * If we can grab both IOLOCK and ILOCK of the alleged child, we can
  * proceed with the validation.
 */
 lockmode = xchk_dir_lock_child(sc, ip);
 if (lockmode) {
  trace_xchk_dir_slowpath(sc->ip, xname, ip->i_ino);
  goto check_pptr;
 }

 /*
  * We couldn't lock the child file.  Drop all the locks and try to
  * get them again, one at a time.
 */
 xchk_iunlock(sc, sc->ilock_flags);
 sd->need_revalidate = true;

 trace_xchk_dir_ultraslowpath(sc->ip, xname, ip->i_ino);

 error = xchk_dir_trylock_for_pptrs(sc, ip, &lockmode);
 if (error)
  goto out_rele;

 /* Revalidate, since we just cycled the locks. */
 error = xchk_dir_revalidate_dirent(sd, xname, dirent->ino);
 if (error == -ENOENT) {
  error = 0;
  goto out_unlock;
 }
 if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0, &error))
  goto out_unlock;

check_pptr:
 error = xchk_dir_parent_pointer(sd, xname, ip);
out_unlock:
 xfs_iunlock(ip, lockmode);
out_rele:
 xchk_irele(sc, ip);
 return error;
}

/* Check all the dirents that we deferred the first time around. */
STATIC int
xchk_dir_finish_slow_dirents(
 struct xchk_dir  *sd)
{
 xfarray_idx_t  array_cur;
 int   error;

 foreach_xfarray_idx(sd->dir_entries, array_cur) {
  struct xchk_dirent dirent;

  if (sd->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
   return 0;

  error = xfarray_load(sd->dir_entries, array_cur, &dirent);
  if (error)
   return error;

  error = xfblob_loadname(sd->dir_names, dirent.name_cookie,
    &sd->xname, dirent.namelen);
  if (error)
   return error;

  error = xchk_dir_slow_dirent(sd, &dirent, &sd->xname);
  if (error)
   return error;
 }

 return 0;
}

/* Scrub a whole directory. */
int
xchk_directory(
 struct xfs_scrub *sc)
{
 struct xchk_dir  *sd;
 int   error;

 if (!S_ISDIR(VFS_I(sc->ip)->i_mode))
  return -ENOENT;

 if (xchk_file_looks_zapped(sc, XFS_SICK_INO_DIR_ZAPPED)) {
  xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
  return 0;
 }

 /* Plausible size? */
 if (sc->ip->i_disk_size < xfs_dir2_sf_hdr_size(0)) {
  xchk_ino_set_corrupt(sc, sc->ip->i_ino);
  return 0;
 }

 /* Check directory tree structure */
 error = xchk_da_btree(sc, XFS_DATA_FORK, xchk_dir_rec, NULL);
 if (error)
  return error;

 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
  return 0;

 /* Check the freespace. */
 error = xchk_directory_blocks(sc);
 if (error)
  return error;

 if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
  return 0;

 sd = kvzalloc(sizeof(struct xchk_dir), XCHK_GFP_FLAGS);
 if (!sd)
  return -ENOMEM;
 sd->sc = sc;
 sd->xname.name = sd->namebuf;

 if (xfs_has_parent(sc->mp)) {
  char  *descr;

  /*
   * Set up some staging memory for dirents that we can't check
   * due to locking contention.
 */
  descr = xchk_xfile_ino_descr(sc, "slow directory entries");
  error = xfarray_create(descr, 0, sizeof(struct xchk_dirent),
    &sd->dir_entries);
  kfree(descr);
  if (error)
   goto out_sd;

  descr = xchk_xfile_ino_descr(sc, "slow directory entry names");
  error = xfblob_create(descr, &sd->dir_names);
  kfree(descr);
  if (error)
   goto out_entries;
 }

 /* Look up every name in this directory by hash. */
 error = xchk_dir_walk(sc, sc->ip, xchk_dir_actor, sd);
 if (error == -ECANCELED)
  error = 0;
 if (error)
  goto out_names;

 if (xfs_has_parent(sc->mp)) {
  error = xchk_dir_finish_slow_dirents(sd);
  if (error == -ETIMEDOUT) {
   /* Couldn't grab a lock, scrub was marked incomplete */
   error = 0;
   goto out_names;
  }
  if (error)
   goto out_names;
 }

out_names:
 if (sd->dir_names)
  xfblob_destroy(sd->dir_names);
out_entries:
 if (sd->dir_entries)
  xfarray_destroy(sd->dir_entries);
out_sd:
 kvfree(sd);
 if (error)
  return error;

 /* If the dir is clean, it is clearly not zapped. */
 xchk_mark_healthy_if_clean(sc, XFS_SICK_INO_DIR_ZAPPED);
 return 0;
}

/*
 * Decide if this directory has been zapped to satisfy the inode and ifork
 * verifiers.  Checking and repairing should be postponed until the directory
 * is fixed.
 */
bool
xchk_dir_looks_zapped(
 struct xfs_inode *dp)
{
 /* Repair zapped this dir's data fork a short time ago */
 if (xfs_ifork_zapped(dp, XFS_DATA_FORK))
  return true;

 /*
  * If the dinode repair found a bad data fork, it will reset the fork
  * to extents format with zero records and wait for the bmapbtd
  * scrubber to reconstruct the block mappings.  Directories always
  * contain some content, so this is a clear sign of a zapped directory.
  * The state checked by xfs_ifork_zapped is not persisted, so this is
  * the secondary strategy if repairs are interrupted by a crash or an
  * unmount.
 */
 return dp->i_df.if_format == XFS_DINODE_FMT_EXTENTS &&
        dp->i_df.if_nextents == 0;
}