attr.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * Copyright (C) 2017-2023 Oracle.  All Rights Reserved.
  4 * Author: Darrick J. Wong <djwong@kernel.org>
  5 */
  6#include "xfs.h"
  7#include "xfs_fs.h"
  8#include "xfs_shared.h"
  9#include "xfs_format.h"
 10#include "xfs_trans_resv.h"
 11#include "xfs_mount.h"
 12#include "xfs_log_format.h"
 13#include "xfs_trans.h"
 14#include "xfs_inode.h"
 15#include "xfs_da_format.h"
 16#include "xfs_da_btree.h"
 17#include "xfs_attr.h"
 18#include "xfs_attr_leaf.h"
 19#include "xfs_attr_sf.h"
 20#include "xfs_parent.h"
 21#include "scrub/scrub.h"
 22#include "scrub/common.h"
 23#include "scrub/dabtree.h"
 24#include "scrub/attr.h"
 25#include "scrub/listxattr.h"
 26#include "scrub/repair.h"
 27
 28/* Free the buffers linked from the xattr buffer. */
 29static void
 30xchk_xattr_buf_cleanup(
 31	void			*priv)
 32{
 33	struct xchk_xattr_buf	*ab = priv;
 34
 35	kvfree(ab->freemap);
 36	ab->freemap = NULL;
 37	kvfree(ab->usedmap);
 38	ab->usedmap = NULL;
 39	kvfree(ab->value);
 40	ab->value = NULL;
 41	ab->value_sz = 0;
 42	kvfree(ab->name);
 43	ab->name = NULL;
 44}
 45
 46/*
 47 * Allocate the free space bitmap if we're trying harder; there are leaf blocks
 48 * in the attr fork; or we can't tell if there are leaf blocks.
 49 */
 50static inline bool
 51xchk_xattr_want_freemap(
 52	struct xfs_scrub	*sc)
 53{
 54	struct xfs_ifork	*ifp;
 55
 56	if (sc->flags & XCHK_TRY_HARDER)
 57		return true;
 58
 59	if (!sc->ip)
 60		return true;
 61
 62	ifp = xfs_ifork_ptr(sc->ip, XFS_ATTR_FORK);
 63	if (!ifp)
 64		return false;
 65
 66	return xfs_ifork_has_extents(ifp);
 67}
 68
 69/*
 70 * Allocate enough memory to hold an attr value and attr block bitmaps,
 71 * reallocating the buffer if necessary.  Buffer contents are not preserved
 72 * across a reallocation.
 73 */
 74int
 75xchk_setup_xattr_buf(
 76	struct xfs_scrub	*sc,
 77	size_t			value_size)
 78{
 79	size_t			bmp_sz;
 80	struct xchk_xattr_buf	*ab = sc->buf;
 81	void			*new_val;
 82
 83	bmp_sz = sizeof(long) * BITS_TO_LONGS(sc->mp->m_attr_geo->blksize);
 84
 85	if (ab)
 86		goto resize_value;
 87
 88	ab = kvzalloc(sizeof(struct xchk_xattr_buf), XCHK_GFP_FLAGS);
 89	if (!ab)
 90		return -ENOMEM;
 91	sc->buf = ab;
 92	sc->buf_cleanup = xchk_xattr_buf_cleanup;
 93
 94	ab->usedmap = kvmalloc(bmp_sz, XCHK_GFP_FLAGS);
 95	if (!ab->usedmap)
 96		return -ENOMEM;
 97
 98	if (xchk_xattr_want_freemap(sc)) {
 99		ab->freemap = kvmalloc(bmp_sz, XCHK_GFP_FLAGS);
100		if (!ab->freemap)
101			return -ENOMEM;
102	}
103
104	if (xchk_could_repair(sc)) {
105		ab->name = kvmalloc(XATTR_NAME_MAX + 1, XCHK_GFP_FLAGS);
106		if (!ab->name)
107			return -ENOMEM;
108	}
109
110resize_value:
111	if (ab->value_sz >= value_size)
112		return 0;
113
114	if (ab->value) {
115		kvfree(ab->value);
116		ab->value = NULL;
117		ab->value_sz = 0;
118	}
119
120	new_val = kvmalloc(value_size, XCHK_GFP_FLAGS);
121	if (!new_val)
122		return -ENOMEM;
123
124	ab->value = new_val;
125	ab->value_sz = value_size;
126	return 0;
127}
128
129/* Set us up to scrub an inode's extended attributes. */
130int
131xchk_setup_xattr(
132	struct xfs_scrub	*sc)
133{
134	int			error;
135
136	if (xchk_could_repair(sc)) {
137		error = xrep_setup_xattr(sc);
138		if (error)
139			return error;
140	}
141
142	/*
143	 * We failed to get memory while checking attrs, so this time try to
144	 * get all the memory we're ever going to need.  Allocate the buffer
145	 * without the inode lock held, which means we can sleep.
146	 */
147	if (sc->flags & XCHK_TRY_HARDER) {
148		error = xchk_setup_xattr_buf(sc, XATTR_SIZE_MAX);
149		if (error)
150			return error;
151	}
152
153	return xchk_setup_inode_contents(sc, 0);
154}
155
156/* Extended Attributes */
157
158/*
159 * Check that an extended attribute key can be looked up by hash.
160 *
161 * We use the extended attribute walk helper to call this function for every
162 * attribute key in an inode.  Once we're here, we load the attribute value to
163 * see if any errors happen, or if we get more or less data than we expected.
164 */
165static int
166xchk_xattr_actor(
167	struct xfs_scrub	*sc,
168	struct xfs_inode	*ip,
169	unsigned int		attr_flags,
170	const unsigned char	*name,
171	unsigned int		namelen,
172	const void		*value,
173	unsigned int		valuelen,
174	void			*priv)
175{
176	struct xfs_da_args		args = {
177		.attr_filter		= attr_flags & XFS_ATTR_NSP_ONDISK_MASK,
178		.geo			= sc->mp->m_attr_geo,
179		.whichfork		= XFS_ATTR_FORK,
180		.dp			= ip,
181		.name			= name,
182		.namelen		= namelen,
183		.trans			= sc->tp,
184		.valuelen		= valuelen,
185		.owner			= ip->i_ino,
186	};
187	struct xchk_xattr_buf		*ab;
188	int				error = 0;
189
190	ab = sc->buf;
191
192	if (xchk_should_terminate(sc, &error))
193		return error;
194
195	if (attr_flags & ~XFS_ATTR_ONDISK_MASK) {
196		xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, args.blkno);
197		return -ECANCELED;
198	}
199
200	if (attr_flags & XFS_ATTR_INCOMPLETE) {
201		/* Incomplete attr key, just mark the inode for preening. */
202		xchk_ino_set_preen(sc, ip->i_ino);
203		return 0;
204	}
205
206	/* Does this name make sense? */
207	if (!xfs_attr_namecheck(attr_flags, name, namelen)) {
208		xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, args.blkno);
209		return -ECANCELED;
210	}
211
212	/* Check parent pointer record. */
213	if ((attr_flags & XFS_ATTR_PARENT) &&
214	    !xfs_parent_valuecheck(sc->mp, value, valuelen)) {
215		xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, args.blkno);
216		return -ECANCELED;
217	}
218
219	/*
220	 * Try to allocate enough memory to extract the attr value.  If that
221	 * doesn't work, return -EDEADLOCK as a signal to try again with a
222	 * maximally sized buffer.
223	 */
224	error = xchk_setup_xattr_buf(sc, valuelen);
225	if (error == -ENOMEM)
226		error = -EDEADLOCK;
227	if (error)
228		return error;
229
230	/*
231	 * Parent pointers are matched on attr name and value, so we must
232	 * supply the xfs_parent_rec here when confirming that the dabtree
233	 * indexing works correctly.
234	 */
235	if (attr_flags & XFS_ATTR_PARENT)
236		memcpy(ab->value, value, valuelen);
237
238	args.value = ab->value;
239
240	/*
241	 * Get the attr value to ensure that lookup can find this attribute
242	 * through the dabtree indexing and that remote value retrieval also
243	 * works correctly.
244	 */
245	xfs_attr_sethash(&args);
246	error = xfs_attr_get_ilocked(&args);
247	/* ENODATA means the hash lookup failed and the attr is bad */
248	if (error == -ENODATA)
249		error = -EFSCORRUPTED;
250	if (!xchk_fblock_process_error(sc, XFS_ATTR_FORK, args.blkno,
251			&error))
252		return error;
253	if (args.valuelen != valuelen)
254		xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, args.blkno);
255
256	return 0;
257}
258
259/*
260 * Mark a range [start, start+len) in this map.  Returns true if the
261 * region was free, and false if there's a conflict or a problem.
262 *
263 * Within a char, the lowest bit of the char represents the byte with
264 * the smallest address
265 */
266bool
267xchk_xattr_set_map(
268	struct xfs_scrub	*sc,
269	unsigned long		*map,
270	unsigned int		start,
271	unsigned int		len)
272{
273	unsigned int		mapsize = sc->mp->m_attr_geo->blksize;
274	bool			ret = true;
275
276	if (start >= mapsize)
277		return false;
278	if (start + len > mapsize) {
279		len = mapsize - start;
280		ret = false;
281	}
282
283	if (find_next_bit(map, mapsize, start) < start + len)
284		ret = false;
285	bitmap_set(map, start, len);
286
287	return ret;
288}
289
290/*
291 * Check this leaf entry's relations to everything else.
292 * Returns the number of bytes used for the name/value data.
293 */
294STATIC void
295xchk_xattr_entry(
296	struct xchk_da_btree		*ds,
297	int				level,
298	char				*buf_end,
299	struct xfs_attr_leafblock	*leaf,
300	struct xfs_attr3_icleaf_hdr	*leafhdr,
301	struct xfs_attr_leaf_entry	*ent,
302	int				idx,
303	unsigned int			*usedbytes,
304	__u32				*last_hashval)
305{
306	struct xfs_mount		*mp = ds->state->mp;
307	struct xchk_xattr_buf		*ab = ds->sc->buf;
308	char				*name_end;
309	struct xfs_attr_leaf_name_local	*lentry;
310	struct xfs_attr_leaf_name_remote *rentry;
311	unsigned int			nameidx;
312	unsigned int			namesize;
313
314	if (ent->pad2 != 0)
315		xchk_da_set_corrupt(ds, level);
316
317	/* Hash values in order? */
318	if (be32_to_cpu(ent->hashval) < *last_hashval)
319		xchk_da_set_corrupt(ds, level);
320	*last_hashval = be32_to_cpu(ent->hashval);
321
322	nameidx = be16_to_cpu(ent->nameidx);
323	if (nameidx < leafhdr->firstused ||
324	    nameidx >= mp->m_attr_geo->blksize) {
325		xchk_da_set_corrupt(ds, level);
326		return;
327	}
328
329	/* Check the name information. */
330	if (ent->flags & XFS_ATTR_LOCAL) {
331		lentry = xfs_attr3_leaf_name_local(leaf, idx);
332		namesize = xfs_attr_leaf_entsize_local(lentry->namelen,
333				be16_to_cpu(lentry->valuelen));
334		name_end = (char *)lentry + namesize;
335		if (lentry->namelen == 0)
336			xchk_da_set_corrupt(ds, level);
337	} else {
338		rentry = xfs_attr3_leaf_name_remote(leaf, idx);
339		namesize = xfs_attr_leaf_entsize_remote(rentry->namelen);
340		name_end = (char *)rentry + namesize;
341		if (rentry->namelen == 0)
342			xchk_da_set_corrupt(ds, level);
343		if (rentry->valueblk == 0 &&
344		    !(ent->flags & XFS_ATTR_INCOMPLETE))
345			xchk_da_set_corrupt(ds, level);
346	}
347	if (name_end > buf_end)
348		xchk_da_set_corrupt(ds, level);
349
350	if (!xchk_xattr_set_map(ds->sc, ab->usedmap, nameidx, namesize))
351		xchk_da_set_corrupt(ds, level);
352	if (!(ds->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
353		*usedbytes += namesize;
354}
355
356/* Scrub an attribute leaf. */
357STATIC int
358xchk_xattr_block(
359	struct xchk_da_btree		*ds,
360	int				level)
361{
362	struct xfs_attr3_icleaf_hdr	leafhdr;
363	struct xfs_mount		*mp = ds->state->mp;
364	struct xfs_da_state_blk		*blk = &ds->state->path.blk[level];
365	struct xfs_buf			*bp = blk->bp;
366	xfs_dablk_t			*last_checked = ds->private;
367	struct xfs_attr_leafblock	*leaf = bp->b_addr;
368	struct xfs_attr_leaf_entry	*ent;
369	struct xfs_attr_leaf_entry	*entries;
370	struct xchk_xattr_buf		*ab = ds->sc->buf;
371	char				*buf_end;
372	size_t				off;
373	__u32				last_hashval = 0;
374	unsigned int			usedbytes = 0;
375	unsigned int			hdrsize;
376	int				i;
377
378	if (*last_checked == blk->blkno)
379		return 0;
380
381	*last_checked = blk->blkno;
382	bitmap_zero(ab->usedmap, mp->m_attr_geo->blksize);
383	bitmap_zero(ab->freemap, mp->m_attr_geo->blksize);
384
385	/* Check all the padding. */
386	if (xfs_has_crc(ds->sc->mp)) {
387		struct xfs_attr3_leafblock	*leaf3 = bp->b_addr;
388
389		if (leaf3->hdr.pad1 != 0 || leaf3->hdr.pad2 != 0 ||
390		    leaf3->hdr.info.hdr.pad != 0)
391			xchk_da_set_corrupt(ds, level);
392	} else {
393		if (leaf->hdr.pad1 != 0 || leaf->hdr.info.pad != 0)
394			xchk_da_set_corrupt(ds, level);
395	}
396
397	/* Check the leaf header */
398	xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &leafhdr, leaf);
399	hdrsize = xfs_attr3_leaf_hdr_size(leaf);
400
401	/*
402	 * Empty xattr leaf blocks mapped at block 0 are probably a byproduct
403	 * of a race between setxattr and a log shutdown.  Anywhere else in the
404	 * attr fork is a corruption.
405	 */
406	if (leafhdr.count == 0) {
407		if (blk->blkno == 0)
408			xchk_da_set_preen(ds, level);
409		else
410			xchk_da_set_corrupt(ds, level);
411	}
412	if (leafhdr.usedbytes > mp->m_attr_geo->blksize)
413		xchk_da_set_corrupt(ds, level);
414	if (leafhdr.firstused > mp->m_attr_geo->blksize)
415		xchk_da_set_corrupt(ds, level);
416	if (leafhdr.firstused < hdrsize)
417		xchk_da_set_corrupt(ds, level);
418	if (!xchk_xattr_set_map(ds->sc, ab->usedmap, 0, hdrsize))
419		xchk_da_set_corrupt(ds, level);
420	if (leafhdr.holes)
421		xchk_da_set_preen(ds, level);
422
423	if (ds->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
424		goto out;
425
426	entries = xfs_attr3_leaf_entryp(leaf);
427	if ((char *)&entries[leafhdr.count] > (char *)leaf + leafhdr.firstused)
428		xchk_da_set_corrupt(ds, level);
429
430	if (ds->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
431		goto out;
432
433	buf_end = (char *)bp->b_addr + mp->m_attr_geo->blksize;
434	for (i = 0, ent = entries; i < leafhdr.count; ent++, i++) {
435		/* Mark the leaf entry itself. */
436		off = (char *)ent - (char *)leaf;
437		if (!xchk_xattr_set_map(ds->sc, ab->usedmap, off,
438				sizeof(xfs_attr_leaf_entry_t))) {
439			xchk_da_set_corrupt(ds, level);
440			goto out;
441		}
442
443		/* Check the entry and nameval. */
444		xchk_xattr_entry(ds, level, buf_end, leaf, &leafhdr,
445				ent, i, &usedbytes, &last_hashval);
446
447		if (ds->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
448			goto out;
449	}
450
451	/* Construct bitmap of freemap contents. */
452	for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
453		if (!xchk_xattr_set_map(ds->sc, ab->freemap,
454				leafhdr.freemap[i].base,
455				leafhdr.freemap[i].size))
456			xchk_da_set_corrupt(ds, level);
457
458		/*
459		 * freemap entries with zero length and nonzero base can cause
460		 * problems with older kernels, so we mark these for preening
461		 * even though there's no inconsistency.
462		 */
463		if (leafhdr.freemap[i].size == 0 &&
464		    leafhdr.freemap[i].base > 0)
465			xchk_da_set_preen(ds, level);
466
467		if (ds->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
468			goto out;
469	}
470
471	/* Look for bits that are set in freemap and are marked in use. */
472	if (bitmap_intersects(ab->freemap, ab->usedmap,
473			mp->m_attr_geo->blksize))
474		xchk_da_set_corrupt(ds, level);
475
476	if (leafhdr.usedbytes != usedbytes)
477		xchk_da_set_corrupt(ds, level);
478
479out:
480	return 0;
481}
482
483/* Scrub a attribute btree record. */
484STATIC int
485xchk_xattr_rec(
486	struct xchk_da_btree		*ds,
487	int				level)
488{
489	struct xfs_mount		*mp = ds->state->mp;
490	struct xfs_da_state_blk		*blk = &ds->state->path.blk[level];
491	struct xfs_attr_leaf_name_local	*lentry;
492	struct xfs_attr_leaf_name_remote	*rentry;
493	struct xfs_buf			*bp;
494	struct xfs_attr_leaf_entry	*ent;
495	xfs_dahash_t			calc_hash;
496	xfs_dahash_t			hash;
497	int				nameidx;
498	int				hdrsize;
499	int				error;
500
501	ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
502
503	ent = xfs_attr3_leaf_entryp(blk->bp->b_addr) + blk->index;
504
505	/* Check the whole block, if necessary. */
506	error = xchk_xattr_block(ds, level);
507	if (error)
508		goto out;
509	if (ds->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
510		goto out;
511
512	/* Check the hash of the entry. */
513	error = xchk_da_btree_hash(ds, level, &ent->hashval);
514	if (error)
515		goto out;
516
517	/* Find the attr entry's location. */
518	bp = blk->bp;
519	hdrsize = xfs_attr3_leaf_hdr_size(bp->b_addr);
520	nameidx = be16_to_cpu(ent->nameidx);
521	if (nameidx < hdrsize || nameidx >= mp->m_attr_geo->blksize) {
522		xchk_da_set_corrupt(ds, level);
523		goto out;
524	}
525
526	/* Retrieve the entry and check it. */
527	hash = be32_to_cpu(ent->hashval);
528	if (ent->flags & ~XFS_ATTR_ONDISK_MASK) {
529		xchk_da_set_corrupt(ds, level);
530		return 0;
531	}
532	if (!xfs_attr_check_namespace(ent->flags)) {
533		xchk_da_set_corrupt(ds, level);
534		return 0;
535	}
536
537	if (ent->flags & XFS_ATTR_LOCAL) {
538		lentry = (struct xfs_attr_leaf_name_local *)
539				(((char *)bp->b_addr) + nameidx);
540		if (lentry->namelen <= 0) {
541			xchk_da_set_corrupt(ds, level);
542			goto out;
543		}
544		calc_hash = xfs_attr_hashval(mp, ent->flags, lentry->nameval,
545					     lentry->namelen,
546					     lentry->nameval + lentry->namelen,
547					     be16_to_cpu(lentry->valuelen));
548	} else {
549		rentry = (struct xfs_attr_leaf_name_remote *)
550				(((char *)bp->b_addr) + nameidx);
551		if (rentry->namelen <= 0) {
552			xchk_da_set_corrupt(ds, level);
553			goto out;
554		}
555		if (ent->flags & XFS_ATTR_PARENT) {
556			xchk_da_set_corrupt(ds, level);
557			goto out;
558		}
559		calc_hash = xfs_attr_hashval(mp, ent->flags, rentry->name,
560					     rentry->namelen, NULL,
561					     be32_to_cpu(rentry->valuelen));
562	}
563	if (calc_hash != hash)
564		xchk_da_set_corrupt(ds, level);
565
566out:
567	return error;
568}
569
570/* Check space usage of shortform attrs. */
571STATIC int
572xchk_xattr_check_sf(
573	struct xfs_scrub		*sc)
574{
575	struct xchk_xattr_buf		*ab = sc->buf;
576	struct xfs_ifork		*ifp = &sc->ip->i_af;
577	struct xfs_attr_sf_hdr		*sf = ifp->if_data;
578	struct xfs_attr_sf_entry	*sfe = xfs_attr_sf_firstentry(sf);
579	struct xfs_attr_sf_entry	*next;
580	unsigned char			*end = ifp->if_data + ifp->if_bytes;
581	int				i;
582	int				error = 0;
583
584	bitmap_zero(ab->usedmap, ifp->if_bytes);
585	xchk_xattr_set_map(sc, ab->usedmap, 0, sizeof(*sf));
586
587	if ((unsigned char *)sfe > end) {
588		xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, 0);
589		return 0;
590	}
591
592	for (i = 0; i < sf->count; i++) {
593		unsigned char		*name = sfe->nameval;
594		unsigned char		*value = &sfe->nameval[sfe->namelen];
595
596		if (xchk_should_terminate(sc, &error))
597			return error;
598
599		next = xfs_attr_sf_nextentry(sfe);
600		if ((unsigned char *)next > end) {
601			xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, 0);
602			break;
603		}
604
605		/*
606		 * Shortform entries do not set LOCAL or INCOMPLETE, so the
607		 * only valid flag bits here are for namespaces.
608		 */
609		if (sfe->flags & ~XFS_ATTR_NSP_ONDISK_MASK) {
610			xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, 0);
611			break;
612		}
613
614		if (!xchk_xattr_set_map(sc, ab->usedmap,
615				(char *)sfe - (char *)sf,
616				sizeof(struct xfs_attr_sf_entry))) {
617			xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, 0);
618			break;
619		}
620
621		if (!xchk_xattr_set_map(sc, ab->usedmap,
622				(char *)name - (char *)sf,
623				sfe->namelen)) {
624			xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, 0);
625			break;
626		}
627
628		if (!xchk_xattr_set_map(sc, ab->usedmap,
629				(char *)value - (char *)sf,
630				sfe->valuelen)) {
631			xchk_fblock_set_corrupt(sc, XFS_ATTR_FORK, 0);
632			break;
633		}
634
635		sfe = next;
636	}
637
638	return 0;
639}
640
641/* Scrub the extended attribute metadata. */
642int
643xchk_xattr(
644	struct xfs_scrub		*sc)
645{
646	xfs_dablk_t			last_checked = -1U;
647	int				error = 0;
648
649	if (!xfs_inode_hasattr(sc->ip))
650		return -ENOENT;
651
652	/* Allocate memory for xattr checking. */
653	error = xchk_setup_xattr_buf(sc, 0);
654	if (error == -ENOMEM)
655		return -EDEADLOCK;
656	if (error)
657		return error;
658
659	/* Check the physical structure of the xattr. */
660	if (sc->ip->i_af.if_format == XFS_DINODE_FMT_LOCAL)
661		error = xchk_xattr_check_sf(sc);
662	else
663		error = xchk_da_btree(sc, XFS_ATTR_FORK, xchk_xattr_rec,
664				&last_checked);
665	if (error)
666		return error;
667
668	if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
669		return 0;
670
671	/*
672	 * Look up every xattr in this file by name and hash.
673	 *
674	 * The VFS only locks i_rwsem when modifying attrs, so keep all
675	 * three locks held because that's the only way to ensure we're
676	 * the only thread poking into the da btree.  We traverse the da
677	 * btree while holding a leaf buffer locked for the xattr name
678	 * iteration, which doesn't really follow the usual buffer
679	 * locking order.
680	 */
681	error = xchk_xattr_walk(sc, sc->ip, xchk_xattr_actor, NULL, NULL);
682	if (!xchk_fblock_process_error(sc, XFS_ATTR_FORK, 0, &error))
683		return error;
684
685	return 0;
686}