1/*
   2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   3 * All Rights Reserved.
   4 *
   5 * This program is free software; you can redistribute it and/or
   6 * modify it under the terms of the GNU General Public License as
   7 * published by the Free Software Foundation.
   8 *
   9 * This program is distributed in the hope that it would be useful,
  10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 * GNU General Public License for more details.
  13 *
  14 * You should have received a copy of the GNU General Public License
  15 * along with this program; if not, write the Free Software Foundation,
  16 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17 */
  18
  19#include "xfs.h"
  20#include "xfs_fs.h"
  21#include "xfs_types.h"
  22#include "xfs_bit.h"
  23#include "xfs_log.h"
  24#include "xfs_inum.h"
  25#include "xfs_trans.h"
  26#include "xfs_sb.h"
  27#include "xfs_ag.h"
  28#include "xfs_mount.h"
  29#include "xfs_da_btree.h"
  30#include "xfs_bmap_btree.h"
  31#include "xfs_attr_sf.h"
  32#include "xfs_dinode.h"
  33#include "xfs_inode.h"
  34#include "xfs_alloc.h"
  35#include "xfs_inode_item.h"
  36#include "xfs_bmap.h"
  37#include "xfs_attr.h"
  38#include "xfs_attr_leaf.h"
  39#include "xfs_error.h"
  40#include "xfs_quota.h"
  41#include "xfs_trans_space.h"
  42#include "xfs_rw.h"
  43#include "xfs_vnodeops.h"
  44#include "xfs_trace.h"
  45
  46/*
  47 * xfs_attr.c
  48 *
  49 * Provide the external interfaces to manage attribute lists.
  50 */
  51
  52/*========================================================================
  53 * Function prototypes for the kernel.
  54 *========================================================================*/
  55
  56/*
  57 * Internal routines when attribute list fits inside the inode.
  58 */
  59STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
  60
  61/*
  62 * Internal routines when attribute list is one block.
  63 */
  64STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
  65STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
  66STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
  67STATIC int xfs_attr_leaf_list(xfs_attr_list_context_t *context);
  68
  69/*
  70 * Internal routines when attribute list is more than one block.
  71 */
  72STATIC int xfs_attr_node_get(xfs_da_args_t *args);
  73STATIC int xfs_attr_node_addname(xfs_da_args_t *args);
  74STATIC int xfs_attr_node_removename(xfs_da_args_t *args);
  75STATIC int xfs_attr_node_list(xfs_attr_list_context_t *context);
  76STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
  77STATIC int xfs_attr_refillstate(xfs_da_state_t *state);
  78
  79/*
  80 * Routines to manipulate out-of-line attribute values.
  81 */
  82STATIC int xfs_attr_rmtval_set(xfs_da_args_t *args);
  83STATIC int xfs_attr_rmtval_remove(xfs_da_args_t *args);
  84
  85#define ATTR_RMTVALUE_MAPSIZE	1	/* # of map entries at once */
  86
  87STATIC int
  88xfs_attr_name_to_xname(
  89	struct xfs_name	*xname,
  90	const unsigned char *aname)
  91{
  92	if (!aname)
  93		return EINVAL;
  94	xname->name = aname;
  95	xname->len = strlen((char *)aname);
  96	if (xname->len >= MAXNAMELEN)
  97		return EFAULT;		/* match IRIX behaviour */
  98
  99	return 0;
 100}
 101
 102STATIC int
 103xfs_inode_hasattr(
 104	struct xfs_inode	*ip)
 105{
 106	if (!XFS_IFORK_Q(ip) ||
 107	    (ip->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS &&
 108	     ip->i_d.di_anextents == 0))
 109		return 0;
 110	return 1;
 111}
 112
 113/*========================================================================
 114 * Overall external interface routines.
 115 *========================================================================*/
 116
 117STATIC int
 118xfs_attr_get_int(
 119	struct xfs_inode	*ip,
 120	struct xfs_name		*name,
 121	unsigned char		*value,
 122	int			*valuelenp,
 123	int			flags)
 124{
 125	xfs_da_args_t   args;
 126	int             error;
 127
 128	if (!xfs_inode_hasattr(ip))
 129		return ENOATTR;
 130
 131	/*
 132	 * Fill in the arg structure for this request.
 133	 */
 134	memset((char *)&args, 0, sizeof(args));
 135	args.name = name->name;
 136	args.namelen = name->len;
 137	args.value = value;
 138	args.valuelen = *valuelenp;
 139	args.flags = flags;
 140	args.hashval = xfs_da_hashname(args.name, args.namelen);
 141	args.dp = ip;
 142	args.whichfork = XFS_ATTR_FORK;
 143
 144	/*
 145	 * Decide on what work routines to call based on the inode size.
 146	 */
 147	if (ip->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
 148		error = xfs_attr_shortform_getvalue(&args);
 149	} else if (xfs_bmap_one_block(ip, XFS_ATTR_FORK)) {
 150		error = xfs_attr_leaf_get(&args);
 151	} else {
 152		error = xfs_attr_node_get(&args);
 153	}
 154
 155	/*
 156	 * Return the number of bytes in the value to the caller.
 157	 */
 158	*valuelenp = args.valuelen;
 159
 160	if (error == EEXIST)
 161		error = 0;
 162	return(error);
 163}
 164
 165int
 166xfs_attr_get(
 167	xfs_inode_t	*ip,
 168	const unsigned char *name,
 169	unsigned char	*value,
 170	int		*valuelenp,
 171	int		flags)
 172{
 173	int		error;
 174	struct xfs_name	xname;
 175
 176	XFS_STATS_INC(xs_attr_get);
 177
 178	if (XFS_FORCED_SHUTDOWN(ip->i_mount))
 179		return(EIO);
 180
 181	error = xfs_attr_name_to_xname(&xname, name);
 182	if (error)
 183		return error;
 184
 185	xfs_ilock(ip, XFS_ILOCK_SHARED);
 186	error = xfs_attr_get_int(ip, &xname, value, valuelenp, flags);
 187	xfs_iunlock(ip, XFS_ILOCK_SHARED);
 188	return(error);
 189}
 190
 191/*
 192 * Calculate how many blocks we need for the new attribute,
 193 */
 194STATIC int
 195xfs_attr_calc_size(
 196	struct xfs_inode 	*ip,
 197	int			namelen,
 198	int			valuelen,
 199	int			*local)
 200{
 201	struct xfs_mount 	*mp = ip->i_mount;
 202	int			size;
 203	int			nblks;
 204
 205	/*
 206	 * Determine space new attribute will use, and if it would be
 207	 * "local" or "remote" (note: local != inline).
 208	 */
 209	size = xfs_attr_leaf_newentsize(namelen, valuelen,
 210					mp->m_sb.sb_blocksize, local);
 211
 212	nblks = XFS_DAENTER_SPACE_RES(mp, XFS_ATTR_FORK);
 213	if (*local) {
 214		if (size > (mp->m_sb.sb_blocksize >> 1)) {
 215			/* Double split possible */
 216			nblks *= 2;
 217		}
 218	} else {
 219		/*
 220		 * Out of line attribute, cannot double split, but
 221		 * make room for the attribute value itself.
 222		 */
 223		uint	dblocks = XFS_B_TO_FSB(mp, valuelen);
 224		nblks += dblocks;
 225		nblks += XFS_NEXTENTADD_SPACE_RES(mp, dblocks, XFS_ATTR_FORK);
 226	}
 227
 228	return nblks;
 229}
 230
 231STATIC int
 232xfs_attr_set_int(
 233	struct xfs_inode *dp,
 234	struct xfs_name	*name,
 235	unsigned char	*value,
 236	int		valuelen,
 237	int		flags)
 238{
 239	xfs_da_args_t	args;
 240	xfs_fsblock_t	firstblock;
 241	xfs_bmap_free_t flist;
 242	int		error, err2, committed;
 243	xfs_mount_t	*mp = dp->i_mount;
 244	int             rsvd = (flags & ATTR_ROOT) != 0;
 245	int		local;
 246
 247	/*
 248	 * Attach the dquots to the inode.
 249	 */
 250	error = xfs_qm_dqattach(dp, 0);
 251	if (error)
 252		return error;
 253
 254	/*
 255	 * If the inode doesn't have an attribute fork, add one.
 256	 * (inode must not be locked when we call this routine)
 257	 */
 258	if (XFS_IFORK_Q(dp) == 0) {
 259		int sf_size = sizeof(xfs_attr_sf_hdr_t) +
 260			      XFS_ATTR_SF_ENTSIZE_BYNAME(name->len, valuelen);
 261
 262		if ((error = xfs_bmap_add_attrfork(dp, sf_size, rsvd)))
 263			return(error);
 264	}
 265
 266	/*
 267	 * Fill in the arg structure for this request.
 268	 */
 269	memset((char *)&args, 0, sizeof(args));
 270	args.name = name->name;
 271	args.namelen = name->len;
 272	args.value = value;
 273	args.valuelen = valuelen;
 274	args.flags = flags;
 275	args.hashval = xfs_da_hashname(args.name, args.namelen);
 276	args.dp = dp;
 277	args.firstblock = &firstblock;
 278	args.flist = &flist;
 279	args.whichfork = XFS_ATTR_FORK;
 280	args.op_flags = XFS_DA_OP_ADDNAME | XFS_DA_OP_OKNOENT;
 281
 282	/* Size is now blocks for attribute data */
 283	args.total = xfs_attr_calc_size(dp, name->len, valuelen, &local);
 284
 285	/*
 286	 * Start our first transaction of the day.
 287	 *
 288	 * All future transactions during this code must be "chained" off
 289	 * this one via the trans_dup() call.  All transactions will contain
 290	 * the inode, and the inode will always be marked with trans_ihold().
 291	 * Since the inode will be locked in all transactions, we must log
 292	 * the inode in every transaction to let it float upward through
 293	 * the log.
 294	 */
 295	args.trans = xfs_trans_alloc(mp, XFS_TRANS_ATTR_SET);
 296
 297	/*
 298	 * Root fork attributes can use reserved data blocks for this
 299	 * operation if necessary
 300	 */
 301
 302	if (rsvd)
 303		args.trans->t_flags |= XFS_TRANS_RESERVE;
 304
 305	if ((error = xfs_trans_reserve(args.trans, args.total,
 306			XFS_ATTRSET_LOG_RES(mp, args.total), 0,
 307			XFS_TRANS_PERM_LOG_RES, XFS_ATTRSET_LOG_COUNT))) {
 308		xfs_trans_cancel(args.trans, 0);
 309		return(error);
 310	}
 311	xfs_ilock(dp, XFS_ILOCK_EXCL);
 312
 313	error = xfs_trans_reserve_quota_nblks(args.trans, dp, args.total, 0,
 314				rsvd ? XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_FORCE_RES :
 315				       XFS_QMOPT_RES_REGBLKS);
 316	if (error) {
 317		xfs_iunlock(dp, XFS_ILOCK_EXCL);
 318		xfs_trans_cancel(args.trans, XFS_TRANS_RELEASE_LOG_RES);
 319		return (error);
 320	}
 321
 322	xfs_trans_ijoin(args.trans, dp);
 323
 324	/*
 325	 * If the attribute list is non-existent or a shortform list,
 326	 * upgrade it to a single-leaf-block attribute list.
 327	 */
 328	if ((dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) ||
 329	    ((dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS) &&
 330	     (dp->i_d.di_anextents == 0))) {
 331
 332		/*
 333		 * Build initial attribute list (if required).
 334		 */
 335		if (dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS)
 336			xfs_attr_shortform_create(&args);
 337
 338		/*
 339		 * Try to add the attr to the attribute list in
 340		 * the inode.
 341		 */
 342		error = xfs_attr_shortform_addname(&args);
 343		if (error != ENOSPC) {
 344			/*
 345			 * Commit the shortform mods, and we're done.
 346			 * NOTE: this is also the error path (EEXIST, etc).
 347			 */
 348			ASSERT(args.trans != NULL);
 349
 350			/*
 351			 * If this is a synchronous mount, make sure that
 352			 * the transaction goes to disk before returning
 353			 * to the user.
 354			 */
 355			if (mp->m_flags & XFS_MOUNT_WSYNC) {
 356				xfs_trans_set_sync(args.trans);
 357			}
 358
 359			if (!error && (flags & ATTR_KERNOTIME) == 0) {
 360				xfs_trans_ichgtime(args.trans, dp,
 361							XFS_ICHGTIME_CHG);
 362			}
 363			err2 = xfs_trans_commit(args.trans,
 364						 XFS_TRANS_RELEASE_LOG_RES);
 365			xfs_iunlock(dp, XFS_ILOCK_EXCL);
 366
 367			return(error == 0 ? err2 : error);
 368		}
 369
 370		/*
 371		 * It won't fit in the shortform, transform to a leaf block.
 372		 * GROT: another possible req'mt for a double-split btree op.
 373		 */
 374		xfs_bmap_init(args.flist, args.firstblock);
 375		error = xfs_attr_shortform_to_leaf(&args);
 376		if (!error) {
 377			error = xfs_bmap_finish(&args.trans, args.flist,
 378						&committed);
 379		}
 380		if (error) {
 381			ASSERT(committed);
 382			args.trans = NULL;
 383			xfs_bmap_cancel(&flist);
 384			goto out;
 385		}
 386
 387		/*
 388		 * bmap_finish() may have committed the last trans and started
 389		 * a new one.  We need the inode to be in all transactions.
 390		 */
 391		if (committed)
 392			xfs_trans_ijoin(args.trans, dp);
 393
 394		/*
 395		 * Commit the leaf transformation.  We'll need another (linked)
 396		 * transaction to add the new attribute to the leaf.
 397		 */
 398
 399		error = xfs_trans_roll(&args.trans, dp);
 400		if (error)
 401			goto out;
 402
 403	}
 404
 405	if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
 406		error = xfs_attr_leaf_addname(&args);
 407	} else {
 408		error = xfs_attr_node_addname(&args);
 409	}
 410	if (error) {
 411		goto out;
 412	}
 413
 414	/*
 415	 * If this is a synchronous mount, make sure that the
 416	 * transaction goes to disk before returning to the user.
 417	 */
 418	if (mp->m_flags & XFS_MOUNT_WSYNC) {
 419		xfs_trans_set_sync(args.trans);
 420	}
 421
 422	if ((flags & ATTR_KERNOTIME) == 0)
 423		xfs_trans_ichgtime(args.trans, dp, XFS_ICHGTIME_CHG);
 424
 425	/*
 426	 * Commit the last in the sequence of transactions.
 427	 */
 428	xfs_trans_log_inode(args.trans, dp, XFS_ILOG_CORE);
 429	error = xfs_trans_commit(args.trans, XFS_TRANS_RELEASE_LOG_RES);
 430	xfs_iunlock(dp, XFS_ILOCK_EXCL);
 431
 432	return(error);
 433
 434out:
 435	if (args.trans)
 436		xfs_trans_cancel(args.trans,
 437			XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
 438	xfs_iunlock(dp, XFS_ILOCK_EXCL);
 439	return(error);
 440}
 441
 442int
 443xfs_attr_set(
 444	xfs_inode_t	*dp,
 445	const unsigned char *name,
 446	unsigned char	*value,
 447	int		valuelen,
 448	int		flags)
 449{
 450	int             error;
 451	struct xfs_name	xname;
 452
 453	XFS_STATS_INC(xs_attr_set);
 454
 455	if (XFS_FORCED_SHUTDOWN(dp->i_mount))
 456		return (EIO);
 457
 458	error = xfs_attr_name_to_xname(&xname, name);
 459	if (error)
 460		return error;
 461
 462	return xfs_attr_set_int(dp, &xname, value, valuelen, flags);
 463}
 464
 465/*
 466 * Generic handler routine to remove a name from an attribute list.
 467 * Transitions attribute list from Btree to shortform as necessary.
 468 */
 469STATIC int
 470xfs_attr_remove_int(xfs_inode_t *dp, struct xfs_name *name, int flags)
 471{
 472	xfs_da_args_t	args;
 473	xfs_fsblock_t	firstblock;
 474	xfs_bmap_free_t	flist;
 475	int		error;
 476	xfs_mount_t	*mp = dp->i_mount;
 477
 478	/*
 479	 * Fill in the arg structure for this request.
 480	 */
 481	memset((char *)&args, 0, sizeof(args));
 482	args.name = name->name;
 483	args.namelen = name->len;
 484	args.flags = flags;
 485	args.hashval = xfs_da_hashname(args.name, args.namelen);
 486	args.dp = dp;
 487	args.firstblock = &firstblock;
 488	args.flist = &flist;
 489	args.total = 0;
 490	args.whichfork = XFS_ATTR_FORK;
 491
 492	/*
 493	 * we have no control over the attribute names that userspace passes us
 494	 * to remove, so we have to allow the name lookup prior to attribute
 495	 * removal to fail.
 496	 */
 497	args.op_flags = XFS_DA_OP_OKNOENT;
 498
 499	/*
 500	 * Attach the dquots to the inode.
 501	 */
 502	error = xfs_qm_dqattach(dp, 0);
 503	if (error)
 504		return error;
 505
 506	/*
 507	 * Start our first transaction of the day.
 508	 *
 509	 * All future transactions during this code must be "chained" off
 510	 * this one via the trans_dup() call.  All transactions will contain
 511	 * the inode, and the inode will always be marked with trans_ihold().
 512	 * Since the inode will be locked in all transactions, we must log
 513	 * the inode in every transaction to let it float upward through
 514	 * the log.
 515	 */
 516	args.trans = xfs_trans_alloc(mp, XFS_TRANS_ATTR_RM);
 517
 518	/*
 519	 * Root fork attributes can use reserved data blocks for this
 520	 * operation if necessary
 521	 */
 522
 523	if (flags & ATTR_ROOT)
 524		args.trans->t_flags |= XFS_TRANS_RESERVE;
 525
 526	if ((error = xfs_trans_reserve(args.trans,
 527				      XFS_ATTRRM_SPACE_RES(mp),
 528				      XFS_ATTRRM_LOG_RES(mp),
 529				      0, XFS_TRANS_PERM_LOG_RES,
 530				      XFS_ATTRRM_LOG_COUNT))) {
 531		xfs_trans_cancel(args.trans, 0);
 532		return(error);
 533	}
 534
 535	xfs_ilock(dp, XFS_ILOCK_EXCL);
 536	/*
 537	 * No need to make quota reservations here. We expect to release some
 538	 * blocks not allocate in the common case.
 539	 */
 540	xfs_trans_ijoin(args.trans, dp);
 541
 542	/*
 543	 * Decide on what work routines to call based on the inode size.
 544	 */
 545	if (!xfs_inode_hasattr(dp)) {
 546		error = XFS_ERROR(ENOATTR);
 547		goto out;
 548	}
 549	if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
 550		ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
 551		error = xfs_attr_shortform_remove(&args);
 552		if (error) {
 553			goto out;
 554		}
 555	} else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
 556		error = xfs_attr_leaf_removename(&args);
 557	} else {
 558		error = xfs_attr_node_removename(&args);
 559	}
 560	if (error) {
 561		goto out;
 562	}
 563
 564	/*
 565	 * If this is a synchronous mount, make sure that the
 566	 * transaction goes to disk before returning to the user.
 567	 */
 568	if (mp->m_flags & XFS_MOUNT_WSYNC) {
 569		xfs_trans_set_sync(args.trans);
 570	}
 571
 572	if ((flags & ATTR_KERNOTIME) == 0)
 573		xfs_trans_ichgtime(args.trans, dp, XFS_ICHGTIME_CHG);
 574
 575	/*
 576	 * Commit the last in the sequence of transactions.
 577	 */
 578	xfs_trans_log_inode(args.trans, dp, XFS_ILOG_CORE);
 579	error = xfs_trans_commit(args.trans, XFS_TRANS_RELEASE_LOG_RES);
 580	xfs_iunlock(dp, XFS_ILOCK_EXCL);
 581
 582	return(error);
 583
 584out:
 585	if (args.trans)
 586		xfs_trans_cancel(args.trans,
 587			XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
 588	xfs_iunlock(dp, XFS_ILOCK_EXCL);
 589	return(error);
 590}
 591
 592int
 593xfs_attr_remove(
 594	xfs_inode_t	*dp,
 595	const unsigned char *name,
 596	int		flags)
 597{
 598	int		error;
 599	struct xfs_name	xname;
 600
 601	XFS_STATS_INC(xs_attr_remove);
 602
 603	if (XFS_FORCED_SHUTDOWN(dp->i_mount))
 604		return (EIO);
 605
 606	error = xfs_attr_name_to_xname(&xname, name);
 607	if (error)
 608		return error;
 609
 610	xfs_ilock(dp, XFS_ILOCK_SHARED);
 611	if (!xfs_inode_hasattr(dp)) {
 612		xfs_iunlock(dp, XFS_ILOCK_SHARED);
 613		return XFS_ERROR(ENOATTR);
 614	}
 615	xfs_iunlock(dp, XFS_ILOCK_SHARED);
 616
 617	return xfs_attr_remove_int(dp, &xname, flags);
 618}
 619
 620int
 621xfs_attr_list_int(xfs_attr_list_context_t *context)
 622{
 623	int error;
 624	xfs_inode_t *dp = context->dp;
 625
 626	XFS_STATS_INC(xs_attr_list);
 627
 628	if (XFS_FORCED_SHUTDOWN(dp->i_mount))
 629		return EIO;
 630
 631	xfs_ilock(dp, XFS_ILOCK_SHARED);
 632
 633	/*
 634	 * Decide on what work routines to call based on the inode size.
 635	 */
 636	if (!xfs_inode_hasattr(dp)) {
 637		error = 0;
 638	} else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
 639		error = xfs_attr_shortform_list(context);
 640	} else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
 641		error = xfs_attr_leaf_list(context);
 642	} else {
 643		error = xfs_attr_node_list(context);
 644	}
 645
 646	xfs_iunlock(dp, XFS_ILOCK_SHARED);
 647
 648	return error;
 649}
 650
 651#define	ATTR_ENTBASESIZE		/* minimum bytes used by an attr */ \
 652	(((struct attrlist_ent *) 0)->a_name - (char *) 0)
 653#define	ATTR_ENTSIZE(namelen)		/* actual bytes used by an attr */ \
 654	((ATTR_ENTBASESIZE + (namelen) + 1 + sizeof(u_int32_t)-1) \
 655	 & ~(sizeof(u_int32_t)-1))
 656
 657/*
 658 * Format an attribute and copy it out to the user's buffer.
 659 * Take care to check values and protect against them changing later,
 660 * we may be reading them directly out of a user buffer.
 661 */
 662/*ARGSUSED*/
 663STATIC int
 664xfs_attr_put_listent(
 665	xfs_attr_list_context_t *context,
 666	int		flags,
 667	unsigned char	*name,
 668	int		namelen,
 669	int		valuelen,
 670	unsigned char	*value)
 671{
 672	struct attrlist *alist = (struct attrlist *)context->alist;
 673	attrlist_ent_t *aep;
 674	int arraytop;
 675
 676	ASSERT(!(context->flags & ATTR_KERNOVAL));
 677	ASSERT(context->count >= 0);
 678	ASSERT(context->count < (ATTR_MAX_VALUELEN/8));
 679	ASSERT(context->firstu >= sizeof(*alist));
 680	ASSERT(context->firstu <= context->bufsize);
 681
 682	/*
 683	 * Only list entries in the right namespace.
 684	 */
 685	if (((context->flags & ATTR_SECURE) == 0) !=
 686	    ((flags & XFS_ATTR_SECURE) == 0))
 687		return 0;
 688	if (((context->flags & ATTR_ROOT) == 0) !=
 689	    ((flags & XFS_ATTR_ROOT) == 0))
 690		return 0;
 691
 692	arraytop = sizeof(*alist) +
 693			context->count * sizeof(alist->al_offset[0]);
 694	context->firstu -= ATTR_ENTSIZE(namelen);
 695	if (context->firstu < arraytop) {
 696		trace_xfs_attr_list_full(context);
 697		alist->al_more = 1;
 698		context->seen_enough = 1;
 699		return 1;
 700	}
 701
 702	aep = (attrlist_ent_t *)&context->alist[context->firstu];
 703	aep->a_valuelen = valuelen;
 704	memcpy(aep->a_name, name, namelen);
 705	aep->a_name[namelen] = 0;
 706	alist->al_offset[context->count++] = context->firstu;
 707	alist->al_count = context->count;
 708	trace_xfs_attr_list_add(context);
 709	return 0;
 710}
 711
 712/*
 713 * Generate a list of extended attribute names and optionally
 714 * also value lengths.  Positive return value follows the XFS
 715 * convention of being an error, zero or negative return code
 716 * is the length of the buffer returned (negated), indicating
 717 * success.
 718 */
 719int
 720xfs_attr_list(
 721	xfs_inode_t	*dp,
 722	char		*buffer,
 723	int		bufsize,
 724	int		flags,
 725	attrlist_cursor_kern_t *cursor)
 726{
 727	xfs_attr_list_context_t context;
 728	struct attrlist *alist;
 729	int error;
 730
 731	/*
 732	 * Validate the cursor.
 733	 */
 734	if (cursor->pad1 || cursor->pad2)
 735		return(XFS_ERROR(EINVAL));
 736	if ((cursor->initted == 0) &&
 737	    (cursor->hashval || cursor->blkno || cursor->offset))
 738		return XFS_ERROR(EINVAL);
 739
 740	/*
 741	 * Check for a properly aligned buffer.
 742	 */
 743	if (((long)buffer) & (sizeof(int)-1))
 744		return XFS_ERROR(EFAULT);
 745	if (flags & ATTR_KERNOVAL)
 746		bufsize = 0;
 747
 748	/*
 749	 * Initialize the output buffer.
 750	 */
 751	memset(&context, 0, sizeof(context));
 752	context.dp = dp;
 753	context.cursor = cursor;
 754	context.resynch = 1;
 755	context.flags = flags;
 756	context.alist = buffer;
 757	context.bufsize = (bufsize & ~(sizeof(int)-1));  /* align */
 758	context.firstu = context.bufsize;
 759	context.put_listent = xfs_attr_put_listent;
 760
 761	alist = (struct attrlist *)context.alist;
 762	alist->al_count = 0;
 763	alist->al_more = 0;
 764	alist->al_offset[0] = context.bufsize;
 765
 766	error = xfs_attr_list_int(&context);
 767	ASSERT(error >= 0);
 768	return error;
 769}
 770
 771int								/* error */
 772xfs_attr_inactive(xfs_inode_t *dp)
 773{
 774	xfs_trans_t *trans;
 775	xfs_mount_t *mp;
 776	int error;
 777
 778	mp = dp->i_mount;
 779	ASSERT(! XFS_NOT_DQATTACHED(mp, dp));
 780
 781	xfs_ilock(dp, XFS_ILOCK_SHARED);
 782	if (!xfs_inode_hasattr(dp) ||
 783	    dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
 784		xfs_iunlock(dp, XFS_ILOCK_SHARED);
 785		return 0;
 786	}
 787	xfs_iunlock(dp, XFS_ILOCK_SHARED);
 788
 789	/*
 790	 * Start our first transaction of the day.
 791	 *
 792	 * All future transactions during this code must be "chained" off
 793	 * this one via the trans_dup() call.  All transactions will contain
 794	 * the inode, and the inode will always be marked with trans_ihold().
 795	 * Since the inode will be locked in all transactions, we must log
 796	 * the inode in every transaction to let it float upward through
 797	 * the log.
 798	 */
 799	trans = xfs_trans_alloc(mp, XFS_TRANS_ATTRINVAL);
 800	if ((error = xfs_trans_reserve(trans, 0, XFS_ATTRINVAL_LOG_RES(mp), 0,
 801				      XFS_TRANS_PERM_LOG_RES,
 802				      XFS_ATTRINVAL_LOG_COUNT))) {
 803		xfs_trans_cancel(trans, 0);
 804		return(error);
 805	}
 806	xfs_ilock(dp, XFS_ILOCK_EXCL);
 807
 808	/*
 809	 * No need to make quota reservations here. We expect to release some
 810	 * blocks, not allocate, in the common case.
 811	 */
 812	xfs_trans_ijoin(trans, dp);
 813
 814	/*
 815	 * Decide on what work routines to call based on the inode size.
 816	 */
 817	if (!xfs_inode_hasattr(dp) ||
 818	    dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
 819		error = 0;
 820		goto out;
 821	}
 822	error = xfs_attr_root_inactive(&trans, dp);
 823	if (error)
 824		goto out;
 825
 826	/*
 827	 * Signal synchronous inactive transactions unless this is a
 828	 * synchronous mount filesystem in which case we know that we're here
 829	 * because we've been called out of xfs_inactive which means that the
 830	 * last reference is gone and the unlink transaction has already hit
 831	 * the disk so async inactive transactions are safe.
 832	 */
 833	if (!(mp->m_flags & XFS_MOUNT_WSYNC)) {
 834		if (dp->i_d.di_anextents > 0)
 835			xfs_trans_set_sync(trans);
 836	}
 837
 838	error = xfs_itruncate_extents(&trans, dp, XFS_ATTR_FORK, 0);
 839	if (error)
 840		goto out;
 841
 842	/*
 843	 * Commit the last in the sequence of transactions.
 844	 */
 845	xfs_trans_log_inode(trans, dp, XFS_ILOG_CORE);
 846	error = xfs_trans_commit(trans, XFS_TRANS_RELEASE_LOG_RES);
 847	xfs_iunlock(dp, XFS_ILOCK_EXCL);
 848
 849	return(error);
 850
 851out:
 852	xfs_trans_cancel(trans, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
 853	xfs_iunlock(dp, XFS_ILOCK_EXCL);
 854	return(error);
 855}
 856
 857
 858
 859/*========================================================================
 860 * External routines when attribute list is inside the inode
 861 *========================================================================*/
 862
 863/*
 864 * Add a name to the shortform attribute list structure
 865 * This is the external routine.
 866 */
 867STATIC int
 868xfs_attr_shortform_addname(xfs_da_args_t *args)
 869{
 870	int newsize, forkoff, retval;
 871
 
 
 872	retval = xfs_attr_shortform_lookup(args);
 873	if ((args->flags & ATTR_REPLACE) && (retval == ENOATTR)) {
 874		return(retval);
 875	} else if (retval == EEXIST) {
 876		if (args->flags & ATTR_CREATE)
 877			return(retval);
 878		retval = xfs_attr_shortform_remove(args);
 879		ASSERT(retval == 0);
 880	}
 881
 882	if (args->namelen >= XFS_ATTR_SF_ENTSIZE_MAX ||
 883	    args->valuelen >= XFS_ATTR_SF_ENTSIZE_MAX)
 884		return(XFS_ERROR(ENOSPC));
 885
 886	newsize = XFS_ATTR_SF_TOTSIZE(args->dp);
 887	newsize += XFS_ATTR_SF_ENTSIZE_BYNAME(args->namelen, args->valuelen);
 888
 889	forkoff = xfs_attr_shortform_bytesfit(args->dp, newsize);
 890	if (!forkoff)
 891		return(XFS_ERROR(ENOSPC));
 892
 893	xfs_attr_shortform_add(args, forkoff);
 894	return(0);
 895}
 896
 897
 898/*========================================================================
 899 * External routines when attribute list is one block
 900 *========================================================================*/
 901
 902/*
 903 * Add a name to the leaf attribute list structure
 904 *
 905 * This leaf block cannot have a "remote" value, we only call this routine
 906 * if bmap_one_block() says there is only one block (ie: no remote blks).
 907 */
 908STATIC int
 909xfs_attr_leaf_addname(xfs_da_args_t *args)
 910{
 911	xfs_inode_t *dp;
 912	xfs_dabuf_t *bp;
 913	int retval, error, committed, forkoff;
 914
 
 
 915	/*
 916	 * Read the (only) block in the attribute list in.
 917	 */
 918	dp = args->dp;
 919	args->blkno = 0;
 920	error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp,
 921					     XFS_ATTR_FORK);
 922	if (error)
 923		return(error);
 924	ASSERT(bp != NULL);
 925
 926	/*
 927	 * Look up the given attribute in the leaf block.  Figure out if
 928	 * the given flags produce an error or call for an atomic rename.
 929	 */
 930	retval = xfs_attr_leaf_lookup_int(bp, args);
 931	if ((args->flags & ATTR_REPLACE) && (retval == ENOATTR)) {
 932		xfs_da_brelse(args->trans, bp);
 933		return(retval);
 934	} else if (retval == EEXIST) {
 935		if (args->flags & ATTR_CREATE) {	/* pure create op */
 936			xfs_da_brelse(args->trans, bp);
 937			return(retval);
 938		}
 
 
 
 939		args->op_flags |= XFS_DA_OP_RENAME;	/* an atomic rename */
 940		args->blkno2 = args->blkno;		/* set 2nd entry info*/
 941		args->index2 = args->index;
 942		args->rmtblkno2 = args->rmtblkno;
 943		args->rmtblkcnt2 = args->rmtblkcnt;
 944	}
 945
 946	/*
 947	 * Add the attribute to the leaf block, transitioning to a Btree
 948	 * if required.
 949	 */
 950	retval = xfs_attr_leaf_add(bp, args);
 951	xfs_da_buf_done(bp);
 952	if (retval == ENOSPC) {
 953		/*
 954		 * Promote the attribute list to the Btree format, then
 955		 * Commit that transaction so that the node_addname() call
 956		 * can manage its own transactions.
 957		 */
 958		xfs_bmap_init(args->flist, args->firstblock);
 959		error = xfs_attr_leaf_to_node(args);
 960		if (!error) {
 961			error = xfs_bmap_finish(&args->trans, args->flist,
 962						&committed);
 963		}
 964		if (error) {
 965			ASSERT(committed);
 966			args->trans = NULL;
 967			xfs_bmap_cancel(args->flist);
 968			return(error);
 969		}
 970
 971		/*
 972		 * bmap_finish() may have committed the last trans and started
 973		 * a new one.  We need the inode to be in all transactions.
 974		 */
 975		if (committed)
 976			xfs_trans_ijoin(args->trans, dp);
 977
 978		/*
 979		 * Commit the current trans (including the inode) and start
 980		 * a new one.
 981		 */
 982		error = xfs_trans_roll(&args->trans, dp);
 983		if (error)
 984			return (error);
 985
 986		/*
 987		 * Fob the whole rest of the problem off on the Btree code.
 988		 */
 989		error = xfs_attr_node_addname(args);
 990		return(error);
 991	}
 992
 993	/*
 994	 * Commit the transaction that added the attr name so that
 995	 * later routines can manage their own transactions.
 996	 */
 997	error = xfs_trans_roll(&args->trans, dp);
 998	if (error)
 999		return (error);
1000
1001	/*
1002	 * If there was an out-of-line value, allocate the blocks we
1003	 * identified for its storage and copy the value.  This is done
1004	 * after we create the attribute so that we don't overflow the
1005	 * maximum size of a transaction and/or hit a deadlock.
1006	 */
1007	if (args->rmtblkno > 0) {
1008		error = xfs_attr_rmtval_set(args);
1009		if (error)
1010			return(error);
1011	}
1012
1013	/*
1014	 * If this is an atomic rename operation, we must "flip" the
1015	 * incomplete flags on the "new" and "old" attribute/value pairs
1016	 * so that one disappears and one appears atomically.  Then we
1017	 * must remove the "old" attribute/value pair.
1018	 */
1019	if (args->op_flags & XFS_DA_OP_RENAME) {
1020		/*
1021		 * In a separate transaction, set the incomplete flag on the
1022		 * "old" attr and clear the incomplete flag on the "new" attr.
1023		 */
1024		error = xfs_attr_leaf_flipflags(args);
1025		if (error)
1026			return(error);
1027
1028		/*
1029		 * Dismantle the "old" attribute/value pair by removing
1030		 * a "remote" value (if it exists).
1031		 */
1032		args->index = args->index2;
1033		args->blkno = args->blkno2;
1034		args->rmtblkno = args->rmtblkno2;
1035		args->rmtblkcnt = args->rmtblkcnt2;
1036		if (args->rmtblkno) {
1037			error = xfs_attr_rmtval_remove(args);
1038			if (error)
1039				return(error);
1040		}
1041
1042		/*
1043		 * Read in the block containing the "old" attr, then
1044		 * remove the "old" attr from that block (neat, huh!)
1045		 */
1046		error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1,
1047						     &bp, XFS_ATTR_FORK);
1048		if (error)
1049			return(error);
1050		ASSERT(bp != NULL);
1051		(void)xfs_attr_leaf_remove(bp, args);
1052
1053		/*
1054		 * If the result is small enough, shrink it all into the inode.
1055		 */
1056		if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
1057			xfs_bmap_init(args->flist, args->firstblock);
1058			error = xfs_attr_leaf_to_shortform(bp, args, forkoff);
1059			/* bp is gone due to xfs_da_shrink_inode */
1060			if (!error) {
1061				error = xfs_bmap_finish(&args->trans,
1062							args->flist,
1063							&committed);
1064			}
1065			if (error) {
1066				ASSERT(committed);
1067				args->trans = NULL;
1068				xfs_bmap_cancel(args->flist);
1069				return(error);
1070			}
1071
1072			/*
1073			 * bmap_finish() may have committed the last trans
1074			 * and started a new one.  We need the inode to be
1075			 * in all transactions.
1076			 */
1077			if (committed)
1078				xfs_trans_ijoin(args->trans, dp);
1079		} else
1080			xfs_da_buf_done(bp);
1081
1082		/*
1083		 * Commit the remove and start the next trans in series.
1084		 */
1085		error = xfs_trans_roll(&args->trans, dp);
1086
1087	} else if (args->rmtblkno > 0) {
1088		/*
1089		 * Added a "remote" value, just clear the incomplete flag.
1090		 */
1091		error = xfs_attr_leaf_clearflag(args);
1092	}
1093	return(error);
1094}
1095
1096/*
1097 * Remove a name from the leaf attribute list structure
1098 *
1099 * This leaf block cannot have a "remote" value, we only call this routine
1100 * if bmap_one_block() says there is only one block (ie: no remote blks).
1101 */
1102STATIC int
1103xfs_attr_leaf_removename(xfs_da_args_t *args)
1104{
1105	xfs_inode_t *dp;
1106	xfs_dabuf_t *bp;
1107	int error, committed, forkoff;
1108
 
 
1109	/*
1110	 * Remove the attribute.
1111	 */
1112	dp = args->dp;
1113	args->blkno = 0;
1114	error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp,
1115					     XFS_ATTR_FORK);
1116	if (error) {
1117		return(error);
1118	}
1119
1120	ASSERT(bp != NULL);
1121	error = xfs_attr_leaf_lookup_int(bp, args);
1122	if (error == ENOATTR) {
1123		xfs_da_brelse(args->trans, bp);
1124		return(error);
1125	}
1126
1127	(void)xfs_attr_leaf_remove(bp, args);
1128
1129	/*
1130	 * If the result is small enough, shrink it all into the inode.
1131	 */
1132	if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
1133		xfs_bmap_init(args->flist, args->firstblock);
1134		error = xfs_attr_leaf_to_shortform(bp, args, forkoff);
1135		/* bp is gone due to xfs_da_shrink_inode */
1136		if (!error) {
1137			error = xfs_bmap_finish(&args->trans, args->flist,
1138						&committed);
1139		}
1140		if (error) {
1141			ASSERT(committed);
1142			args->trans = NULL;
1143			xfs_bmap_cancel(args->flist);
1144			return(error);
1145		}
1146
1147		/*
1148		 * bmap_finish() may have committed the last trans and started
1149		 * a new one.  We need the inode to be in all transactions.
1150		 */
1151		if (committed)
1152			xfs_trans_ijoin(args->trans, dp);
1153	} else
1154		xfs_da_buf_done(bp);
1155	return(0);
1156}
1157
1158/*
1159 * Look up a name in a leaf attribute list structure.
1160 *
1161 * This leaf block cannot have a "remote" value, we only call this routine
1162 * if bmap_one_block() says there is only one block (ie: no remote blks).
1163 */
1164STATIC int
1165xfs_attr_leaf_get(xfs_da_args_t *args)
1166{
1167	xfs_dabuf_t *bp;
1168	int error;
1169
1170	args->blkno = 0;
1171	error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp,
1172					     XFS_ATTR_FORK);
1173	if (error)
1174		return(error);
1175	ASSERT(bp != NULL);
1176
1177	error = xfs_attr_leaf_lookup_int(bp, args);
1178	if (error != EEXIST)  {
1179		xfs_da_brelse(args->trans, bp);
1180		return(error);
1181	}
1182	error = xfs_attr_leaf_getvalue(bp, args);
1183	xfs_da_brelse(args->trans, bp);
1184	if (!error && (args->rmtblkno > 0) && !(args->flags & ATTR_KERNOVAL)) {
1185		error = xfs_attr_rmtval_get(args);
1186	}
1187	return(error);
1188}
1189
1190/*
1191 * Copy out attribute entries for attr_list(), for leaf attribute lists.
1192 */
1193STATIC int
1194xfs_attr_leaf_list(xfs_attr_list_context_t *context)
1195{
1196	xfs_attr_leafblock_t *leaf;
1197	int error;
1198	xfs_dabuf_t *bp;
1199
1200	context->cursor->blkno = 0;
1201	error = xfs_da_read_buf(NULL, context->dp, 0, -1, &bp, XFS_ATTR_FORK);
1202	if (error)
1203		return XFS_ERROR(error);
1204	ASSERT(bp != NULL);
1205	leaf = bp->data;
1206	if (unlikely(leaf->hdr.info.magic != cpu_to_be16(XFS_ATTR_LEAF_MAGIC))) {
1207		XFS_CORRUPTION_ERROR("xfs_attr_leaf_list", XFS_ERRLEVEL_LOW,
1208				     context->dp->i_mount, leaf);
1209		xfs_da_brelse(NULL, bp);
1210		return XFS_ERROR(EFSCORRUPTED);
1211	}
1212
1213	error = xfs_attr_leaf_list_int(bp, context);
1214	xfs_da_brelse(NULL, bp);
1215	return XFS_ERROR(error);
1216}
1217
1218
1219/*========================================================================
1220 * External routines when attribute list size > XFS_LBSIZE(mp).
1221 *========================================================================*/
1222
1223/*
1224 * Add a name to a Btree-format attribute list.
1225 *
1226 * This will involve walking down the Btree, and may involve splitting
1227 * leaf nodes and even splitting intermediate nodes up to and including
1228 * the root node (a special case of an intermediate node).
1229 *
1230 * "Remote" attribute values confuse the issue and atomic rename operations
1231 * add a whole extra layer of confusion on top of that.
1232 */
1233STATIC int
1234xfs_attr_node_addname(xfs_da_args_t *args)
1235{
1236	xfs_da_state_t *state;
1237	xfs_da_state_blk_t *blk;
1238	xfs_inode_t *dp;
1239	xfs_mount_t *mp;
1240	int committed, retval, error;
1241
 
 
1242	/*
1243	 * Fill in bucket of arguments/results/context to carry around.
1244	 */
1245	dp = args->dp;
1246	mp = dp->i_mount;
1247restart:
1248	state = xfs_da_state_alloc();
1249	state->args = args;
1250	state->mp = mp;
1251	state->blocksize = state->mp->m_sb.sb_blocksize;
1252	state->node_ents = state->mp->m_attr_node_ents;
1253
1254	/*
1255	 * Search to see if name already exists, and get back a pointer
1256	 * to where it should go.
1257	 */
1258	error = xfs_da_node_lookup_int(state, &retval);
1259	if (error)
1260		goto out;
1261	blk = &state->path.blk[ state->path.active-1 ];
1262	ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
1263	if ((args->flags & ATTR_REPLACE) && (retval == ENOATTR)) {
1264		goto out;
1265	} else if (retval == EEXIST) {
1266		if (args->flags & ATTR_CREATE)
1267			goto out;
 
 
 
1268		args->op_flags |= XFS_DA_OP_RENAME;	/* atomic rename op */
1269		args->blkno2 = args->blkno;		/* set 2nd entry info*/
1270		args->index2 = args->index;
1271		args->rmtblkno2 = args->rmtblkno;
1272		args->rmtblkcnt2 = args->rmtblkcnt;
1273		args->rmtblkno = 0;
1274		args->rmtblkcnt = 0;
1275	}
1276
1277	retval = xfs_attr_leaf_add(blk->bp, state->args);
1278	if (retval == ENOSPC) {
1279		if (state->path.active == 1) {
1280			/*
1281			 * Its really a single leaf node, but it had
1282			 * out-of-line values so it looked like it *might*
1283			 * have been a b-tree.
1284			 */
1285			xfs_da_state_free(state);
1286			xfs_bmap_init(args->flist, args->firstblock);
1287			error = xfs_attr_leaf_to_node(args);
1288			if (!error) {
1289				error = xfs_bmap_finish(&args->trans,
1290							args->flist,
1291							&committed);
1292			}
1293			if (error) {
1294				ASSERT(committed);
1295				args->trans = NULL;
1296				xfs_bmap_cancel(args->flist);
1297				goto out;
1298			}
1299
1300			/*
1301			 * bmap_finish() may have committed the last trans
1302			 * and started a new one.  We need the inode to be
1303			 * in all transactions.
1304			 */
1305			if (committed)
1306				xfs_trans_ijoin(args->trans, dp);
1307
1308			/*
1309			 * Commit the node conversion and start the next
1310			 * trans in the chain.
1311			 */
1312			error = xfs_trans_roll(&args->trans, dp);
1313			if (error)
1314				goto out;
1315
1316			goto restart;
1317		}
1318
1319		/*
1320		 * Split as many Btree elements as required.
1321		 * This code tracks the new and old attr's location
1322		 * in the index/blkno/rmtblkno/rmtblkcnt fields and
1323		 * in the index2/blkno2/rmtblkno2/rmtblkcnt2 fields.
1324		 */
1325		xfs_bmap_init(args->flist, args->firstblock);
1326		error = xfs_da_split(state);
1327		if (!error) {
1328			error = xfs_bmap_finish(&args->trans, args->flist,
1329						&committed);
1330		}
1331		if (error) {
1332			ASSERT(committed);
1333			args->trans = NULL;
1334			xfs_bmap_cancel(args->flist);
1335			goto out;
1336		}
1337
1338		/*
1339		 * bmap_finish() may have committed the last trans and started
1340		 * a new one.  We need the inode to be in all transactions.
1341		 */
1342		if (committed)
1343			xfs_trans_ijoin(args->trans, dp);
1344	} else {
1345		/*
1346		 * Addition succeeded, update Btree hashvals.
1347		 */
1348		xfs_da_fixhashpath(state, &state->path);
1349	}
1350
1351	/*
1352	 * Kill the state structure, we're done with it and need to
1353	 * allow the buffers to come back later.
1354	 */
1355	xfs_da_state_free(state);
1356	state = NULL;
1357
1358	/*
1359	 * Commit the leaf addition or btree split and start the next
1360	 * trans in the chain.
1361	 */
1362	error = xfs_trans_roll(&args->trans, dp);
1363	if (error)
1364		goto out;
1365
1366	/*
1367	 * If there was an out-of-line value, allocate the blocks we
1368	 * identified for its storage and copy the value.  This is done
1369	 * after we create the attribute so that we don't overflow the
1370	 * maximum size of a transaction and/or hit a deadlock.
1371	 */
1372	if (args->rmtblkno > 0) {
1373		error = xfs_attr_rmtval_set(args);
1374		if (error)
1375			return(error);
1376	}
1377
1378	/*
1379	 * If this is an atomic rename operation, we must "flip" the
1380	 * incomplete flags on the "new" and "old" attribute/value pairs
1381	 * so that one disappears and one appears atomically.  Then we
1382	 * must remove the "old" attribute/value pair.
1383	 */
1384	if (args->op_flags & XFS_DA_OP_RENAME) {
1385		/*
1386		 * In a separate transaction, set the incomplete flag on the
1387		 * "old" attr and clear the incomplete flag on the "new" attr.
1388		 */
1389		error = xfs_attr_leaf_flipflags(args);
1390		if (error)
1391			goto out;
1392
1393		/*
1394		 * Dismantle the "old" attribute/value pair by removing
1395		 * a "remote" value (if it exists).
1396		 */
1397		args->index = args->index2;
1398		args->blkno = args->blkno2;
1399		args->rmtblkno = args->rmtblkno2;
1400		args->rmtblkcnt = args->rmtblkcnt2;
1401		if (args->rmtblkno) {
1402			error = xfs_attr_rmtval_remove(args);
1403			if (error)
1404				return(error);
1405		}
1406
1407		/*
1408		 * Re-find the "old" attribute entry after any split ops.
1409		 * The INCOMPLETE flag means that we will find the "old"
1410		 * attr, not the "new" one.
1411		 */
1412		args->flags |= XFS_ATTR_INCOMPLETE;
1413		state = xfs_da_state_alloc();
1414		state->args = args;
1415		state->mp = mp;
1416		state->blocksize = state->mp->m_sb.sb_blocksize;
1417		state->node_ents = state->mp->m_attr_node_ents;
1418		state->inleaf = 0;
1419		error = xfs_da_node_lookup_int(state, &retval);
1420		if (error)
1421			goto out;
1422
1423		/*
1424		 * Remove the name and update the hashvals in the tree.
1425		 */
1426		blk = &state->path.blk[ state->path.active-1 ];
1427		ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
1428		error = xfs_attr_leaf_remove(blk->bp, args);
1429		xfs_da_fixhashpath(state, &state->path);
1430
1431		/*
1432		 * Check to see if the tree needs to be collapsed.
1433		 */
1434		if (retval && (state->path.active > 1)) {
1435			xfs_bmap_init(args->flist, args->firstblock);
1436			error = xfs_da_join(state);
1437			if (!error) {
1438				error = xfs_bmap_finish(&args->trans,
1439							args->flist,
1440							&committed);
1441			}
1442			if (error) {
1443				ASSERT(committed);
1444				args->trans = NULL;
1445				xfs_bmap_cancel(args->flist);
1446				goto out;
1447			}
1448
1449			/*
1450			 * bmap_finish() may have committed the last trans
1451			 * and started a new one.  We need the inode to be
1452			 * in all transactions.
1453			 */
1454			if (committed)
1455				xfs_trans_ijoin(args->trans, dp);
1456		}
1457
1458		/*
1459		 * Commit and start the next trans in the chain.
1460		 */
1461		error = xfs_trans_roll(&args->trans, dp);
1462		if (error)
1463			goto out;
1464
1465	} else if (args->rmtblkno > 0) {
1466		/*
1467		 * Added a "remote" value, just clear the incomplete flag.
1468		 */
1469		error = xfs_attr_leaf_clearflag(args);
1470		if (error)
1471			goto out;
1472	}
1473	retval = error = 0;
1474
1475out:
1476	if (state)
1477		xfs_da_state_free(state);
1478	if (error)
1479		return(error);
1480	return(retval);
1481}
1482
1483/*
1484 * Remove a name from a B-tree attribute list.
1485 *
1486 * This will involve walking down the Btree, and may involve joining
1487 * leaf nodes and even joining intermediate nodes up to and including
1488 * the root node (a special case of an intermediate node).
1489 */
1490STATIC int
1491xfs_attr_node_removename(xfs_da_args_t *args)
1492{
1493	xfs_da_state_t *state;
1494	xfs_da_state_blk_t *blk;
1495	xfs_inode_t *dp;
1496	xfs_dabuf_t *bp;
1497	int retval, error, committed, forkoff;
1498
 
 
1499	/*
1500	 * Tie a string around our finger to remind us where we are.
1501	 */
1502	dp = args->dp;
1503	state = xfs_da_state_alloc();
1504	state->args = args;
1505	state->mp = dp->i_mount;
1506	state->blocksize = state->mp->m_sb.sb_blocksize;
1507	state->node_ents = state->mp->m_attr_node_ents;
1508
1509	/*
1510	 * Search to see if name exists, and get back a pointer to it.
1511	 */
1512	error = xfs_da_node_lookup_int(state, &retval);
1513	if (error || (retval != EEXIST)) {
1514		if (error == 0)
1515			error = retval;
1516		goto out;
1517	}
1518
1519	/*
1520	 * If there is an out-of-line value, de-allocate the blocks.
1521	 * This is done before we remove the attribute so that we don't
1522	 * overflow the maximum size of a transaction and/or hit a deadlock.
1523	 */
1524	blk = &state->path.blk[ state->path.active-1 ];
1525	ASSERT(blk->bp != NULL);
1526	ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
1527	if (args->rmtblkno > 0) {
1528		/*
1529		 * Fill in disk block numbers in the state structure
1530		 * so that we can get the buffers back after we commit
1531		 * several transactions in the following calls.
1532		 */
1533		error = xfs_attr_fillstate(state);
1534		if (error)
1535			goto out;
1536
1537		/*
1538		 * Mark the attribute as INCOMPLETE, then bunmapi() the
1539		 * remote value.
1540		 */
1541		error = xfs_attr_leaf_setflag(args);
1542		if (error)
1543			goto out;
1544		error = xfs_attr_rmtval_remove(args);
1545		if (error)
1546			goto out;
1547
1548		/*
1549		 * Refill the state structure with buffers, the prior calls
1550		 * released our buffers.
1551		 */
1552		error = xfs_attr_refillstate(state);
1553		if (error)
1554			goto out;
1555	}
1556
1557	/*
1558	 * Remove the name and update the hashvals in the tree.
1559	 */
1560	blk = &state->path.blk[ state->path.active-1 ];
1561	ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
1562	retval = xfs_attr_leaf_remove(blk->bp, args);
1563	xfs_da_fixhashpath(state, &state->path);
1564
1565	/*
1566	 * Check to see if the tree needs to be collapsed.
1567	 */
1568	if (retval && (state->path.active > 1)) {
1569		xfs_bmap_init(args->flist, args->firstblock);
1570		error = xfs_da_join(state);
1571		if (!error) {
1572			error = xfs_bmap_finish(&args->trans, args->flist,
1573						&committed);
1574		}
1575		if (error) {
1576			ASSERT(committed);
1577			args->trans = NULL;
1578			xfs_bmap_cancel(args->flist);
1579			goto out;
1580		}
1581
1582		/*
1583		 * bmap_finish() may have committed the last trans and started
1584		 * a new one.  We need the inode to be in all transactions.
1585		 */
1586		if (committed)
1587			xfs_trans_ijoin(args->trans, dp);
1588
1589		/*
1590		 * Commit the Btree join operation and start a new trans.
1591		 */
1592		error = xfs_trans_roll(&args->trans, dp);
1593		if (error)
1594			goto out;
1595	}
1596
1597	/*
1598	 * If the result is small enough, push it all into the inode.
1599	 */
1600	if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
1601		/*
1602		 * Have to get rid of the copy of this dabuf in the state.
1603		 */
1604		ASSERT(state->path.active == 1);
1605		ASSERT(state->path.blk[0].bp);
1606		xfs_da_buf_done(state->path.blk[0].bp);
1607		state->path.blk[0].bp = NULL;
1608
1609		error = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp,
1610						     XFS_ATTR_FORK);
1611		if (error)
1612			goto out;
1613		ASSERT((((xfs_attr_leafblock_t *)bp->data)->hdr.info.magic) ==
1614		       cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1615
1616		if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
1617			xfs_bmap_init(args->flist, args->firstblock);
1618			error = xfs_attr_leaf_to_shortform(bp, args, forkoff);
1619			/* bp is gone due to xfs_da_shrink_inode */
1620			if (!error) {
1621				error = xfs_bmap_finish(&args->trans,
1622							args->flist,
1623							&committed);
1624			}
1625			if (error) {
1626				ASSERT(committed);
1627				args->trans = NULL;
1628				xfs_bmap_cancel(args->flist);
1629				goto out;
1630			}
1631
1632			/*
1633			 * bmap_finish() may have committed the last trans
1634			 * and started a new one.  We need the inode to be
1635			 * in all transactions.
1636			 */
1637			if (committed)
1638				xfs_trans_ijoin(args->trans, dp);
1639		} else
1640			xfs_da_brelse(args->trans, bp);
1641	}
1642	error = 0;
1643
1644out:
1645	xfs_da_state_free(state);
1646	return(error);
1647}
1648
1649/*
1650 * Fill in the disk block numbers in the state structure for the buffers
1651 * that are attached to the state structure.
1652 * This is done so that we can quickly reattach ourselves to those buffers
1653 * after some set of transaction commits have released these buffers.
1654 */
1655STATIC int
1656xfs_attr_fillstate(xfs_da_state_t *state)
1657{
1658	xfs_da_state_path_t *path;
1659	xfs_da_state_blk_t *blk;
1660	int level;
1661
1662	/*
1663	 * Roll down the "path" in the state structure, storing the on-disk
1664	 * block number for those buffers in the "path".
1665	 */
1666	path = &state->path;
1667	ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
1668	for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
1669		if (blk->bp) {
1670			blk->disk_blkno = xfs_da_blkno(blk->bp);
1671			xfs_da_buf_done(blk->bp);
1672			blk->bp = NULL;
1673		} else {
1674			blk->disk_blkno = 0;
1675		}
1676	}
1677
1678	/*
1679	 * Roll down the "altpath" in the state structure, storing the on-disk
1680	 * block number for those buffers in the "altpath".
1681	 */
1682	path = &state->altpath;
1683	ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
1684	for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
1685		if (blk->bp) {
1686			blk->disk_blkno = xfs_da_blkno(blk->bp);
1687			xfs_da_buf_done(blk->bp);
1688			blk->bp = NULL;
1689		} else {
1690			blk->disk_blkno = 0;
1691		}
1692	}
1693
1694	return(0);
1695}
1696
1697/*
1698 * Reattach the buffers to the state structure based on the disk block
1699 * numbers stored in the state structure.
1700 * This is done after some set of transaction commits have released those
1701 * buffers from our grip.
1702 */
1703STATIC int
1704xfs_attr_refillstate(xfs_da_state_t *state)
1705{
1706	xfs_da_state_path_t *path;
1707	xfs_da_state_blk_t *blk;
1708	int level, error;
1709
1710	/*
1711	 * Roll down the "path" in the state structure, storing the on-disk
1712	 * block number for those buffers in the "path".
1713	 */
1714	path = &state->path;
1715	ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
1716	for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
1717		if (blk->disk_blkno) {
1718			error = xfs_da_read_buf(state->args->trans,
1719						state->args->dp,
1720						blk->blkno, blk->disk_blkno,
1721						&blk->bp, XFS_ATTR_FORK);
1722			if (error)
1723				return(error);
1724		} else {
1725			blk->bp = NULL;
1726		}
1727	}
1728
1729	/*
1730	 * Roll down the "altpath" in the state structure, storing the on-disk
1731	 * block number for those buffers in the "altpath".
1732	 */
1733	path = &state->altpath;
1734	ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
1735	for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
1736		if (blk->disk_blkno) {
1737			error = xfs_da_read_buf(state->args->trans,
1738						state->args->dp,
1739						blk->blkno, blk->disk_blkno,
1740						&blk->bp, XFS_ATTR_FORK);
1741			if (error)
1742				return(error);
1743		} else {
1744			blk->bp = NULL;
1745		}
1746	}
1747
1748	return(0);
1749}
1750
1751/*
1752 * Look up a filename in a node attribute list.
1753 *
1754 * This routine gets called for any attribute fork that has more than one
1755 * block, ie: both true Btree attr lists and for single-leaf-blocks with
1756 * "remote" values taking up more blocks.
1757 */
1758STATIC int
1759xfs_attr_node_get(xfs_da_args_t *args)
1760{
1761	xfs_da_state_t *state;
1762	xfs_da_state_blk_t *blk;
1763	int error, retval;
1764	int i;
1765
1766	state = xfs_da_state_alloc();
1767	state->args = args;
1768	state->mp = args->dp->i_mount;
1769	state->blocksize = state->mp->m_sb.sb_blocksize;
1770	state->node_ents = state->mp->m_attr_node_ents;
1771
1772	/*
1773	 * Search to see if name exists, and get back a pointer to it.
1774	 */
1775	error = xfs_da_node_lookup_int(state, &retval);
1776	if (error) {
1777		retval = error;
1778	} else if (retval == EEXIST) {
1779		blk = &state->path.blk[ state->path.active-1 ];
1780		ASSERT(blk->bp != NULL);
1781		ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
1782
1783		/*
1784		 * Get the value, local or "remote"
1785		 */
1786		retval = xfs_attr_leaf_getvalue(blk->bp, args);
1787		if (!retval && (args->rmtblkno > 0)
1788		    && !(args->flags & ATTR_KERNOVAL)) {
1789			retval = xfs_attr_rmtval_get(args);
1790		}
1791	}
1792
1793	/*
1794	 * If not in a transaction, we have to release all the buffers.
1795	 */
1796	for (i = 0; i < state->path.active; i++) {
1797		xfs_da_brelse(args->trans, state->path.blk[i].bp);
1798		state->path.blk[i].bp = NULL;
1799	}
1800
1801	xfs_da_state_free(state);
1802	return(retval);
1803}
1804
1805STATIC int							/* error */
1806xfs_attr_node_list(xfs_attr_list_context_t *context)
1807{
1808	attrlist_cursor_kern_t *cursor;
1809	xfs_attr_leafblock_t *leaf;
1810	xfs_da_intnode_t *node;
1811	xfs_da_node_entry_t *btree;
1812	int error, i;
1813	xfs_dabuf_t *bp;
1814
1815	cursor = context->cursor;
1816	cursor->initted = 1;
1817
1818	/*
1819	 * Do all sorts of validation on the passed-in cursor structure.
1820	 * If anything is amiss, ignore the cursor and look up the hashval
1821	 * starting from the btree root.
1822	 */
1823	bp = NULL;
1824	if (cursor->blkno > 0) {
1825		error = xfs_da_read_buf(NULL, context->dp, cursor->blkno, -1,
1826					      &bp, XFS_ATTR_FORK);
1827		if ((error != 0) && (error != EFSCORRUPTED))
1828			return(error);
1829		if (bp) {
1830			node = bp->data;
1831			switch (be16_to_cpu(node->hdr.info.magic)) {
1832			case XFS_DA_NODE_MAGIC:
1833				trace_xfs_attr_list_wrong_blk(context);
1834				xfs_da_brelse(NULL, bp);
1835				bp = NULL;
1836				break;
1837			case XFS_ATTR_LEAF_MAGIC:
1838				leaf = bp->data;
1839				if (cursor->hashval > be32_to_cpu(leaf->entries[
1840				    be16_to_cpu(leaf->hdr.count)-1].hashval)) {
1841					trace_xfs_attr_list_wrong_blk(context);
1842					xfs_da_brelse(NULL, bp);
1843					bp = NULL;
1844				} else if (cursor->hashval <=
1845					     be32_to_cpu(leaf->entries[0].hashval)) {
1846					trace_xfs_attr_list_wrong_blk(context);
1847					xfs_da_brelse(NULL, bp);
1848					bp = NULL;
1849				}
1850				break;
1851			default:
1852				trace_xfs_attr_list_wrong_blk(context);
1853				xfs_da_brelse(NULL, bp);
1854				bp = NULL;
1855			}
1856		}
1857	}
1858
1859	/*
1860	 * We did not find what we expected given the cursor's contents,
1861	 * so we start from the top and work down based on the hash value.
1862	 * Note that start of node block is same as start of leaf block.
1863	 */
1864	if (bp == NULL) {
1865		cursor->blkno = 0;
1866		for (;;) {
1867			error = xfs_da_read_buf(NULL, context->dp,
1868						      cursor->blkno, -1, &bp,
1869						      XFS_ATTR_FORK);
1870			if (error)
1871				return(error);
1872			if (unlikely(bp == NULL)) {
1873				XFS_ERROR_REPORT("xfs_attr_node_list(2)",
1874						 XFS_ERRLEVEL_LOW,
1875						 context->dp->i_mount);
1876				return(XFS_ERROR(EFSCORRUPTED));
1877			}
1878			node = bp->data;
1879			if (node->hdr.info.magic ==
1880			    cpu_to_be16(XFS_ATTR_LEAF_MAGIC))
1881				break;
1882			if (unlikely(node->hdr.info.magic !=
1883				     cpu_to_be16(XFS_DA_NODE_MAGIC))) {
1884				XFS_CORRUPTION_ERROR("xfs_attr_node_list(3)",
1885						     XFS_ERRLEVEL_LOW,
1886						     context->dp->i_mount,
1887						     node);
1888				xfs_da_brelse(NULL, bp);
1889				return(XFS_ERROR(EFSCORRUPTED));
1890			}
1891			btree = node->btree;
1892			for (i = 0; i < be16_to_cpu(node->hdr.count);
1893								btree++, i++) {
1894				if (cursor->hashval
1895						<= be32_to_cpu(btree->hashval)) {
1896					cursor->blkno = be32_to_cpu(btree->before);
1897					trace_xfs_attr_list_node_descend(context,
1898									 btree);
1899					break;
1900				}
1901			}
1902			if (i == be16_to_cpu(node->hdr.count)) {
1903				xfs_da_brelse(NULL, bp);
1904				return(0);
1905			}
1906			xfs_da_brelse(NULL, bp);
1907		}
1908	}
1909	ASSERT(bp != NULL);
1910
1911	/*
1912	 * Roll upward through the blocks, processing each leaf block in
1913	 * order.  As long as there is space in the result buffer, keep
1914	 * adding the information.
1915	 */
1916	for (;;) {
1917		leaf = bp->data;
1918		if (unlikely(leaf->hdr.info.magic !=
1919			     cpu_to_be16(XFS_ATTR_LEAF_MAGIC))) {
1920			XFS_CORRUPTION_ERROR("xfs_attr_node_list(4)",
1921					     XFS_ERRLEVEL_LOW,
1922					     context->dp->i_mount, leaf);
1923			xfs_da_brelse(NULL, bp);
1924			return(XFS_ERROR(EFSCORRUPTED));
1925		}
1926		error = xfs_attr_leaf_list_int(bp, context);
1927		if (error) {
1928			xfs_da_brelse(NULL, bp);
1929			return error;
1930		}
1931		if (context->seen_enough || leaf->hdr.info.forw == 0)
1932			break;
1933		cursor->blkno = be32_to_cpu(leaf->hdr.info.forw);
1934		xfs_da_brelse(NULL, bp);
1935		error = xfs_da_read_buf(NULL, context->dp, cursor->blkno, -1,
1936					      &bp, XFS_ATTR_FORK);
1937		if (error)
1938			return(error);
1939		if (unlikely((bp == NULL))) {
1940			XFS_ERROR_REPORT("xfs_attr_node_list(5)",
1941					 XFS_ERRLEVEL_LOW,
1942					 context->dp->i_mount);
1943			return(XFS_ERROR(EFSCORRUPTED));
1944		}
1945	}
1946	xfs_da_brelse(NULL, bp);
1947	return(0);
1948}
1949
1950
1951/*========================================================================
1952 * External routines for manipulating out-of-line attribute values.
1953 *========================================================================*/
1954
1955/*
1956 * Read the value associated with an attribute from the out-of-line buffer
1957 * that we stored it in.
1958 */
1959int
1960xfs_attr_rmtval_get(xfs_da_args_t *args)
1961{
1962	xfs_bmbt_irec_t map[ATTR_RMTVALUE_MAPSIZE];
1963	xfs_mount_t *mp;
1964	xfs_daddr_t dblkno;
1965	void *dst;
1966	xfs_buf_t *bp;
1967	int nmap, error, tmp, valuelen, blkcnt, i;
1968	xfs_dablk_t lblkno;
1969
1970	ASSERT(!(args->flags & ATTR_KERNOVAL));
1971
1972	mp = args->dp->i_mount;
1973	dst = args->value;
1974	valuelen = args->valuelen;
1975	lblkno = args->rmtblkno;
1976	while (valuelen > 0) {
1977		nmap = ATTR_RMTVALUE_MAPSIZE;
1978		error = xfs_bmapi(args->trans, args->dp, (xfs_fileoff_t)lblkno,
1979				  args->rmtblkcnt,
1980				  XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA,
1981				  NULL, 0, map, &nmap, NULL);
1982		if (error)
1983			return(error);
1984		ASSERT(nmap >= 1);
1985
1986		for (i = 0; (i < nmap) && (valuelen > 0); i++) {
1987			ASSERT((map[i].br_startblock != DELAYSTARTBLOCK) &&
1988			       (map[i].br_startblock != HOLESTARTBLOCK));
1989			dblkno = XFS_FSB_TO_DADDR(mp, map[i].br_startblock);
1990			blkcnt = XFS_FSB_TO_BB(mp, map[i].br_blockcount);
1991			error = xfs_read_buf(mp, mp->m_ddev_targp, dblkno,
1992					     blkcnt, XBF_LOCK | XBF_DONT_BLOCK,
1993					     &bp);
1994			if (error)
1995				return(error);
1996
1997			tmp = (valuelen < XFS_BUF_SIZE(bp))
1998				? valuelen : XFS_BUF_SIZE(bp);
1999			xfs_buf_iomove(bp, 0, tmp, dst, XBRW_READ);
2000			xfs_buf_relse(bp);
2001			dst += tmp;
2002			valuelen -= tmp;
2003
2004			lblkno += map[i].br_blockcount;
2005		}
2006	}
2007	ASSERT(valuelen == 0);
2008	return(0);
2009}
2010
2011/*
2012 * Write the value associated with an attribute into the out-of-line buffer
2013 * that we have defined for it.
2014 */
2015STATIC int
2016xfs_attr_rmtval_set(xfs_da_args_t *args)
2017{
2018	xfs_mount_t *mp;
2019	xfs_fileoff_t lfileoff;
2020	xfs_inode_t *dp;
2021	xfs_bmbt_irec_t map;
2022	xfs_daddr_t dblkno;
2023	void *src;
2024	xfs_buf_t *bp;
2025	xfs_dablk_t lblkno;
2026	int blkcnt, valuelen, nmap, error, tmp, committed;
2027
2028	dp = args->dp;
2029	mp = dp->i_mount;
2030	src = args->value;
2031
2032	/*
2033	 * Find a "hole" in the attribute address space large enough for
2034	 * us to drop the new attribute's value into.
2035	 */
2036	blkcnt = XFS_B_TO_FSB(mp, args->valuelen);
2037	lfileoff = 0;
2038	error = xfs_bmap_first_unused(args->trans, args->dp, blkcnt, &lfileoff,
2039						   XFS_ATTR_FORK);
2040	if (error) {
2041		return(error);
2042	}
2043	args->rmtblkno = lblkno = (xfs_dablk_t)lfileoff;
2044	args->rmtblkcnt = blkcnt;
2045
2046	/*
2047	 * Roll through the "value", allocating blocks on disk as required.
2048	 */
2049	while (blkcnt > 0) {
2050		/*
2051		 * Allocate a single extent, up to the size of the value.
2052		 */
2053		xfs_bmap_init(args->flist, args->firstblock);
2054		nmap = 1;
2055		error = xfs_bmapi(args->trans, dp, (xfs_fileoff_t)lblkno,
2056				  blkcnt,
2057				  XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA |
2058							XFS_BMAPI_WRITE,
2059				  args->firstblock, args->total, &map, &nmap,
2060				  args->flist);
2061		if (!error) {
2062			error = xfs_bmap_finish(&args->trans, args->flist,
2063						&committed);
2064		}
2065		if (error) {
2066			ASSERT(committed);
2067			args->trans = NULL;
2068			xfs_bmap_cancel(args->flist);
2069			return(error);
2070		}
2071
2072		/*
2073		 * bmap_finish() may have committed the last trans and started
2074		 * a new one.  We need the inode to be in all transactions.
2075		 */
2076		if (committed)
2077			xfs_trans_ijoin(args->trans, dp);
2078
2079		ASSERT(nmap == 1);
2080		ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
2081		       (map.br_startblock != HOLESTARTBLOCK));
2082		lblkno += map.br_blockcount;
2083		blkcnt -= map.br_blockcount;
2084
2085		/*
2086		 * Start the next trans in the chain.
2087		 */
2088		error = xfs_trans_roll(&args->trans, dp);
2089		if (error)
2090			return (error);
2091	}
2092
2093	/*
2094	 * Roll through the "value", copying the attribute value to the
2095	 * already-allocated blocks.  Blocks are written synchronously
2096	 * so that we can know they are all on disk before we turn off
2097	 * the INCOMPLETE flag.
2098	 */
2099	lblkno = args->rmtblkno;
2100	valuelen = args->valuelen;
2101	while (valuelen > 0) {
 
 
2102		/*
2103		 * Try to remember where we decided to put the value.
2104		 */
2105		xfs_bmap_init(args->flist, args->firstblock);
2106		nmap = 1;
2107		error = xfs_bmapi(NULL, dp, (xfs_fileoff_t)lblkno,
2108				  args->rmtblkcnt,
2109				  XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA,
2110				  args->firstblock, 0, &map, &nmap,
2111				  NULL);
2112		if (error) {
2113			return(error);
2114		}
2115		ASSERT(nmap == 1);
2116		ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
2117		       (map.br_startblock != HOLESTARTBLOCK));
2118
2119		dblkno = XFS_FSB_TO_DADDR(mp, map.br_startblock),
2120		blkcnt = XFS_FSB_TO_BB(mp, map.br_blockcount);
2121
2122		bp = xfs_buf_get(mp->m_ddev_targp, dblkno, blkcnt,
2123				 XBF_LOCK | XBF_DONT_BLOCK);
2124		ASSERT(!xfs_buf_geterror(bp));
2125
2126		tmp = (valuelen < XFS_BUF_SIZE(bp)) ? valuelen :
2127							XFS_BUF_SIZE(bp);
2128		xfs_buf_iomove(bp, 0, tmp, src, XBRW_WRITE);
2129		if (tmp < XFS_BUF_SIZE(bp))
2130			xfs_buf_zero(bp, tmp, XFS_BUF_SIZE(bp) - tmp);
2131		if ((error = xfs_bwrite(mp, bp))) {/* GROT: NOTE: synchronous write */
2132			return (error);
2133		}
 
 
2134		src += tmp;
2135		valuelen -= tmp;
2136
2137		lblkno += map.br_blockcount;
2138	}
2139	ASSERT(valuelen == 0);
2140	return(0);
2141}
2142
2143/*
2144 * Remove the value associated with an attribute by deleting the
2145 * out-of-line buffer that it is stored on.
2146 */
2147STATIC int
2148xfs_attr_rmtval_remove(xfs_da_args_t *args)
2149{
2150	xfs_mount_t *mp;
2151	xfs_bmbt_irec_t map;
2152	xfs_buf_t *bp;
2153	xfs_daddr_t dblkno;
2154	xfs_dablk_t lblkno;
2155	int valuelen, blkcnt, nmap, error, done, committed;
2156
2157	mp = args->dp->i_mount;
2158
2159	/*
2160	 * Roll through the "value", invalidating the attribute value's
2161	 * blocks.
2162	 */
2163	lblkno = args->rmtblkno;
2164	valuelen = args->rmtblkcnt;
2165	while (valuelen > 0) {
2166		/*
2167		 * Try to remember where we decided to put the value.
2168		 */
2169		xfs_bmap_init(args->flist, args->firstblock);
2170		nmap = 1;
2171		error = xfs_bmapi(NULL, args->dp, (xfs_fileoff_t)lblkno,
2172					args->rmtblkcnt,
2173					XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA,
2174					args->firstblock, 0, &map, &nmap,
2175					args->flist);
2176		if (error) {
2177			return(error);
2178		}
2179		ASSERT(nmap == 1);
2180		ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
2181		       (map.br_startblock != HOLESTARTBLOCK));
2182
2183		dblkno = XFS_FSB_TO_DADDR(mp, map.br_startblock),
2184		blkcnt = XFS_FSB_TO_BB(mp, map.br_blockcount);
2185
2186		/*
2187		 * If the "remote" value is in the cache, remove it.
2188		 */
2189		bp = xfs_incore(mp->m_ddev_targp, dblkno, blkcnt, XBF_TRYLOCK);
2190		if (bp) {
2191			XFS_BUF_STALE(bp);
2192			XFS_BUF_UNDELAYWRITE(bp);
2193			xfs_buf_relse(bp);
2194			bp = NULL;
2195		}
2196
2197		valuelen -= map.br_blockcount;
2198
2199		lblkno += map.br_blockcount;
2200	}
2201
2202	/*
2203	 * Keep de-allocating extents until the remote-value region is gone.
2204	 */
2205	lblkno = args->rmtblkno;
2206	blkcnt = args->rmtblkcnt;
2207	done = 0;
2208	while (!done) {
2209		xfs_bmap_init(args->flist, args->firstblock);
2210		error = xfs_bunmapi(args->trans, args->dp, lblkno, blkcnt,
2211				    XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA,
2212				    1, args->firstblock, args->flist,
2213				    &done);
2214		if (!error) {
2215			error = xfs_bmap_finish(&args->trans, args->flist,
2216						&committed);
2217		}
2218		if (error) {
2219			ASSERT(committed);
2220			args->trans = NULL;
2221			xfs_bmap_cancel(args->flist);
2222			return(error);
2223		}
2224
2225		/*
2226		 * bmap_finish() may have committed the last trans and started
2227		 * a new one.  We need the inode to be in all transactions.
2228		 */
2229		if (committed)
2230			xfs_trans_ijoin(args->trans, args->dp);
2231
2232		/*
2233		 * Close out trans and start the next one in the chain.
2234		 */
2235		error = xfs_trans_roll(&args->trans, args->dp);
2236		if (error)
2237			return (error);
2238	}
2239	return(0);
2240}