Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c517b3aa authored by Darrick J. Wong's avatar Darrick J. Wong
Browse files

xfs: shorten xfs_scrub_ prefix



Shorten all the metadata checking xfs_scrub_ prefixes to xchk_.  After
this, the only xfs_scrub* symbols are the ones that pertain to both
scrub and repair.  Whitespace damage will be fixed in a subsequent
patch.  There are no functional changes.

Signed-off-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: default avatarBrian Foster <bfoster@redhat.com>
parent ef97ef26
Loading
Loading
Loading
Loading
+159 −159

File changed.

Preview size limit exceeded, changes collapsed.

+28 −28
Original line number Diff line number Diff line
@@ -28,11 +28,11 @@
 * Set us up to scrub free space btrees.
 */
int
xfs_scrub_setup_ag_allocbt(
xchk_setup_ag_allocbt(
	struct xfs_scrub_context	*sc,
	struct xfs_inode		*ip)
{
	return xfs_scrub_setup_ag_btree(sc, ip, false);
	return xchk_setup_ag_btree(sc, ip, false);
}

/* Free space btree scrubber. */
@@ -41,7 +41,7 @@ xfs_scrub_setup_ag_allocbt(
 * bnobt/cntbt record, respectively.
 */
STATIC void
xfs_scrub_allocbt_xref_other(
xchk_allocbt_xref_other(
	struct xfs_scrub_context	*sc,
	xfs_agblock_t			agbno,
	xfs_extlen_t			len)
@@ -56,32 +56,32 @@ xfs_scrub_allocbt_xref_other(
		pcur = &sc->sa.cnt_cur;
	else
		pcur = &sc->sa.bno_cur;
	if (!*pcur || xfs_scrub_skip_xref(sc->sm))
	if (!*pcur || xchk_skip_xref(sc->sm))
		return;

	error = xfs_alloc_lookup_le(*pcur, agbno, len, &has_otherrec);
	if (!xfs_scrub_should_check_xref(sc, &error, pcur))
	if (!xchk_should_check_xref(sc, &error, pcur))
		return;
	if (!has_otherrec) {
		xfs_scrub_btree_xref_set_corrupt(sc, *pcur, 0);
		xchk_btree_xref_set_corrupt(sc, *pcur, 0);
		return;
	}

	error = xfs_alloc_get_rec(*pcur, &fbno, &flen, &has_otherrec);
	if (!xfs_scrub_should_check_xref(sc, &error, pcur))
	if (!xchk_should_check_xref(sc, &error, pcur))
		return;
	if (!has_otherrec) {
		xfs_scrub_btree_xref_set_corrupt(sc, *pcur, 0);
		xchk_btree_xref_set_corrupt(sc, *pcur, 0);
		return;
	}

	if (fbno != agbno || flen != len)
		xfs_scrub_btree_xref_set_corrupt(sc, *pcur, 0);
		xchk_btree_xref_set_corrupt(sc, *pcur, 0);
}

/* Cross-reference with the other btrees. */
STATIC void
xfs_scrub_allocbt_xref(
xchk_allocbt_xref(
	struct xfs_scrub_context	*sc,
	xfs_agblock_t			agbno,
	xfs_extlen_t			len)
@@ -89,16 +89,16 @@ xfs_scrub_allocbt_xref(
	if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
		return;

	xfs_scrub_allocbt_xref_other(sc, agbno, len);
	xfs_scrub_xref_is_not_inode_chunk(sc, agbno, len);
	xfs_scrub_xref_has_no_owner(sc, agbno, len);
	xfs_scrub_xref_is_not_shared(sc, agbno, len);
	xchk_allocbt_xref_other(sc, agbno, len);
	xchk_xref_is_not_inode_chunk(sc, agbno, len);
	xchk_xref_has_no_owner(sc, agbno, len);
	xchk_xref_is_not_shared(sc, agbno, len);
}

/* Scrub a bnobt/cntbt record. */
STATIC int
xfs_scrub_allocbt_rec(
	struct xfs_scrub_btree		*bs,
xchk_allocbt_rec(
	struct xchk_btree		*bs,
	union xfs_btree_rec		*rec)
{
	struct xfs_mount		*mp = bs->cur->bc_mp;
@@ -113,16 +113,16 @@ xfs_scrub_allocbt_rec(
	if (bno + len <= bno ||
	    !xfs_verify_agbno(mp, agno, bno) ||
	    !xfs_verify_agbno(mp, agno, bno + len - 1))
		xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
		xchk_btree_set_corrupt(bs->sc, bs->cur, 0);

	xfs_scrub_allocbt_xref(bs->sc, bno, len);
	xchk_allocbt_xref(bs->sc, bno, len);

	return error;
}

/* Scrub the freespace btrees for some AG. */
STATIC int
xfs_scrub_allocbt(
xchk_allocbt(
	struct xfs_scrub_context	*sc,
	xfs_btnum_t			which)
{
@@ -131,26 +131,26 @@ xfs_scrub_allocbt(

	xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_AG);
	cur = which == XFS_BTNUM_BNO ? sc->sa.bno_cur : sc->sa.cnt_cur;
	return xfs_scrub_btree(sc, cur, xfs_scrub_allocbt_rec, &oinfo, NULL);
	return xchk_btree(sc, cur, xchk_allocbt_rec, &oinfo, NULL);
}

int
xfs_scrub_bnobt(
xchk_bnobt(
	struct xfs_scrub_context	*sc)
{
	return xfs_scrub_allocbt(sc, XFS_BTNUM_BNO);
	return xchk_allocbt(sc, XFS_BTNUM_BNO);
}

int
xfs_scrub_cntbt(
xchk_cntbt(
	struct xfs_scrub_context	*sc)
{
	return xfs_scrub_allocbt(sc, XFS_BTNUM_CNT);
	return xchk_allocbt(sc, XFS_BTNUM_CNT);
}

/* xref check that the extent is not free */
void
xfs_scrub_xref_is_used_space(
xchk_xref_is_used_space(
	struct xfs_scrub_context	*sc,
	xfs_agblock_t			agbno,
	xfs_extlen_t			len)
@@ -158,12 +158,12 @@ xfs_scrub_xref_is_used_space(
	bool				is_freesp;
	int				error;

	if (!sc->sa.bno_cur || xfs_scrub_skip_xref(sc->sm))
	if (!sc->sa.bno_cur || xchk_skip_xref(sc->sm))
		return;

	error = xfs_alloc_has_record(sc->sa.bno_cur, agbno, len, &is_freesp);
	if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.bno_cur))
	if (!xchk_should_check_xref(sc, &error, &sc->sa.bno_cur))
		return;
	if (is_freesp)
		xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.bno_cur, 0);
		xchk_btree_xref_set_corrupt(sc, sc->sa.bno_cur, 0);
}
+53 −53
Original line number Diff line number Diff line
@@ -32,7 +32,7 @@

/* Set us up to scrub an inode's extended attributes. */
int
xfs_scrub_setup_xattr(
xchk_setup_xattr(
	struct xfs_scrub_context	*sc,
	struct xfs_inode		*ip)
{
@@ -50,12 +50,12 @@ xfs_scrub_setup_xattr(
	if (!sc->buf)
		return -ENOMEM;

	return xfs_scrub_setup_inode_contents(sc, ip, 0);
	return xchk_setup_inode_contents(sc, ip, 0);
}

/* Extended Attributes */

struct xfs_scrub_xattr {
struct xchk_xattr {
	struct xfs_attr_list_context	context;
	struct xfs_scrub_context	*sc;
};
@@ -69,22 +69,22 @@ struct xfs_scrub_xattr {
 * or if we get more or less data than we expected.
 */
static void
xfs_scrub_xattr_listent(
xchk_xattr_listent(
	struct xfs_attr_list_context	*context,
	int				flags,
	unsigned char			*name,
	int				namelen,
	int				valuelen)
{
	struct xfs_scrub_xattr		*sx;
	struct xchk_xattr		*sx;
	struct xfs_da_args		args = { NULL };
	int				error = 0;

	sx = container_of(context, struct xfs_scrub_xattr, context);
	sx = container_of(context, struct xchk_xattr, context);

	if (flags & XFS_ATTR_INCOMPLETE) {
		/* Incomplete attr key, just mark the inode for preening. */
		xfs_scrub_ino_set_preen(sx->sc, context->dp->i_ino);
		xchk_ino_set_preen(sx->sc, context->dp->i_ino);
		return;
	}

@@ -106,11 +106,11 @@ xfs_scrub_xattr_listent(
	error = xfs_attr_get_ilocked(context->dp, &args);
	if (error == -EEXIST)
		error = 0;
	if (!xfs_scrub_fblock_process_error(sx->sc, XFS_ATTR_FORK, args.blkno,
	if (!xchk_fblock_process_error(sx->sc, XFS_ATTR_FORK, args.blkno,
			&error))
		goto fail_xref;
	if (args.valuelen != valuelen)
		xfs_scrub_fblock_set_corrupt(sx->sc, XFS_ATTR_FORK,
		xchk_fblock_set_corrupt(sx->sc, XFS_ATTR_FORK,
					     args.blkno);
fail_xref:
	if (sx->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
@@ -126,7 +126,7 @@ xfs_scrub_xattr_listent(
 * the smallest address
 */
STATIC bool
xfs_scrub_xattr_set_map(
xchk_xattr_set_map(
	struct xfs_scrub_context	*sc,
	unsigned long			*map,
	unsigned int			start,
@@ -154,7 +154,7 @@ xfs_scrub_xattr_set_map(
 * attr freemap has problems or points to used space.
 */
STATIC bool
xfs_scrub_xattr_check_freemap(
xchk_xattr_check_freemap(
	struct xfs_scrub_context	*sc,
	unsigned long			*map,
	struct xfs_attr3_icleaf_hdr	*leafhdr)
@@ -168,7 +168,7 @@ xfs_scrub_xattr_check_freemap(
	freemap = (unsigned long *)sc->buf + BITS_TO_LONGS(mapsize);
	bitmap_zero(freemap, mapsize);
	for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
		if (!xfs_scrub_xattr_set_map(sc, freemap,
		if (!xchk_xattr_set_map(sc, freemap,
				leafhdr->freemap[i].base,
				leafhdr->freemap[i].size))
			return false;
@@ -184,8 +184,8 @@ xfs_scrub_xattr_check_freemap(
 * Returns the number of bytes used for the name/value data.
 */
STATIC void
xfs_scrub_xattr_entry(
	struct xfs_scrub_da_btree	*ds,
xchk_xattr_entry(
	struct xchk_da_btree		*ds,
	int				level,
	char				*buf_end,
	struct xfs_attr_leafblock	*leaf,
@@ -204,17 +204,17 @@ xfs_scrub_xattr_entry(
	unsigned int			namesize;

	if (ent->pad2 != 0)
		xfs_scrub_da_set_corrupt(ds, level);
		xchk_da_set_corrupt(ds, level);

	/* Hash values in order? */
	if (be32_to_cpu(ent->hashval) < *last_hashval)
		xfs_scrub_da_set_corrupt(ds, level);
		xchk_da_set_corrupt(ds, level);
	*last_hashval = be32_to_cpu(ent->hashval);

	nameidx = be16_to_cpu(ent->nameidx);
	if (nameidx < leafhdr->firstused ||
	    nameidx >= mp->m_attr_geo->blksize) {
		xfs_scrub_da_set_corrupt(ds, level);
		xchk_da_set_corrupt(ds, level);
		return;
	}

@@ -225,27 +225,27 @@ xfs_scrub_xattr_entry(
				be16_to_cpu(lentry->valuelen));
		name_end = (char *)lentry + namesize;
		if (lentry->namelen == 0)
			xfs_scrub_da_set_corrupt(ds, level);
			xchk_da_set_corrupt(ds, level);
	} else {
		rentry = xfs_attr3_leaf_name_remote(leaf, idx);
		namesize = xfs_attr_leaf_entsize_remote(rentry->namelen);
		name_end = (char *)rentry + namesize;
		if (rentry->namelen == 0 || rentry->valueblk == 0)
			xfs_scrub_da_set_corrupt(ds, level);
			xchk_da_set_corrupt(ds, level);
	}
	if (name_end > buf_end)
		xfs_scrub_da_set_corrupt(ds, level);
		xchk_da_set_corrupt(ds, level);

	if (!xfs_scrub_xattr_set_map(ds->sc, usedmap, nameidx, namesize))
		xfs_scrub_da_set_corrupt(ds, level);
	if (!xchk_xattr_set_map(ds->sc, usedmap, nameidx, namesize))
		xchk_da_set_corrupt(ds, level);
	if (!(ds->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
		*usedbytes += namesize;
}

/* Scrub an attribute leaf. */
STATIC int
xfs_scrub_xattr_block(
	struct xfs_scrub_da_btree	*ds,
xchk_xattr_block(
	struct xchk_da_btree		*ds,
	int				level)
{
	struct xfs_attr3_icleaf_hdr	leafhdr;
@@ -275,10 +275,10 @@ xfs_scrub_xattr_block(

		if (leaf->hdr.pad1 != 0 || leaf->hdr.pad2 != 0 ||
		    leaf->hdr.info.hdr.pad != 0)
			xfs_scrub_da_set_corrupt(ds, level);
			xchk_da_set_corrupt(ds, level);
	} else {
		if (leaf->hdr.pad1 != 0 || leaf->hdr.info.pad != 0)
			xfs_scrub_da_set_corrupt(ds, level);
			xchk_da_set_corrupt(ds, level);
	}

	/* Check the leaf header */
@@ -286,44 +286,44 @@ xfs_scrub_xattr_block(
	hdrsize = xfs_attr3_leaf_hdr_size(leaf);

	if (leafhdr.usedbytes > mp->m_attr_geo->blksize)
		xfs_scrub_da_set_corrupt(ds, level);
		xchk_da_set_corrupt(ds, level);
	if (leafhdr.firstused > mp->m_attr_geo->blksize)
		xfs_scrub_da_set_corrupt(ds, level);
		xchk_da_set_corrupt(ds, level);
	if (leafhdr.firstused < hdrsize)
		xfs_scrub_da_set_corrupt(ds, level);
	if (!xfs_scrub_xattr_set_map(ds->sc, usedmap, 0, hdrsize))
		xfs_scrub_da_set_corrupt(ds, level);
		xchk_da_set_corrupt(ds, level);
	if (!xchk_xattr_set_map(ds->sc, usedmap, 0, hdrsize))
		xchk_da_set_corrupt(ds, level);

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

	entries = xfs_attr3_leaf_entryp(leaf);
	if ((char *)&entries[leafhdr.count] > (char *)leaf + leafhdr.firstused)
		xfs_scrub_da_set_corrupt(ds, level);
		xchk_da_set_corrupt(ds, level);

	buf_end = (char *)bp->b_addr + mp->m_attr_geo->blksize;
	for (i = 0, ent = entries; i < leafhdr.count; ent++, i++) {
		/* Mark the leaf entry itself. */
		off = (char *)ent - (char *)leaf;
		if (!xfs_scrub_xattr_set_map(ds->sc, usedmap, off,
		if (!xchk_xattr_set_map(ds->sc, usedmap, off,
				sizeof(xfs_attr_leaf_entry_t))) {
			xfs_scrub_da_set_corrupt(ds, level);
			xchk_da_set_corrupt(ds, level);
			goto out;
		}

		/* Check the entry and nameval. */
		xfs_scrub_xattr_entry(ds, level, buf_end, leaf, &leafhdr,
		xchk_xattr_entry(ds, level, buf_end, leaf, &leafhdr,
				usedmap, ent, i, &usedbytes, &last_hashval);

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

	if (!xfs_scrub_xattr_check_freemap(ds->sc, usedmap, &leafhdr))
		xfs_scrub_da_set_corrupt(ds, level);
	if (!xchk_xattr_check_freemap(ds->sc, usedmap, &leafhdr))
		xchk_da_set_corrupt(ds, level);

	if (leafhdr.usedbytes != usedbytes)
		xfs_scrub_da_set_corrupt(ds, level);
		xchk_da_set_corrupt(ds, level);

out:
	return 0;
@@ -331,8 +331,8 @@ xfs_scrub_xattr_block(

/* Scrub a attribute btree record. */
STATIC int
xfs_scrub_xattr_rec(
	struct xfs_scrub_da_btree	*ds,
xchk_xattr_rec(
	struct xchk_da_btree		*ds,
	int				level,
	void				*rec)
{
@@ -352,14 +352,14 @@ xfs_scrub_xattr_rec(
	blk = &ds->state->path.blk[level];

	/* Check the whole block, if necessary. */
	error = xfs_scrub_xattr_block(ds, level);
	error = xchk_xattr_block(ds, level);
	if (error)
		goto out;
	if (ds->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
		goto out;

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

@@ -368,7 +368,7 @@ xfs_scrub_xattr_rec(
	hdrsize = xfs_attr3_leaf_hdr_size(bp->b_addr);
	nameidx = be16_to_cpu(ent->nameidx);
	if (nameidx < hdrsize || nameidx >= mp->m_attr_geo->blksize) {
		xfs_scrub_da_set_corrupt(ds, level);
		xchk_da_set_corrupt(ds, level);
		goto out;
	}

@@ -377,12 +377,12 @@ xfs_scrub_xattr_rec(
	badflags = ~(XFS_ATTR_LOCAL | XFS_ATTR_ROOT | XFS_ATTR_SECURE |
			XFS_ATTR_INCOMPLETE);
	if ((ent->flags & badflags) != 0)
		xfs_scrub_da_set_corrupt(ds, level);
		xchk_da_set_corrupt(ds, level);
	if (ent->flags & XFS_ATTR_LOCAL) {
		lentry = (struct xfs_attr_leaf_name_local *)
				(((char *)bp->b_addr) + nameidx);
		if (lentry->namelen <= 0) {
			xfs_scrub_da_set_corrupt(ds, level);
			xchk_da_set_corrupt(ds, level);
			goto out;
		}
		calc_hash = xfs_da_hashname(lentry->nameval, lentry->namelen);
@@ -390,13 +390,13 @@ xfs_scrub_xattr_rec(
		rentry = (struct xfs_attr_leaf_name_remote *)
				(((char *)bp->b_addr) + nameidx);
		if (rentry->namelen <= 0) {
			xfs_scrub_da_set_corrupt(ds, level);
			xchk_da_set_corrupt(ds, level);
			goto out;
		}
		calc_hash = xfs_da_hashname(rentry->name, rentry->namelen);
	}
	if (calc_hash != hash)
		xfs_scrub_da_set_corrupt(ds, level);
		xchk_da_set_corrupt(ds, level);

out:
	return error;
@@ -404,10 +404,10 @@ xfs_scrub_xattr_rec(

/* Scrub the extended attribute metadata. */
int
xfs_scrub_xattr(
xchk_xattr(
	struct xfs_scrub_context	*sc)
{
	struct xfs_scrub_xattr		sx;
	struct xchk_xattr		sx;
	struct attrlist_cursor_kern	cursor = { 0 };
	xfs_dablk_t			last_checked = -1U;
	int				error = 0;
@@ -417,7 +417,7 @@ xfs_scrub_xattr(

	memset(&sx, 0, sizeof(sx));
	/* Check attribute tree structure */
	error = xfs_scrub_da_btree(sc, XFS_ATTR_FORK, xfs_scrub_xattr_rec,
	error = xchk_da_btree(sc, XFS_ATTR_FORK, xchk_xattr_rec,
			&last_checked);
	if (error)
		goto out;
@@ -429,7 +429,7 @@ xfs_scrub_xattr(
	sx.context.dp = sc->ip;
	sx.context.cursor = &cursor;
	sx.context.resynch = 1;
	sx.context.put_listent = xfs_scrub_xattr_listent;
	sx.context.put_listent = xchk_xattr_listent;
	sx.context.tp = sc->tp;
	sx.context.flags = ATTR_INCOMPLETE;
	sx.sc = sc;
@@ -438,7 +438,7 @@ xfs_scrub_xattr(
	 * Look up every xattr in this file by name.
	 *
	 * Use the backend implementation of xfs_attr_list to call
	 * xfs_scrub_xattr_listent on every attribute key in this inode.
	 * xchk_xattr_listent on every attribute key in this inode.
	 * In other words, we use the same iterator/callback mechanism
	 * that listattr uses to scrub extended attributes, though in our
	 * _listent function, we check the value of the attribute.
@@ -451,7 +451,7 @@ xfs_scrub_xattr(
	 * locking order.
	 */
	error = xfs_attr_list_int_ilocked(&sx.context);
	if (!xfs_scrub_fblock_process_error(sc, XFS_ATTR_FORK, 0, &error))
	if (!xchk_fblock_process_error(sc, XFS_ATTR_FORK, 0, &error))
		goto out;
out:
	return error;
+88 −88

File changed.

Preview size limit exceeded, changes collapsed.

+83 −83

File changed.

Preview size limit exceeded, changes collapsed.

Loading