xref: /openbmc/linux/fs/xfs/libxfs/xfs_attr.c (revision d9f6e12f)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
4  * All Rights Reserved.
5  */
6 #include "xfs.h"
7 #include "xfs_fs.h"
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.h"
12 #include "xfs_mount.h"
13 #include "xfs_defer.h"
14 #include "xfs_da_format.h"
15 #include "xfs_da_btree.h"
16 #include "xfs_attr_sf.h"
17 #include "xfs_inode.h"
18 #include "xfs_trans.h"
19 #include "xfs_bmap.h"
20 #include "xfs_bmap_btree.h"
21 #include "xfs_attr.h"
22 #include "xfs_attr_leaf.h"
23 #include "xfs_attr_remote.h"
24 #include "xfs_quota.h"
25 #include "xfs_trans_space.h"
26 #include "xfs_trace.h"
27 
28 /*
29  * xfs_attr.c
30  *
31  * Provide the external interfaces to manage attribute lists.
32  */
33 
34 /*========================================================================
35  * Function prototypes for the kernel.
36  *========================================================================*/
37 
38 /*
39  * Internal routines when attribute list fits inside the inode.
40  */
41 STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
42 
43 /*
44  * Internal routines when attribute list is one block.
45  */
46 STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
47 STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
48 STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
49 STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);
50 
51 /*
52  * Internal routines when attribute list is more than one block.
53  */
54 STATIC int xfs_attr_node_get(xfs_da_args_t *args);
55 STATIC int xfs_attr_node_addname(xfs_da_args_t *args);
56 STATIC int xfs_attr_node_removename(xfs_da_args_t *args);
57 STATIC int xfs_attr_node_hasname(xfs_da_args_t *args,
58 				 struct xfs_da_state **state);
59 STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
60 STATIC int xfs_attr_refillstate(xfs_da_state_t *state);
61 
62 int
63 xfs_inode_hasattr(
64 	struct xfs_inode	*ip)
65 {
66 	if (!XFS_IFORK_Q(ip) ||
67 	    (ip->i_afp->if_format == XFS_DINODE_FMT_EXTENTS &&
68 	     ip->i_afp->if_nextents == 0))
69 		return 0;
70 	return 1;
71 }
72 
73 /*========================================================================
74  * Overall external interface routines.
75  *========================================================================*/
76 
77 /*
78  * Retrieve an extended attribute and its value.  Must have ilock.
79  * Returns 0 on successful retrieval, otherwise an error.
80  */
81 int
82 xfs_attr_get_ilocked(
83 	struct xfs_da_args	*args)
84 {
85 	ASSERT(xfs_isilocked(args->dp, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL));
86 
87 	if (!xfs_inode_hasattr(args->dp))
88 		return -ENOATTR;
89 
90 	if (args->dp->i_afp->if_format == XFS_DINODE_FMT_LOCAL)
91 		return xfs_attr_shortform_getvalue(args);
92 	if (xfs_bmap_one_block(args->dp, XFS_ATTR_FORK))
93 		return xfs_attr_leaf_get(args);
94 	return xfs_attr_node_get(args);
95 }
96 
97 /*
98  * Retrieve an extended attribute by name, and its value if requested.
99  *
100  * If args->valuelen is zero, then the caller does not want the value, just an
101  * indication whether the attribute exists and the size of the value if it
102  * exists. The size is returned in args.valuelen.
103  *
104  * If args->value is NULL but args->valuelen is non-zero, allocate the buffer
105  * for the value after existence of the attribute has been determined. The
106  * caller always has to free args->value if it is set, no matter if this
107  * function was successful or not.
108  *
109  * If the attribute is found, but exceeds the size limit set by the caller in
110  * args->valuelen, return -ERANGE with the size of the attribute that was found
111  * in args->valuelen.
112  */
113 int
114 xfs_attr_get(
115 	struct xfs_da_args	*args)
116 {
117 	uint			lock_mode;
118 	int			error;
119 
120 	XFS_STATS_INC(args->dp->i_mount, xs_attr_get);
121 
122 	if (XFS_FORCED_SHUTDOWN(args->dp->i_mount))
123 		return -EIO;
124 
125 	args->geo = args->dp->i_mount->m_attr_geo;
126 	args->whichfork = XFS_ATTR_FORK;
127 	args->hashval = xfs_da_hashname(args->name, args->namelen);
128 
129 	/* Entirely possible to look up a name which doesn't exist */
130 	args->op_flags = XFS_DA_OP_OKNOENT;
131 
132 	lock_mode = xfs_ilock_attr_map_shared(args->dp);
133 	error = xfs_attr_get_ilocked(args);
134 	xfs_iunlock(args->dp, lock_mode);
135 
136 	return error;
137 }
138 
139 /*
140  * Calculate how many blocks we need for the new attribute,
141  */
142 STATIC int
143 xfs_attr_calc_size(
144 	struct xfs_da_args	*args,
145 	int			*local)
146 {
147 	struct xfs_mount	*mp = args->dp->i_mount;
148 	int			size;
149 	int			nblks;
150 
151 	/*
152 	 * Determine space new attribute will use, and if it would be
153 	 * "local" or "remote" (note: local != inline).
154 	 */
155 	size = xfs_attr_leaf_newentsize(args, local);
156 	nblks = XFS_DAENTER_SPACE_RES(mp, XFS_ATTR_FORK);
157 	if (*local) {
158 		if (size > (args->geo->blksize / 2)) {
159 			/* Double split possible */
160 			nblks *= 2;
161 		}
162 	} else {
163 		/*
164 		 * Out of line attribute, cannot double split, but
165 		 * make room for the attribute value itself.
166 		 */
167 		uint	dblocks = xfs_attr3_rmt_blocks(mp, args->valuelen);
168 		nblks += dblocks;
169 		nblks += XFS_NEXTENTADD_SPACE_RES(mp, dblocks, XFS_ATTR_FORK);
170 	}
171 
172 	return nblks;
173 }
174 
175 STATIC int
176 xfs_attr_try_sf_addname(
177 	struct xfs_inode	*dp,
178 	struct xfs_da_args	*args)
179 {
180 
181 	int			error;
182 
183 	/*
184 	 * Build initial attribute list (if required).
185 	 */
186 	if (dp->i_afp->if_format == XFS_DINODE_FMT_EXTENTS)
187 		xfs_attr_shortform_create(args);
188 
189 	error = xfs_attr_shortform_addname(args);
190 	if (error == -ENOSPC)
191 		return error;
192 
193 	/*
194 	 * Commit the shortform mods, and we're done.
195 	 * NOTE: this is also the error path (EEXIST, etc).
196 	 */
197 	if (!error && !(args->op_flags & XFS_DA_OP_NOTIME))
198 		xfs_trans_ichgtime(args->trans, dp, XFS_ICHGTIME_CHG);
199 
200 	if (dp->i_mount->m_flags & XFS_MOUNT_WSYNC)
201 		xfs_trans_set_sync(args->trans);
202 
203 	return error;
204 }
205 
206 /*
207  * Check to see if the attr should be upgraded from non-existent or shortform to
208  * single-leaf-block attribute list.
209  */
210 static inline bool
211 xfs_attr_is_shortform(
212 	struct xfs_inode    *ip)
213 {
214 	return ip->i_afp->if_format == XFS_DINODE_FMT_LOCAL ||
215 	       (ip->i_afp->if_format == XFS_DINODE_FMT_EXTENTS &&
216 		ip->i_afp->if_nextents == 0);
217 }
218 
219 /*
220  * Attempts to set an attr in shortform, or converts short form to leaf form if
221  * there is not enough room.  If the attr is set, the transaction is committed
222  * and set to NULL.
223  */
224 STATIC int
225 xfs_attr_set_shortform(
226 	struct xfs_da_args	*args,
227 	struct xfs_buf		**leaf_bp)
228 {
229 	struct xfs_inode	*dp = args->dp;
230 	int			error, error2 = 0;
231 
232 	/*
233 	 * Try to add the attr to the attribute list in the inode.
234 	 */
235 	error = xfs_attr_try_sf_addname(dp, args);
236 	if (error != -ENOSPC) {
237 		error2 = xfs_trans_commit(args->trans);
238 		args->trans = NULL;
239 		return error ? error : error2;
240 	}
241 	/*
242 	 * It won't fit in the shortform, transform to a leaf block.  GROT:
243 	 * another possible req'mt for a double-split btree op.
244 	 */
245 	error = xfs_attr_shortform_to_leaf(args, leaf_bp);
246 	if (error)
247 		return error;
248 
249 	/*
250 	 * Prevent the leaf buffer from being unlocked so that a concurrent AIL
251 	 * push cannot grab the half-baked leaf buffer and run into problems
252 	 * with the write verifier. Once we're done rolling the transaction we
253 	 * can release the hold and add the attr to the leaf.
254 	 */
255 	xfs_trans_bhold(args->trans, *leaf_bp);
256 	error = xfs_defer_finish(&args->trans);
257 	xfs_trans_bhold_release(args->trans, *leaf_bp);
258 	if (error) {
259 		xfs_trans_brelse(args->trans, *leaf_bp);
260 		return error;
261 	}
262 
263 	return 0;
264 }
265 
266 /*
267  * Set the attribute specified in @args.
268  */
269 int
270 xfs_attr_set_args(
271 	struct xfs_da_args	*args)
272 {
273 	struct xfs_inode	*dp = args->dp;
274 	struct xfs_buf          *leaf_bp = NULL;
275 	int			error = 0;
276 
277 	/*
278 	 * If the attribute list is already in leaf format, jump straight to
279 	 * leaf handling.  Otherwise, try to add the attribute to the shortform
280 	 * list; if there's no room then convert the list to leaf format and try
281 	 * again.
282 	 */
283 	if (xfs_attr_is_shortform(dp)) {
284 
285 		/*
286 		 * If the attr was successfully set in shortform, the
287 		 * transaction is committed and set to NULL.  Otherwise, is it
288 		 * converted from shortform to leaf, and the transaction is
289 		 * retained.
290 		 */
291 		error = xfs_attr_set_shortform(args, &leaf_bp);
292 		if (error || !args->trans)
293 			return error;
294 	}
295 
296 	if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
297 		error = xfs_attr_leaf_addname(args);
298 		if (error != -ENOSPC)
299 			return error;
300 
301 		/*
302 		 * Promote the attribute list to the Btree format.
303 		 */
304 		error = xfs_attr3_leaf_to_node(args);
305 		if (error)
306 			return error;
307 
308 		/*
309 		 * Finish any deferred work items and roll the transaction once
310 		 * more.  The goal here is to call node_addname with the inode
311 		 * and transaction in the same state (inode locked and joined,
312 		 * transaction clean) no matter how we got to this step.
313 		 */
314 		error = xfs_defer_finish(&args->trans);
315 		if (error)
316 			return error;
317 
318 		/*
319 		 * Commit the current trans (including the inode) and
320 		 * start a new one.
321 		 */
322 		error = xfs_trans_roll_inode(&args->trans, dp);
323 		if (error)
324 			return error;
325 	}
326 
327 	error = xfs_attr_node_addname(args);
328 	return error;
329 }
330 
331 /*
332  * Return EEXIST if attr is found, or ENOATTR if not
333  */
334 int
335 xfs_has_attr(
336 	struct xfs_da_args	*args)
337 {
338 	struct xfs_inode	*dp = args->dp;
339 	struct xfs_buf		*bp = NULL;
340 	int			error;
341 
342 	if (!xfs_inode_hasattr(dp))
343 		return -ENOATTR;
344 
345 	if (dp->i_afp->if_format == XFS_DINODE_FMT_LOCAL) {
346 		ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
347 		return xfs_attr_sf_findname(args, NULL, NULL);
348 	}
349 
350 	if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
351 		error = xfs_attr_leaf_hasname(args, &bp);
352 
353 		if (bp)
354 			xfs_trans_brelse(args->trans, bp);
355 
356 		return error;
357 	}
358 
359 	return xfs_attr_node_hasname(args, NULL);
360 }
361 
362 /*
363  * Remove the attribute specified in @args.
364  */
365 int
366 xfs_attr_remove_args(
367 	struct xfs_da_args      *args)
368 {
369 	struct xfs_inode	*dp = args->dp;
370 	int			error;
371 
372 	if (!xfs_inode_hasattr(dp)) {
373 		error = -ENOATTR;
374 	} else if (dp->i_afp->if_format == XFS_DINODE_FMT_LOCAL) {
375 		ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
376 		error = xfs_attr_shortform_remove(args);
377 	} else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
378 		error = xfs_attr_leaf_removename(args);
379 	} else {
380 		error = xfs_attr_node_removename(args);
381 	}
382 
383 	return error;
384 }
385 
386 /*
387  * Note: If args->value is NULL the attribute will be removed, just like the
388  * Linux ->setattr API.
389  */
390 int
391 xfs_attr_set(
392 	struct xfs_da_args	*args)
393 {
394 	struct xfs_inode	*dp = args->dp;
395 	struct xfs_mount	*mp = dp->i_mount;
396 	struct xfs_trans_res	tres;
397 	bool			rsvd = (args->attr_filter & XFS_ATTR_ROOT);
398 	int			error, local;
399 	int			rmt_blks = 0;
400 	unsigned int		total;
401 
402 	if (XFS_FORCED_SHUTDOWN(dp->i_mount))
403 		return -EIO;
404 
405 	error = xfs_qm_dqattach(dp);
406 	if (error)
407 		return error;
408 
409 	args->geo = mp->m_attr_geo;
410 	args->whichfork = XFS_ATTR_FORK;
411 	args->hashval = xfs_da_hashname(args->name, args->namelen);
412 
413 	/*
414 	 * We have no control over the attribute names that userspace passes us
415 	 * to remove, so we have to allow the name lookup prior to attribute
416 	 * removal to fail as well.
417 	 */
418 	args->op_flags = XFS_DA_OP_OKNOENT;
419 
420 	if (args->value) {
421 		XFS_STATS_INC(mp, xs_attr_set);
422 
423 		args->op_flags |= XFS_DA_OP_ADDNAME;
424 		args->total = xfs_attr_calc_size(args, &local);
425 
426 		/*
427 		 * If the inode doesn't have an attribute fork, add one.
428 		 * (inode must not be locked when we call this routine)
429 		 */
430 		if (XFS_IFORK_Q(dp) == 0) {
431 			int sf_size = sizeof(struct xfs_attr_sf_hdr) +
432 				xfs_attr_sf_entsize_byname(args->namelen,
433 						args->valuelen);
434 
435 			error = xfs_bmap_add_attrfork(dp, sf_size, rsvd);
436 			if (error)
437 				return error;
438 		}
439 
440 		tres.tr_logres = M_RES(mp)->tr_attrsetm.tr_logres +
441 				 M_RES(mp)->tr_attrsetrt.tr_logres *
442 					args->total;
443 		tres.tr_logcount = XFS_ATTRSET_LOG_COUNT;
444 		tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
445 		total = args->total;
446 
447 		if (!local)
448 			rmt_blks = xfs_attr3_rmt_blocks(mp, args->valuelen);
449 	} else {
450 		XFS_STATS_INC(mp, xs_attr_remove);
451 
452 		tres = M_RES(mp)->tr_attrrm;
453 		total = XFS_ATTRRM_SPACE_RES(mp);
454 		rmt_blks = xfs_attr3_rmt_blocks(mp, XFS_XATTR_SIZE_MAX);
455 	}
456 
457 	/*
458 	 * Root fork attributes can use reserved data blocks for this
459 	 * operation if necessary
460 	 */
461 	error = xfs_trans_alloc_inode(dp, &tres, total, 0, rsvd, &args->trans);
462 	if (error)
463 		return error;
464 
465 	if (args->value || xfs_inode_hasattr(dp)) {
466 		error = xfs_iext_count_may_overflow(dp, XFS_ATTR_FORK,
467 				XFS_IEXT_ATTR_MANIP_CNT(rmt_blks));
468 		if (error)
469 			goto out_trans_cancel;
470 	}
471 
472 	if (args->value) {
473 		error = xfs_has_attr(args);
474 		if (error == -EEXIST && (args->attr_flags & XATTR_CREATE))
475 			goto out_trans_cancel;
476 		if (error == -ENOATTR && (args->attr_flags & XATTR_REPLACE))
477 			goto out_trans_cancel;
478 		if (error != -ENOATTR && error != -EEXIST)
479 			goto out_trans_cancel;
480 
481 		error = xfs_attr_set_args(args);
482 		if (error)
483 			goto out_trans_cancel;
484 		/* shortform attribute has already been committed */
485 		if (!args->trans)
486 			goto out_unlock;
487 	} else {
488 		error = xfs_has_attr(args);
489 		if (error != -EEXIST)
490 			goto out_trans_cancel;
491 
492 		error = xfs_attr_remove_args(args);
493 		if (error)
494 			goto out_trans_cancel;
495 	}
496 
497 	/*
498 	 * If this is a synchronous mount, make sure that the
499 	 * transaction goes to disk before returning to the user.
500 	 */
501 	if (mp->m_flags & XFS_MOUNT_WSYNC)
502 		xfs_trans_set_sync(args->trans);
503 
504 	if (!(args->op_flags & XFS_DA_OP_NOTIME))
505 		xfs_trans_ichgtime(args->trans, dp, XFS_ICHGTIME_CHG);
506 
507 	/*
508 	 * Commit the last in the sequence of transactions.
509 	 */
510 	xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE);
511 	error = xfs_trans_commit(args->trans);
512 out_unlock:
513 	xfs_iunlock(dp, XFS_ILOCK_EXCL);
514 	return error;
515 
516 out_trans_cancel:
517 	if (args->trans)
518 		xfs_trans_cancel(args->trans);
519 	goto out_unlock;
520 }
521 
522 /*========================================================================
523  * External routines when attribute list is inside the inode
524  *========================================================================*/
525 
526 static inline int xfs_attr_sf_totsize(struct xfs_inode *dp)
527 {
528 	struct xfs_attr_shortform *sf;
529 
530 	sf = (struct xfs_attr_shortform *)dp->i_afp->if_u1.if_data;
531 	return be16_to_cpu(sf->hdr.totsize);
532 }
533 
534 /*
535  * Add a name to the shortform attribute list structure
536  * This is the external routine.
537  */
538 STATIC int
539 xfs_attr_shortform_addname(xfs_da_args_t *args)
540 {
541 	int newsize, forkoff, retval;
542 
543 	trace_xfs_attr_sf_addname(args);
544 
545 	retval = xfs_attr_shortform_lookup(args);
546 	if (retval == -ENOATTR && (args->attr_flags & XATTR_REPLACE))
547 		return retval;
548 	if (retval == -EEXIST) {
549 		if (args->attr_flags & XATTR_CREATE)
550 			return retval;
551 		retval = xfs_attr_shortform_remove(args);
552 		if (retval)
553 			return retval;
554 		/*
555 		 * Since we have removed the old attr, clear ATTR_REPLACE so
556 		 * that the leaf format add routine won't trip over the attr
557 		 * not being around.
558 		 */
559 		args->attr_flags &= ~XATTR_REPLACE;
560 	}
561 
562 	if (args->namelen >= XFS_ATTR_SF_ENTSIZE_MAX ||
563 	    args->valuelen >= XFS_ATTR_SF_ENTSIZE_MAX)
564 		return -ENOSPC;
565 
566 	newsize = xfs_attr_sf_totsize(args->dp);
567 	newsize += xfs_attr_sf_entsize_byname(args->namelen, args->valuelen);
568 
569 	forkoff = xfs_attr_shortform_bytesfit(args->dp, newsize);
570 	if (!forkoff)
571 		return -ENOSPC;
572 
573 	xfs_attr_shortform_add(args, forkoff);
574 	return 0;
575 }
576 
577 
578 /*========================================================================
579  * External routines when attribute list is one block
580  *========================================================================*/
581 
582 /* Store info about a remote block */
583 STATIC void
584 xfs_attr_save_rmt_blk(
585 	struct xfs_da_args	*args)
586 {
587 	args->blkno2 = args->blkno;
588 	args->index2 = args->index;
589 	args->rmtblkno2 = args->rmtblkno;
590 	args->rmtblkcnt2 = args->rmtblkcnt;
591 	args->rmtvaluelen2 = args->rmtvaluelen;
592 }
593 
594 /* Set stored info about a remote block */
595 STATIC void
596 xfs_attr_restore_rmt_blk(
597 	struct xfs_da_args	*args)
598 {
599 	args->blkno = args->blkno2;
600 	args->index = args->index2;
601 	args->rmtblkno = args->rmtblkno2;
602 	args->rmtblkcnt = args->rmtblkcnt2;
603 	args->rmtvaluelen = args->rmtvaluelen2;
604 }
605 
606 /*
607  * Tries to add an attribute to an inode in leaf form
608  *
609  * This function is meant to execute as part of a delayed operation and leaves
610  * the transaction handling to the caller.  On success the attribute is added
611  * and the inode and transaction are left dirty.  If there is not enough space,
612  * the attr data is converted to node format and -ENOSPC is returned. Caller is
613  * responsible for handling the dirty inode and transaction or adding the attr
614  * in node format.
615  */
616 STATIC int
617 xfs_attr_leaf_try_add(
618 	struct xfs_da_args	*args,
619 	struct xfs_buf		*bp)
620 {
621 	int			retval;
622 
623 	/*
624 	 * Look up the given attribute in the leaf block.  Figure out if
625 	 * the given flags produce an error or call for an atomic rename.
626 	 */
627 	retval = xfs_attr_leaf_hasname(args, &bp);
628 	if (retval != -ENOATTR && retval != -EEXIST)
629 		return retval;
630 	if (retval == -ENOATTR && (args->attr_flags & XATTR_REPLACE))
631 		goto out_brelse;
632 	if (retval == -EEXIST) {
633 		if (args->attr_flags & XATTR_CREATE)
634 			goto out_brelse;
635 
636 		trace_xfs_attr_leaf_replace(args);
637 
638 		/* save the attribute state for later removal*/
639 		args->op_flags |= XFS_DA_OP_RENAME;	/* an atomic rename */
640 		xfs_attr_save_rmt_blk(args);
641 
642 		/*
643 		 * clear the remote attr state now that it is saved so that the
644 		 * values reflect the state of the attribute we are about to
645 		 * add, not the attribute we just found and will remove later.
646 		 */
647 		args->rmtblkno = 0;
648 		args->rmtblkcnt = 0;
649 		args->rmtvaluelen = 0;
650 	}
651 
652 	/*
653 	 * Add the attribute to the leaf block
654 	 */
655 	return xfs_attr3_leaf_add(bp, args);
656 
657 out_brelse:
658 	xfs_trans_brelse(args->trans, bp);
659 	return retval;
660 }
661 
662 
663 /*
664  * Add a name to the leaf attribute list structure
665  *
666  * This leaf block cannot have a "remote" value, we only call this routine
667  * if bmap_one_block() says there is only one block (ie: no remote blks).
668  */
669 STATIC int
670 xfs_attr_leaf_addname(
671 	struct xfs_da_args	*args)
672 {
673 	int			error, forkoff;
674 	struct xfs_buf		*bp = NULL;
675 	struct xfs_inode	*dp = args->dp;
676 
677 	trace_xfs_attr_leaf_addname(args);
678 
679 	error = xfs_attr_leaf_try_add(args, bp);
680 	if (error)
681 		return error;
682 
683 	/*
684 	 * Commit the transaction that added the attr name so that
685 	 * later routines can manage their own transactions.
686 	 */
687 	error = xfs_trans_roll_inode(&args->trans, dp);
688 	if (error)
689 		return error;
690 
691 	/*
692 	 * If there was an out-of-line value, allocate the blocks we
693 	 * identified for its storage and copy the value.  This is done
694 	 * after we create the attribute so that we don't overflow the
695 	 * maximum size of a transaction and/or hit a deadlock.
696 	 */
697 	if (args->rmtblkno > 0) {
698 		error = xfs_attr_rmtval_set(args);
699 		if (error)
700 			return error;
701 	}
702 
703 	if (!(args->op_flags & XFS_DA_OP_RENAME)) {
704 		/*
705 		 * Added a "remote" value, just clear the incomplete flag.
706 		 */
707 		if (args->rmtblkno > 0)
708 			error = xfs_attr3_leaf_clearflag(args);
709 
710 		return error;
711 	}
712 
713 	/*
714 	 * If this is an atomic rename operation, we must "flip" the incomplete
715 	 * flags on the "new" and "old" attribute/value pairs so that one
716 	 * disappears and one appears atomically.  Then we must remove the "old"
717 	 * attribute/value pair.
718 	 *
719 	 * In a separate transaction, set the incomplete flag on the "old" attr
720 	 * and clear the incomplete flag on the "new" attr.
721 	 */
722 
723 	error = xfs_attr3_leaf_flipflags(args);
724 	if (error)
725 		return error;
726 	/*
727 	 * Commit the flag value change and start the next trans in series.
728 	 */
729 	error = xfs_trans_roll_inode(&args->trans, args->dp);
730 	if (error)
731 		return error;
732 
733 	/*
734 	 * Dismantle the "old" attribute/value pair by removing a "remote" value
735 	 * (if it exists).
736 	 */
737 	xfs_attr_restore_rmt_blk(args);
738 
739 	if (args->rmtblkno) {
740 		error = xfs_attr_rmtval_invalidate(args);
741 		if (error)
742 			return error;
743 
744 		error = xfs_attr_rmtval_remove(args);
745 		if (error)
746 			return error;
747 	}
748 
749 	/*
750 	 * Read in the block containing the "old" attr, then remove the "old"
751 	 * attr from that block (neat, huh!)
752 	 */
753 	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno,
754 				   &bp);
755 	if (error)
756 		return error;
757 
758 	xfs_attr3_leaf_remove(bp, args);
759 
760 	/*
761 	 * If the result is small enough, shrink it all into the inode.
762 	 */
763 	forkoff = xfs_attr_shortform_allfit(bp, dp);
764 	if (forkoff)
765 		error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
766 		/* bp is gone due to xfs_da_shrink_inode */
767 
768 	return error;
769 }
770 
771 /*
772  * Return EEXIST if attr is found, or ENOATTR if not
773  */
774 STATIC int
775 xfs_attr_leaf_hasname(
776 	struct xfs_da_args	*args,
777 	struct xfs_buf		**bp)
778 {
779 	int                     error = 0;
780 
781 	error = xfs_attr3_leaf_read(args->trans, args->dp, 0, bp);
782 	if (error)
783 		return error;
784 
785 	error = xfs_attr3_leaf_lookup_int(*bp, args);
786 	if (error != -ENOATTR && error != -EEXIST)
787 		xfs_trans_brelse(args->trans, *bp);
788 
789 	return error;
790 }
791 
792 /*
793  * Remove a name from the leaf attribute list structure
794  *
795  * This leaf block cannot have a "remote" value, we only call this routine
796  * if bmap_one_block() says there is only one block (ie: no remote blks).
797  */
798 STATIC int
799 xfs_attr_leaf_removename(
800 	struct xfs_da_args	*args)
801 {
802 	struct xfs_inode	*dp;
803 	struct xfs_buf		*bp;
804 	int			error, forkoff;
805 
806 	trace_xfs_attr_leaf_removename(args);
807 
808 	/*
809 	 * Remove the attribute.
810 	 */
811 	dp = args->dp;
812 
813 	error = xfs_attr_leaf_hasname(args, &bp);
814 
815 	if (error == -ENOATTR) {
816 		xfs_trans_brelse(args->trans, bp);
817 		return error;
818 	} else if (error != -EEXIST)
819 		return error;
820 
821 	xfs_attr3_leaf_remove(bp, args);
822 
823 	/*
824 	 * If the result is small enough, shrink it all into the inode.
825 	 */
826 	forkoff = xfs_attr_shortform_allfit(bp, dp);
827 	if (forkoff)
828 		return xfs_attr3_leaf_to_shortform(bp, args, forkoff);
829 		/* bp is gone due to xfs_da_shrink_inode */
830 
831 	return 0;
832 }
833 
834 /*
835  * Look up a name in a leaf attribute list structure.
836  *
837  * This leaf block cannot have a "remote" value, we only call this routine
838  * if bmap_one_block() says there is only one block (ie: no remote blks).
839  *
840  * Returns 0 on successful retrieval, otherwise an error.
841  */
842 STATIC int
843 xfs_attr_leaf_get(xfs_da_args_t *args)
844 {
845 	struct xfs_buf *bp;
846 	int error;
847 
848 	trace_xfs_attr_leaf_get(args);
849 
850 	error = xfs_attr_leaf_hasname(args, &bp);
851 
852 	if (error == -ENOATTR)  {
853 		xfs_trans_brelse(args->trans, bp);
854 		return error;
855 	} else if (error != -EEXIST)
856 		return error;
857 
858 
859 	error = xfs_attr3_leaf_getvalue(bp, args);
860 	xfs_trans_brelse(args->trans, bp);
861 	return error;
862 }
863 
864 /*
865  * Return EEXIST if attr is found, or ENOATTR if not
866  * statep: If not null is set to point at the found state.  Caller will
867  *         be responsible for freeing the state in this case.
868  */
869 STATIC int
870 xfs_attr_node_hasname(
871 	struct xfs_da_args	*args,
872 	struct xfs_da_state	**statep)
873 {
874 	struct xfs_da_state	*state;
875 	int			retval, error;
876 
877 	state = xfs_da_state_alloc(args);
878 	if (statep != NULL)
879 		*statep = NULL;
880 
881 	/*
882 	 * Search to see if name exists, and get back a pointer to it.
883 	 */
884 	error = xfs_da3_node_lookup_int(state, &retval);
885 	if (error) {
886 		xfs_da_state_free(state);
887 		return error;
888 	}
889 
890 	if (statep != NULL)
891 		*statep = state;
892 	else
893 		xfs_da_state_free(state);
894 	return retval;
895 }
896 
897 /*========================================================================
898  * External routines when attribute list size > geo->blksize
899  *========================================================================*/
900 
901 /*
902  * Add a name to a Btree-format attribute list.
903  *
904  * This will involve walking down the Btree, and may involve splitting
905  * leaf nodes and even splitting intermediate nodes up to and including
906  * the root node (a special case of an intermediate node).
907  *
908  * "Remote" attribute values confuse the issue and atomic rename operations
909  * add a whole extra layer of confusion on top of that.
910  */
911 STATIC int
912 xfs_attr_node_addname(
913 	struct xfs_da_args	*args)
914 {
915 	struct xfs_da_state	*state;
916 	struct xfs_da_state_blk	*blk;
917 	struct xfs_inode	*dp;
918 	int			retval, error;
919 
920 	trace_xfs_attr_node_addname(args);
921 
922 	/*
923 	 * Fill in bucket of arguments/results/context to carry around.
924 	 */
925 	dp = args->dp;
926 restart:
927 	/*
928 	 * Search to see if name already exists, and get back a pointer
929 	 * to where it should go.
930 	 */
931 	retval = xfs_attr_node_hasname(args, &state);
932 	if (retval != -ENOATTR && retval != -EEXIST)
933 		goto out;
934 
935 	blk = &state->path.blk[ state->path.active-1 ];
936 	ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
937 	if (retval == -ENOATTR && (args->attr_flags & XATTR_REPLACE))
938 		goto out;
939 	if (retval == -EEXIST) {
940 		if (args->attr_flags & XATTR_CREATE)
941 			goto out;
942 
943 		trace_xfs_attr_node_replace(args);
944 
945 		/* save the attribute state for later removal*/
946 		args->op_flags |= XFS_DA_OP_RENAME;	/* atomic rename op */
947 		xfs_attr_save_rmt_blk(args);
948 
949 		/*
950 		 * clear the remote attr state now that it is saved so that the
951 		 * values reflect the state of the attribute we are about to
952 		 * add, not the attribute we just found and will remove later.
953 		 */
954 		args->rmtblkno = 0;
955 		args->rmtblkcnt = 0;
956 		args->rmtvaluelen = 0;
957 	}
958 
959 	retval = xfs_attr3_leaf_add(blk->bp, state->args);
960 	if (retval == -ENOSPC) {
961 		if (state->path.active == 1) {
962 			/*
963 			 * Its really a single leaf node, but it had
964 			 * out-of-line values so it looked like it *might*
965 			 * have been a b-tree.
966 			 */
967 			xfs_da_state_free(state);
968 			state = NULL;
969 			error = xfs_attr3_leaf_to_node(args);
970 			if (error)
971 				goto out;
972 			error = xfs_defer_finish(&args->trans);
973 			if (error)
974 				goto out;
975 
976 			/*
977 			 * Commit the node conversion and start the next
978 			 * trans in the chain.
979 			 */
980 			error = xfs_trans_roll_inode(&args->trans, dp);
981 			if (error)
982 				goto out;
983 
984 			goto restart;
985 		}
986 
987 		/*
988 		 * Split as many Btree elements as required.
989 		 * This code tracks the new and old attr's location
990 		 * in the index/blkno/rmtblkno/rmtblkcnt fields and
991 		 * in the index2/blkno2/rmtblkno2/rmtblkcnt2 fields.
992 		 */
993 		error = xfs_da3_split(state);
994 		if (error)
995 			goto out;
996 		error = xfs_defer_finish(&args->trans);
997 		if (error)
998 			goto out;
999 	} else {
1000 		/*
1001 		 * Addition succeeded, update Btree hashvals.
1002 		 */
1003 		xfs_da3_fixhashpath(state, &state->path);
1004 	}
1005 
1006 	/*
1007 	 * Kill the state structure, we're done with it and need to
1008 	 * allow the buffers to come back later.
1009 	 */
1010 	xfs_da_state_free(state);
1011 	state = NULL;
1012 
1013 	/*
1014 	 * Commit the leaf addition or btree split and start the next
1015 	 * trans in the chain.
1016 	 */
1017 	error = xfs_trans_roll_inode(&args->trans, dp);
1018 	if (error)
1019 		goto out;
1020 
1021 	/*
1022 	 * If there was an out-of-line value, allocate the blocks we
1023 	 * identified for its storage and copy the value.  This is done
1024 	 * after we create the attribute so that we don't overflow the
1025 	 * maximum size of a transaction and/or hit a deadlock.
1026 	 */
1027 	if (args->rmtblkno > 0) {
1028 		error = xfs_attr_rmtval_set(args);
1029 		if (error)
1030 			return error;
1031 	}
1032 
1033 	if (!(args->op_flags & XFS_DA_OP_RENAME)) {
1034 		/*
1035 		 * Added a "remote" value, just clear the incomplete flag.
1036 		 */
1037 		if (args->rmtblkno > 0)
1038 			error = xfs_attr3_leaf_clearflag(args);
1039 		retval = error;
1040 		goto out;
1041 	}
1042 
1043 	/*
1044 	 * If this is an atomic rename operation, we must "flip" the incomplete
1045 	 * flags on the "new" and "old" attribute/value pairs so that one
1046 	 * disappears and one appears atomically.  Then we must remove the "old"
1047 	 * attribute/value pair.
1048 	 *
1049 	 * In a separate transaction, set the incomplete flag on the "old" attr
1050 	 * and clear the incomplete flag on the "new" attr.
1051 	 */
1052 	error = xfs_attr3_leaf_flipflags(args);
1053 	if (error)
1054 		goto out;
1055 	/*
1056 	 * Commit the flag value change and start the next trans in series
1057 	 */
1058 	error = xfs_trans_roll_inode(&args->trans, args->dp);
1059 	if (error)
1060 		goto out;
1061 
1062 	/*
1063 	 * Dismantle the "old" attribute/value pair by removing a "remote" value
1064 	 * (if it exists).
1065 	 */
1066 	xfs_attr_restore_rmt_blk(args);
1067 
1068 	if (args->rmtblkno) {
1069 		error = xfs_attr_rmtval_invalidate(args);
1070 		if (error)
1071 			return error;
1072 
1073 		error = xfs_attr_rmtval_remove(args);
1074 		if (error)
1075 			return error;
1076 	}
1077 
1078 	/*
1079 	 * Re-find the "old" attribute entry after any split ops. The INCOMPLETE
1080 	 * flag means that we will find the "old" attr, not the "new" one.
1081 	 */
1082 	args->attr_filter |= XFS_ATTR_INCOMPLETE;
1083 	state = xfs_da_state_alloc(args);
1084 	state->inleaf = 0;
1085 	error = xfs_da3_node_lookup_int(state, &retval);
1086 	if (error)
1087 		goto out;
1088 
1089 	/*
1090 	 * Remove the name and update the hashvals in the tree.
1091 	 */
1092 	blk = &state->path.blk[state->path.active-1];
1093 	ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
1094 	error = xfs_attr3_leaf_remove(blk->bp, args);
1095 	xfs_da3_fixhashpath(state, &state->path);
1096 
1097 	/*
1098 	 * Check to see if the tree needs to be collapsed.
1099 	 */
1100 	if (retval && (state->path.active > 1)) {
1101 		error = xfs_da3_join(state);
1102 		if (error)
1103 			goto out;
1104 	}
1105 	retval = error = 0;
1106 
1107 out:
1108 	if (state)
1109 		xfs_da_state_free(state);
1110 	if (error)
1111 		return error;
1112 	return retval;
1113 }
1114 
1115 /*
1116  * Shrink an attribute from leaf to shortform
1117  */
1118 STATIC int
1119 xfs_attr_node_shrink(
1120 	struct xfs_da_args	*args,
1121 	struct xfs_da_state     *state)
1122 {
1123 	struct xfs_inode	*dp = args->dp;
1124 	int			error, forkoff;
1125 	struct xfs_buf		*bp;
1126 
1127 	/*
1128 	 * Have to get rid of the copy of this dabuf in the state.
1129 	 */
1130 	ASSERT(state->path.active == 1);
1131 	ASSERT(state->path.blk[0].bp);
1132 	state->path.blk[0].bp = NULL;
1133 
1134 	error = xfs_attr3_leaf_read(args->trans, args->dp, 0, &bp);
1135 	if (error)
1136 		return error;
1137 
1138 	forkoff = xfs_attr_shortform_allfit(bp, dp);
1139 	if (forkoff) {
1140 		error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
1141 		/* bp is gone due to xfs_da_shrink_inode */
1142 	} else
1143 		xfs_trans_brelse(args->trans, bp);
1144 
1145 	return error;
1146 }
1147 
1148 /*
1149  * Mark an attribute entry INCOMPLETE and save pointers to the relevant buffers
1150  * for later deletion of the entry.
1151  */
1152 STATIC int
1153 xfs_attr_leaf_mark_incomplete(
1154 	struct xfs_da_args	*args,
1155 	struct xfs_da_state	*state)
1156 {
1157 	int			error;
1158 
1159 	/*
1160 	 * Fill in disk block numbers in the state structure
1161 	 * so that we can get the buffers back after we commit
1162 	 * several transactions in the following calls.
1163 	 */
1164 	error = xfs_attr_fillstate(state);
1165 	if (error)
1166 		return error;
1167 
1168 	/*
1169 	 * Mark the attribute as INCOMPLETE
1170 	 */
1171 	return xfs_attr3_leaf_setflag(args);
1172 }
1173 
1174 /*
1175  * Initial setup for xfs_attr_node_removename.  Make sure the attr is there and
1176  * the blocks are valid.  Attr keys with remote blocks will be marked
1177  * incomplete.
1178  */
1179 STATIC
1180 int xfs_attr_node_removename_setup(
1181 	struct xfs_da_args	*args,
1182 	struct xfs_da_state	**state)
1183 {
1184 	int			error;
1185 
1186 	error = xfs_attr_node_hasname(args, state);
1187 	if (error != -EEXIST)
1188 		return error;
1189 
1190 	ASSERT((*state)->path.blk[(*state)->path.active - 1].bp != NULL);
1191 	ASSERT((*state)->path.blk[(*state)->path.active - 1].magic ==
1192 		XFS_ATTR_LEAF_MAGIC);
1193 
1194 	if (args->rmtblkno > 0) {
1195 		error = xfs_attr_leaf_mark_incomplete(args, *state);
1196 		if (error)
1197 			return error;
1198 
1199 		return xfs_attr_rmtval_invalidate(args);
1200 	}
1201 
1202 	return 0;
1203 }
1204 
1205 STATIC int
1206 xfs_attr_node_remove_rmt(
1207 	struct xfs_da_args	*args,
1208 	struct xfs_da_state	*state)
1209 {
1210 	int			error = 0;
1211 
1212 	error = xfs_attr_rmtval_remove(args);
1213 	if (error)
1214 		return error;
1215 
1216 	/*
1217 	 * Refill the state structure with buffers, the prior calls released our
1218 	 * buffers.
1219 	 */
1220 	return xfs_attr_refillstate(state);
1221 }
1222 
1223 /*
1224  * Remove a name from a B-tree attribute list.
1225  *
1226  * This will involve walking down the Btree, and may involve joining
1227  * leaf nodes and even joining intermediate nodes up to and including
1228  * the root node (a special case of an intermediate node).
1229  */
1230 STATIC int
1231 xfs_attr_node_removename(
1232 	struct xfs_da_args	*args)
1233 {
1234 	struct xfs_da_state	*state;
1235 	struct xfs_da_state_blk	*blk;
1236 	int			retval, error;
1237 	struct xfs_inode	*dp = args->dp;
1238 
1239 	trace_xfs_attr_node_removename(args);
1240 
1241 	error = xfs_attr_node_removename_setup(args, &state);
1242 	if (error)
1243 		goto out;
1244 
1245 	/*
1246 	 * If there is an out-of-line value, de-allocate the blocks.
1247 	 * This is done before we remove the attribute so that we don't
1248 	 * overflow the maximum size of a transaction and/or hit a deadlock.
1249 	 */
1250 	if (args->rmtblkno > 0) {
1251 		error = xfs_attr_node_remove_rmt(args, state);
1252 		if (error)
1253 			goto out;
1254 	}
1255 
1256 	/*
1257 	 * Remove the name and update the hashvals in the tree.
1258 	 */
1259 	blk = &state->path.blk[ state->path.active-1 ];
1260 	ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
1261 	retval = xfs_attr3_leaf_remove(blk->bp, args);
1262 	xfs_da3_fixhashpath(state, &state->path);
1263 
1264 	/*
1265 	 * Check to see if the tree needs to be collapsed.
1266 	 */
1267 	if (retval && (state->path.active > 1)) {
1268 		error = xfs_da3_join(state);
1269 		if (error)
1270 			goto out;
1271 		error = xfs_defer_finish(&args->trans);
1272 		if (error)
1273 			goto out;
1274 		/*
1275 		 * Commit the Btree join operation and start a new trans.
1276 		 */
1277 		error = xfs_trans_roll_inode(&args->trans, dp);
1278 		if (error)
1279 			goto out;
1280 	}
1281 
1282 	/*
1283 	 * If the result is small enough, push it all into the inode.
1284 	 */
1285 	if (xfs_bmap_one_block(dp, XFS_ATTR_FORK))
1286 		error = xfs_attr_node_shrink(args, state);
1287 
1288 out:
1289 	if (state)
1290 		xfs_da_state_free(state);
1291 	return error;
1292 }
1293 
1294 /*
1295  * Fill in the disk block numbers in the state structure for the buffers
1296  * that are attached to the state structure.
1297  * This is done so that we can quickly reattach ourselves to those buffers
1298  * after some set of transaction commits have released these buffers.
1299  */
1300 STATIC int
1301 xfs_attr_fillstate(xfs_da_state_t *state)
1302 {
1303 	xfs_da_state_path_t *path;
1304 	xfs_da_state_blk_t *blk;
1305 	int level;
1306 
1307 	trace_xfs_attr_fillstate(state->args);
1308 
1309 	/*
1310 	 * Roll down the "path" in the state structure, storing the on-disk
1311 	 * block number for those buffers in the "path".
1312 	 */
1313 	path = &state->path;
1314 	ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
1315 	for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
1316 		if (blk->bp) {
1317 			blk->disk_blkno = XFS_BUF_ADDR(blk->bp);
1318 			blk->bp = NULL;
1319 		} else {
1320 			blk->disk_blkno = 0;
1321 		}
1322 	}
1323 
1324 	/*
1325 	 * Roll down the "altpath" in the state structure, storing the on-disk
1326 	 * block number for those buffers in the "altpath".
1327 	 */
1328 	path = &state->altpath;
1329 	ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
1330 	for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
1331 		if (blk->bp) {
1332 			blk->disk_blkno = XFS_BUF_ADDR(blk->bp);
1333 			blk->bp = NULL;
1334 		} else {
1335 			blk->disk_blkno = 0;
1336 		}
1337 	}
1338 
1339 	return 0;
1340 }
1341 
1342 /*
1343  * Reattach the buffers to the state structure based on the disk block
1344  * numbers stored in the state structure.
1345  * This is done after some set of transaction commits have released those
1346  * buffers from our grip.
1347  */
1348 STATIC int
1349 xfs_attr_refillstate(xfs_da_state_t *state)
1350 {
1351 	xfs_da_state_path_t *path;
1352 	xfs_da_state_blk_t *blk;
1353 	int level, error;
1354 
1355 	trace_xfs_attr_refillstate(state->args);
1356 
1357 	/*
1358 	 * Roll down the "path" in the state structure, storing the on-disk
1359 	 * block number for those buffers in the "path".
1360 	 */
1361 	path = &state->path;
1362 	ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
1363 	for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
1364 		if (blk->disk_blkno) {
1365 			error = xfs_da3_node_read_mapped(state->args->trans,
1366 					state->args->dp, blk->disk_blkno,
1367 					&blk->bp, XFS_ATTR_FORK);
1368 			if (error)
1369 				return error;
1370 		} else {
1371 			blk->bp = NULL;
1372 		}
1373 	}
1374 
1375 	/*
1376 	 * Roll down the "altpath" in the state structure, storing the on-disk
1377 	 * block number for those buffers in the "altpath".
1378 	 */
1379 	path = &state->altpath;
1380 	ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
1381 	for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
1382 		if (blk->disk_blkno) {
1383 			error = xfs_da3_node_read_mapped(state->args->trans,
1384 					state->args->dp, blk->disk_blkno,
1385 					&blk->bp, XFS_ATTR_FORK);
1386 			if (error)
1387 				return error;
1388 		} else {
1389 			blk->bp = NULL;
1390 		}
1391 	}
1392 
1393 	return 0;
1394 }
1395 
1396 /*
1397  * Retrieve the attribute data from a node attribute list.
1398  *
1399  * This routine gets called for any attribute fork that has more than one
1400  * block, ie: both true Btree attr lists and for single-leaf-blocks with
1401  * "remote" values taking up more blocks.
1402  *
1403  * Returns 0 on successful retrieval, otherwise an error.
1404  */
1405 STATIC int
1406 xfs_attr_node_get(
1407 	struct xfs_da_args	*args)
1408 {
1409 	struct xfs_da_state	*state;
1410 	struct xfs_da_state_blk	*blk;
1411 	int			i;
1412 	int			error;
1413 
1414 	trace_xfs_attr_node_get(args);
1415 
1416 	/*
1417 	 * Search to see if name exists, and get back a pointer to it.
1418 	 */
1419 	error = xfs_attr_node_hasname(args, &state);
1420 	if (error != -EEXIST)
1421 		goto out_release;
1422 
1423 	/*
1424 	 * Get the value, local or "remote"
1425 	 */
1426 	blk = &state->path.blk[state->path.active - 1];
1427 	error = xfs_attr3_leaf_getvalue(blk->bp, args);
1428 
1429 	/*
1430 	 * If not in a transaction, we have to release all the buffers.
1431 	 */
1432 out_release:
1433 	for (i = 0; state != NULL && i < state->path.active; i++) {
1434 		xfs_trans_brelse(args->trans, state->path.blk[i].bp);
1435 		state->path.blk[i].bp = NULL;
1436 	}
1437 
1438 	if (state)
1439 		xfs_da_state_free(state);
1440 	return error;
1441 }
1442 
1443 /* Returns true if the attribute entry name is valid. */
1444 bool
1445 xfs_attr_namecheck(
1446 	const void	*name,
1447 	size_t		length)
1448 {
1449 	/*
1450 	 * MAXNAMELEN includes the trailing null, but (name/length) leave it
1451 	 * out, so use >= for the length check.
1452 	 */
1453 	if (length >= MAXNAMELEN)
1454 		return false;
1455 
1456 	/* There shouldn't be any nulls here */
1457 	return !memchr(name, 0, length);
1458 }
1459