Contributors: 7
Author Tokens Token Proportion Commits Commit Proportion
Darrick J. Wong 1256 96.99% 11 45.83%
David Chinner 17 1.31% 6 25.00%
Christoph Hellwig 7 0.54% 3 12.50%
Russell Cattelan 7 0.54% 1 4.17%
Michal Marek 4 0.31% 1 4.17%
Timothy Shimmin 3 0.23% 1 4.17%
Nathan Scott 1 0.08% 1 4.17%
Total 1295 24 


// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (c) 2022-2024 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_log_format.h"
#include "xfs_trans_resv.h"
#include "xfs_mount.h"
#include "xfs_inode.h"
#include "xfs_da_format.h"
#include "xfs_da_btree.h"
#include "xfs_attr.h"
#include "xfs_attr_leaf.h"
#include "xfs_attr_sf.h"
#include "xfs_trans.h"
#include "scrub/scrub.h"
#include "scrub/bitmap.h"
#include "scrub/dab_bitmap.h"
#include "scrub/listxattr.h"

/* Call a function for every entry in a shortform xattr structure. */
STATIC int
xchk_xattr_walk_sf(
	struct xfs_scrub		*sc,
	struct xfs_inode		*ip,
	xchk_xattr_fn			attr_fn,
	void				*priv)
{
	struct xfs_attr_sf_hdr		*hdr = ip->i_af.if_data;
	struct xfs_attr_sf_entry	*sfe;
	unsigned int			i;
	int				error;

	sfe = xfs_attr_sf_firstentry(hdr);
	for (i = 0; i < hdr->count; i++) {
		error = attr_fn(sc, ip, sfe->flags, sfe->nameval, sfe->namelen,
				&sfe->nameval[sfe->namelen], sfe->valuelen,
				priv);
		if (error)
			return error;

		sfe = xfs_attr_sf_nextentry(sfe);
	}

	return 0;
}

/* Call a function for every entry in this xattr leaf block. */
STATIC int
xchk_xattr_walk_leaf_entries(
	struct xfs_scrub		*sc,
	struct xfs_inode		*ip,
	xchk_xattr_fn			attr_fn,
	struct xfs_buf			*bp,
	void				*priv)
{
	struct xfs_attr3_icleaf_hdr	ichdr;
	struct xfs_mount		*mp = sc->mp;
	struct xfs_attr_leafblock	*leaf = bp->b_addr;
	struct xfs_attr_leaf_entry	*entry;
	unsigned int			i;
	int				error;

	xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, leaf);
	entry = xfs_attr3_leaf_entryp(leaf);

	for (i = 0; i < ichdr.count; entry++, i++) {
		void			*value;
		unsigned char		*name;
		unsigned int		namelen, valuelen;

		if (entry->flags & XFS_ATTR_LOCAL) {
			struct xfs_attr_leaf_name_local		*name_loc;

			name_loc = xfs_attr3_leaf_name_local(leaf, i);
			name = name_loc->nameval;
			namelen = name_loc->namelen;
			value = &name_loc->nameval[name_loc->namelen];
			valuelen = be16_to_cpu(name_loc->valuelen);
		} else {
			struct xfs_attr_leaf_name_remote	*name_rmt;

			name_rmt = xfs_attr3_leaf_name_remote(leaf, i);
			name = name_rmt->name;
			namelen = name_rmt->namelen;
			value = NULL;
			valuelen = be32_to_cpu(name_rmt->valuelen);
		}

		error = attr_fn(sc, ip, entry->flags, name, namelen, value,
				valuelen, priv);
		if (error)
			return error;

	}

	return 0;
}

/*
 * Call a function for every entry in a leaf-format xattr structure.  Avoid
 * memory allocations for the loop detector since there's only one block.
 */
STATIC int
xchk_xattr_walk_leaf(
	struct xfs_scrub		*sc,
	struct xfs_inode		*ip,
	xchk_xattr_fn			attr_fn,
	void				*priv)
{
	struct xfs_buf			*leaf_bp;
	int				error;

	error = xfs_attr3_leaf_read(sc->tp, ip, ip->i_ino, 0, &leaf_bp);
	if (error)
		return error;

	error = xchk_xattr_walk_leaf_entries(sc, ip, attr_fn, leaf_bp, priv);
	xfs_trans_brelse(sc->tp, leaf_bp);
	return error;
}

/* Find the leftmost leaf in the xattr dabtree. */
STATIC int
xchk_xattr_find_leftmost_leaf(
	struct xfs_scrub		*sc,
	struct xfs_inode		*ip,
	struct xdab_bitmap		*seen_dablks,
	struct xfs_buf			**leaf_bpp)
{
	struct xfs_da3_icnode_hdr	nodehdr;
	struct xfs_mount		*mp = sc->mp;
	struct xfs_trans		*tp = sc->tp;
	struct xfs_da_intnode		*node;
	struct xfs_da_node_entry	*btree;
	struct xfs_buf			*bp;
	xfs_failaddr_t			fa;
	xfs_dablk_t			blkno = 0;
	unsigned int			expected_level = 0;
	int				error;

	for (;;) {
		xfs_extlen_t		len = 1;
		uint16_t		magic;

		/* Make sure we haven't seen this new block already. */
		if (xdab_bitmap_test(seen_dablks, blkno, &len))
			return -EFSCORRUPTED;

		error = xfs_da3_node_read(tp, ip, blkno, &bp, XFS_ATTR_FORK);
		if (error)
			return error;

		node = bp->b_addr;
		magic = be16_to_cpu(node->hdr.info.magic);
		if (magic == XFS_ATTR_LEAF_MAGIC ||
		    magic == XFS_ATTR3_LEAF_MAGIC)
			break;

		error = -EFSCORRUPTED;
		if (magic != XFS_DA_NODE_MAGIC &&
		    magic != XFS_DA3_NODE_MAGIC)
			goto out_buf;

		fa = xfs_da3_node_header_check(bp, ip->i_ino);
		if (fa)
			goto out_buf;

		xfs_da3_node_hdr_from_disk(mp, &nodehdr, node);

		if (nodehdr.count == 0 || nodehdr.level >= XFS_DA_NODE_MAXDEPTH)
			goto out_buf;

		/* Check the level from the root node. */
		if (blkno == 0)
			expected_level = nodehdr.level - 1;
		else if (expected_level != nodehdr.level)
			goto out_buf;
		else
			expected_level--;

		/* Remember that we've seen this node. */
		error = xdab_bitmap_set(seen_dablks, blkno, 1);
		if (error)
			goto out_buf;

		/* Find the next level towards the leaves of the dabtree. */
		btree = nodehdr.btree;
		blkno = be32_to_cpu(btree->before);
		xfs_trans_brelse(tp, bp);
	}

	error = -EFSCORRUPTED;
	fa = xfs_attr3_leaf_header_check(bp, ip->i_ino);
	if (fa)
		goto out_buf;

	if (expected_level != 0)
		goto out_buf;

	/* Remember that we've seen this leaf. */
	error = xdab_bitmap_set(seen_dablks, blkno, 1);
	if (error)
		goto out_buf;

	*leaf_bpp = bp;
	return 0;

out_buf:
	xfs_trans_brelse(tp, bp);
	return error;
}

/* Call a function for every entry in a node-format xattr structure. */
STATIC int
xchk_xattr_walk_node(
	struct xfs_scrub		*sc,
	struct xfs_inode		*ip,
	xchk_xattr_fn			attr_fn,
	xchk_xattrleaf_fn		leaf_fn,
	void				*priv)
{
	struct xfs_attr3_icleaf_hdr	leafhdr;
	struct xdab_bitmap		seen_dablks;
	struct xfs_mount		*mp = sc->mp;
	struct xfs_attr_leafblock	*leaf;
	struct xfs_buf			*leaf_bp;
	int				error;

	xdab_bitmap_init(&seen_dablks);

	error = xchk_xattr_find_leftmost_leaf(sc, ip, &seen_dablks, &leaf_bp);
	if (error)
		goto out_bitmap;

	for (;;) {
		xfs_extlen_t	len;

		error = xchk_xattr_walk_leaf_entries(sc, ip, attr_fn, leaf_bp,
				priv);
		if (error)
			goto out_leaf;

		/* Find the right sibling of this leaf block. */
		leaf = leaf_bp->b_addr;
		xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &leafhdr, leaf);
		if (leafhdr.forw == 0)
			goto out_leaf;

		xfs_trans_brelse(sc->tp, leaf_bp);

		if (leaf_fn) {
			error = leaf_fn(sc, priv);
			if (error)
				goto out_bitmap;
		}

		/* Make sure we haven't seen this new leaf already. */
		len = 1;
		if (xdab_bitmap_test(&seen_dablks, leafhdr.forw, &len)) {
			error = -EFSCORRUPTED;
			goto out_bitmap;
		}

		error = xfs_attr3_leaf_read(sc->tp, ip, ip->i_ino,
				leafhdr.forw, &leaf_bp);
		if (error)
			goto out_bitmap;

		/* Remember that we've seen this new leaf. */
		error = xdab_bitmap_set(&seen_dablks, leafhdr.forw, 1);
		if (error)
			goto out_leaf;
	}

out_leaf:
	xfs_trans_brelse(sc->tp, leaf_bp);
out_bitmap:
	xdab_bitmap_destroy(&seen_dablks);
	return error;
}

/*
 * Call a function for every extended attribute in a file.
 *
 * Callers must hold the ILOCK.  No validation or cursor restarts allowed.
 * Returns -EFSCORRUPTED on any problem, including loops in the dabtree.
 */
int
xchk_xattr_walk(
	struct xfs_scrub	*sc,
	struct xfs_inode	*ip,
	xchk_xattr_fn		attr_fn,
	xchk_xattrleaf_fn	leaf_fn,
	void			*priv)
{
	int			error;

	xfs_assert_ilocked(ip, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL);

	if (!xfs_inode_hasattr(ip))
		return 0;

	if (ip->i_af.if_format == XFS_DINODE_FMT_LOCAL)
		return xchk_xattr_walk_sf(sc, ip, attr_fn, priv);

	/* attr functions require that the attr fork is loaded */
	error = xfs_iread_extents(sc->tp, ip, XFS_ATTR_FORK);
	if (error)
		return error;

	if (xfs_attr_is_leaf(ip))
		return xchk_xattr_walk_leaf(sc, ip, attr_fn, priv);

	return xchk_xattr_walk_node(sc, ip, attr_fn, leaf_fn, priv);
}