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 err2 = xfs_trans_commit(args.trans, 359 XFS_TRANS_RELEASE_LOG_RES); 360 xfs_iunlock(dp, XFS_ILOCK_EXCL); 361 362 /* 363 * Hit the inode change time. 364 */ 365 if (!error && (flags & ATTR_KERNOTIME) == 0) { 366 xfs_ichgtime(dp, XFS_ICHGTIME_CHG); 367 } 368 return(error == 0 ? err2 : error); 369 } 370 371 /* 372 * It won't fit in the shortform, transform to a leaf block. 373 * GROT: another possible req'mt for a double-split btree op. 374 */ 375 xfs_bmap_init(args.flist, args.firstblock); 376 error = xfs_attr_shortform_to_leaf(&args); 377 if (!error) { 378 error = xfs_bmap_finish(&args.trans, args.flist, 379 &committed); 380 } 381 if (error) { 382 ASSERT(committed); 383 args.trans = NULL; 384 xfs_bmap_cancel(&flist); 385 goto out; 386 } 387 388 /* 389 * bmap_finish() may have committed the last trans and started 390 * a new one. We need the inode to be in all transactions. 391 */ 392 if (committed) 393 xfs_trans_ijoin(args.trans, dp); 394 395 /* 396 * Commit the leaf transformation. We'll need another (linked) 397 * transaction to add the new attribute to the leaf. 398 */ 399 400 error = xfs_trans_roll(&args.trans, dp); 401 if (error) 402 goto out; 403 404 } 405 406 if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) { 407 error = xfs_attr_leaf_addname(&args); 408 } else { 409 error = xfs_attr_node_addname(&args); 410 } 411 if (error) { 412 goto out; 413 } 414 415 /* 416 * If this is a synchronous mount, make sure that the 417 * transaction goes to disk before returning to the user. 418 */ 419 if (mp->m_flags & XFS_MOUNT_WSYNC) { 420 xfs_trans_set_sync(args.trans); 421 } 422 423 /* 424 * Commit the last in the sequence of transactions. 425 */ 426 xfs_trans_log_inode(args.trans, dp, XFS_ILOG_CORE); 427 error = xfs_trans_commit(args.trans, XFS_TRANS_RELEASE_LOG_RES); 428 xfs_iunlock(dp, XFS_ILOCK_EXCL); 429 430 /* 431 * Hit the inode change time. 432 */ 433 if (!error && (flags & ATTR_KERNOTIME) == 0) { 434 xfs_ichgtime(dp, XFS_ICHGTIME_CHG); 435 } 436 437 return(error); 438 439out: 440 if (args.trans) 441 xfs_trans_cancel(args.trans, 442 XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT); 443 xfs_iunlock(dp, XFS_ILOCK_EXCL); 444 return(error); 445} 446 447int 448xfs_attr_set( 449 xfs_inode_t *dp, 450 const unsigned char *name, 451 unsigned char *value, 452 int valuelen, 453 int flags) 454{ 455 int error; 456 struct xfs_name xname; 457 458 XFS_STATS_INC(xs_attr_set); 459 460 if (XFS_FORCED_SHUTDOWN(dp->i_mount)) 461 return (EIO); 462 463 error = xfs_attr_name_to_xname(&xname, name); 464 if (error) 465 return error; 466 467 return xfs_attr_set_int(dp, &xname, value, valuelen, flags); 468} 469 470/* 471 * Generic handler routine to remove a name from an attribute list. 472 * Transitions attribute list from Btree to shortform as necessary. 473 */ 474STATIC int 475xfs_attr_remove_int(xfs_inode_t *dp, struct xfs_name *name, int flags) 476{ 477 xfs_da_args_t args; 478 xfs_fsblock_t firstblock; 479 xfs_bmap_free_t flist; 480 int error; 481 xfs_mount_t *mp = dp->i_mount; 482 483 /* 484 * Fill in the arg structure for this request. 485 */ 486 memset((char *)&args, 0, sizeof(args)); 487 args.name = name->name; 488 args.namelen = name->len; 489 args.flags = flags; 490 args.hashval = xfs_da_hashname(args.name, args.namelen); 491 args.dp = dp; 492 args.firstblock = &firstblock; 493 args.flist = &flist; 494 args.total = 0; 495 args.whichfork = XFS_ATTR_FORK; 496 497 /* 498 * Attach the dquots to the inode. 499 */ 500 error = xfs_qm_dqattach(dp, 0); 501 if (error) 502 return error; 503 504 /* 505 * Start our first transaction of the day. 506 * 507 * All future transactions during this code must be "chained" off 508 * this one via the trans_dup() call. All transactions will contain 509 * the inode, and the inode will always be marked with trans_ihold(). 510 * Since the inode will be locked in all transactions, we must log 511 * the inode in every transaction to let it float upward through 512 * the log. 513 */ 514 args.trans = xfs_trans_alloc(mp, XFS_TRANS_ATTR_RM); 515 516 /* 517 * Root fork attributes can use reserved data blocks for this 518 * operation if necessary 519 */ 520 521 if (flags & ATTR_ROOT) 522 args.trans->t_flags |= XFS_TRANS_RESERVE; 523 524 if ((error = xfs_trans_reserve(args.trans, 525 XFS_ATTRRM_SPACE_RES(mp), 526 XFS_ATTRRM_LOG_RES(mp), 527 0, XFS_TRANS_PERM_LOG_RES, 528 XFS_ATTRRM_LOG_COUNT))) { 529 xfs_trans_cancel(args.trans, 0); 530 return(error); 531 } 532 533 xfs_ilock(dp, XFS_ILOCK_EXCL); 534 /* 535 * No need to make quota reservations here. We expect to release some 536 * blocks not allocate in the common case. 537 */ 538 xfs_trans_ijoin(args.trans, dp); 539 540 /* 541 * Decide on what work routines to call based on the inode size. 542 */ 543 if (!xfs_inode_hasattr(dp)) { 544 error = XFS_ERROR(ENOATTR); 545 goto out; 546 } 547 if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) { 548 ASSERT(dp->i_afp->if_flags & XFS_IFINLINE); 549 error = xfs_attr_shortform_remove(&args); 550 if (error) { 551 goto out; 552 } 553 } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) { 554 error = xfs_attr_leaf_removename(&args); 555 } else { 556 error = xfs_attr_node_removename(&args); 557 } 558 if (error) { 559 goto out; 560 } 561 562 /* 563 * If this is a synchronous mount, make sure that the 564 * transaction goes to disk before returning to the user. 565 */ 566 if (mp->m_flags & XFS_MOUNT_WSYNC) { 567 xfs_trans_set_sync(args.trans); 568 } 569 570 /* 571 * Commit the last in the sequence of transactions. 572 */ 573 xfs_trans_log_inode(args.trans, dp, XFS_ILOG_CORE); 574 error = xfs_trans_commit(args.trans, XFS_TRANS_RELEASE_LOG_RES); 575 xfs_iunlock(dp, XFS_ILOCK_EXCL); 576 577 /* 578 * Hit the inode change time. 579 */ 580 if (!error && (flags & ATTR_KERNOTIME) == 0) { 581 xfs_ichgtime(dp, XFS_ICHGTIME_CHG); 582 } 583 584 return(error); 585 586out: 587 if (args.trans) 588 xfs_trans_cancel(args.trans, 589 XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT); 590 xfs_iunlock(dp, XFS_ILOCK_EXCL); 591 return(error); 592} 593 594int 595xfs_attr_remove( 596 xfs_inode_t *dp, 597 const unsigned char *name, 598 int flags) 599{ 600 int error; 601 struct xfs_name xname; 602 603 XFS_STATS_INC(xs_attr_remove); 604 605 if (XFS_FORCED_SHUTDOWN(dp->i_mount)) 606 return (EIO); 607 608 error = xfs_attr_name_to_xname(&xname, name); 609 if (error) 610 return error; 611 612 xfs_ilock(dp, XFS_ILOCK_SHARED); 613 if (!xfs_inode_hasattr(dp)) { 614 xfs_iunlock(dp, XFS_ILOCK_SHARED); 615 return XFS_ERROR(ENOATTR); 616 } 617 xfs_iunlock(dp, XFS_ILOCK_SHARED); 618 619 return xfs_attr_remove_int(dp, &xname, flags); 620} 621 622int 623xfs_attr_list_int(xfs_attr_list_context_t *context) 624{ 625 int error; 626 xfs_inode_t *dp = context->dp; 627 628 XFS_STATS_INC(xs_attr_list); 629 630 if (XFS_FORCED_SHUTDOWN(dp->i_mount)) 631 return EIO; 632 633 xfs_ilock(dp, XFS_ILOCK_SHARED); 634 635 /* 636 * Decide on what work routines to call based on the inode size. 637 */ 638 if (!xfs_inode_hasattr(dp)) { 639 error = 0; 640 } else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) { 641 error = xfs_attr_shortform_list(context); 642 } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) { 643 error = xfs_attr_leaf_list(context); 644 } else { 645 error = xfs_attr_node_list(context); 646 } 647 648 xfs_iunlock(dp, XFS_ILOCK_SHARED); 649 650 return error; 651} 652 653#define ATTR_ENTBASESIZE /* minimum bytes used by an attr */ \ 654 (((struct attrlist_ent *) 0)->a_name - (char *) 0) 655#define ATTR_ENTSIZE(namelen) /* actual bytes used by an attr */ \ 656 ((ATTR_ENTBASESIZE + (namelen) + 1 + sizeof(u_int32_t)-1) \ 657 & ~(sizeof(u_int32_t)-1)) 658 659/* 660 * Format an attribute and copy it out to the user's buffer. 661 * Take care to check values and protect against them changing later, 662 * we may be reading them directly out of a user buffer. 663 */ 664/*ARGSUSED*/ 665STATIC int 666xfs_attr_put_listent( 667 xfs_attr_list_context_t *context, 668 int flags, 669 unsigned char *name, 670 int namelen, 671 int valuelen, 672 unsigned char *value) 673{ 674 struct attrlist *alist = (struct attrlist *)context->alist; 675 attrlist_ent_t *aep; 676 int arraytop; 677 678 ASSERT(!(context->flags & ATTR_KERNOVAL)); 679 ASSERT(context->count >= 0); 680 ASSERT(context->count < (ATTR_MAX_VALUELEN/8)); 681 ASSERT(context->firstu >= sizeof(*alist)); 682 ASSERT(context->firstu <= context->bufsize); 683 684 /* 685 * Only list entries in the right namespace. 686 */ 687 if (((context->flags & ATTR_SECURE) == 0) != 688 ((flags & XFS_ATTR_SECURE) == 0)) 689 return 0; 690 if (((context->flags & ATTR_ROOT) == 0) != 691 ((flags & XFS_ATTR_ROOT) == 0)) 692 return 0; 693 694 arraytop = sizeof(*alist) + 695 context->count * sizeof(alist->al_offset[0]); 696 context->firstu -= ATTR_ENTSIZE(namelen); 697 if (context->firstu < arraytop) { 698 trace_xfs_attr_list_full(context); 699 alist->al_more = 1; 700 context->seen_enough = 1; 701 return 1; 702 } 703 704 aep = (attrlist_ent_t *)&context->alist[context->firstu]; 705 aep->a_valuelen = valuelen; 706 memcpy(aep->a_name, name, namelen); 707 aep->a_name[namelen] = 0; 708 alist->al_offset[context->count++] = context->firstu; 709 alist->al_count = context->count; 710 trace_xfs_attr_list_add(context); 711 return 0; 712} 713 714/* 715 * Generate a list of extended attribute names and optionally 716 * also value lengths. Positive return value follows the XFS 717 * convention of being an error, zero or negative return code 718 * is the length of the buffer returned (negated), indicating 719 * success. 720 */ 721int 722xfs_attr_list( 723 xfs_inode_t *dp, 724 char *buffer, 725 int bufsize, 726 int flags, 727 attrlist_cursor_kern_t *cursor) 728{ 729 xfs_attr_list_context_t context; 730 struct attrlist *alist; 731 int error; 732 733 /* 734 * Validate the cursor. 735 */ 736 if (cursor->pad1 || cursor->pad2) 737 return(XFS_ERROR(EINVAL)); 738 if ((cursor->initted == 0) && 739 (cursor->hashval || cursor->blkno || cursor->offset)) 740 return XFS_ERROR(EINVAL); 741 742 /* 743 * Check for a properly aligned buffer. 744 */ 745 if (((long)buffer) & (sizeof(int)-1)) 746 return XFS_ERROR(EFAULT); 747 if (flags & ATTR_KERNOVAL) 748 bufsize = 0; 749 750 /* 751 * Initialize the output buffer. 752 */ 753 memset(&context, 0, sizeof(context)); 754 context.dp = dp; 755 context.cursor = cursor; 756 context.resynch = 1; 757 context.flags = flags; 758 context.alist = buffer; 759 context.bufsize = (bufsize & ~(sizeof(int)-1)); /* align */ 760 context.firstu = context.bufsize; 761 context.put_listent = xfs_attr_put_listent; 762 763 alist = (struct attrlist *)context.alist; 764 alist->al_count = 0; 765 alist->al_more = 0; 766 alist->al_offset[0] = context.bufsize; 767 768 error = xfs_attr_list_int(&context); 769 ASSERT(error >= 0); 770 return error; 771} 772 773int /* error */ 774xfs_attr_inactive(xfs_inode_t *dp) 775{ 776 xfs_trans_t *trans; 777 xfs_mount_t *mp; 778 int error; 779 780 mp = dp->i_mount; 781 ASSERT(! XFS_NOT_DQATTACHED(mp, dp)); 782 783 xfs_ilock(dp, XFS_ILOCK_SHARED); 784 if (!xfs_inode_hasattr(dp) || 785 dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) { 786 xfs_iunlock(dp, XFS_ILOCK_SHARED); 787 return 0; 788 } 789 xfs_iunlock(dp, XFS_ILOCK_SHARED); 790 791 /* 792 * Start our first transaction of the day. 793 * 794 * All future transactions during this code must be "chained" off 795 * this one via the trans_dup() call. All transactions will contain 796 * the inode, and the inode will always be marked with trans_ihold(). 797 * Since the inode will be locked in all transactions, we must log 798 * the inode in every transaction to let it float upward through 799 * the log. 800 */ 801 trans = xfs_trans_alloc(mp, XFS_TRANS_ATTRINVAL); 802 if ((error = xfs_trans_reserve(trans, 0, XFS_ATTRINVAL_LOG_RES(mp), 0, 803 XFS_TRANS_PERM_LOG_RES, 804 XFS_ATTRINVAL_LOG_COUNT))) { 805 xfs_trans_cancel(trans, 0); 806 return(error); 807 } 808 xfs_ilock(dp, XFS_ILOCK_EXCL); 809 810 /* 811 * No need to make quota reservations here. We expect to release some 812 * blocks, not allocate, in the common case. 813 */ 814 xfs_trans_ijoin(trans, dp); 815 816 /* 817 * Decide on what work routines to call based on the inode size. 818 */ 819 if (!xfs_inode_hasattr(dp) || 820 dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) { 821 error = 0; 822 goto out; 823 } 824 error = xfs_attr_root_inactive(&trans, dp); 825 if (error) 826 goto out; 827 /* 828 * signal synchronous inactive transactions unless this 829 * is a synchronous mount filesystem in which case we 830 * know that we're here because we've been called out of 831 * xfs_inactive which means that the last reference is gone 832 * and the unlink transaction has already hit the disk so 833 * async inactive transactions are safe. 834 */ 835 if ((error = xfs_itruncate_finish(&trans, dp, 0LL, XFS_ATTR_FORK, 836 (!(mp->m_flags & XFS_MOUNT_WSYNC) 837 ? 1 : 0)))) 838 goto out; 839 840 /* 841 * Commit the last in the sequence of transactions. 842 */ 843 xfs_trans_log_inode(trans, dp, XFS_ILOG_CORE); 844 error = xfs_trans_commit(trans, XFS_TRANS_RELEASE_LOG_RES); 845 xfs_iunlock(dp, XFS_ILOCK_EXCL); 846 847 return(error); 848 849out: 850 xfs_trans_cancel(trans, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT); 851 xfs_iunlock(dp, XFS_ILOCK_EXCL); 852 return(error); 853} 854 855 856 857/*======================================================================== 858 * External routines when attribute list is inside the inode 859 *========================================================================*/ 860 861/* 862 * Add a name to the shortform attribute list structure 863 * This is the external routine. 864 */ 865STATIC int 866xfs_attr_shortform_addname(xfs_da_args_t *args) 867{ 868 int newsize, forkoff, retval; 869 870 retval = xfs_attr_shortform_lookup(args); 871 if ((args->flags & ATTR_REPLACE) && (retval == ENOATTR)) { 872 return(retval); 873 } else if (retval == EEXIST) { 874 if (args->flags & ATTR_CREATE) 875 return(retval); 876 retval = xfs_attr_shortform_remove(args); 877 ASSERT(retval == 0); 878 } 879 880 if (args->namelen >= XFS_ATTR_SF_ENTSIZE_MAX || 881 args->valuelen >= XFS_ATTR_SF_ENTSIZE_MAX) 882 return(XFS_ERROR(ENOSPC)); 883 884 newsize = XFS_ATTR_SF_TOTSIZE(args->dp); 885 newsize += XFS_ATTR_SF_ENTSIZE_BYNAME(args->namelen, args->valuelen); 886 887 forkoff = xfs_attr_shortform_bytesfit(args->dp, newsize); 888 if (!forkoff) 889 return(XFS_ERROR(ENOSPC)); 890 891 xfs_attr_shortform_add(args, forkoff); 892 return(0); 893} 894 895 896/*======================================================================== 897 * External routines when attribute list is one block 898 *========================================================================*/ 899 900/* 901 * Add a name to the leaf attribute list structure 902 * 903 * This leaf block cannot have a "remote" value, we only call this routine 904 * if bmap_one_block() says there is only one block (ie: no remote blks). 905 */ 906STATIC int 907xfs_attr_leaf_addname(xfs_da_args_t *args) 908{ 909 xfs_inode_t *dp; 910 xfs_dabuf_t *bp; 911 int retval, error, committed, forkoff; 912 913 /* 914 * Read the (only) block in the attribute list in. 915 */ 916 dp = args->dp; 917 args->blkno = 0; 918 error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp, 919 XFS_ATTR_FORK); 920 if (error) 921 return(error); 922 ASSERT(bp != NULL); 923 924 /* 925 * Look up the given attribute in the leaf block. Figure out if 926 * the given flags produce an error or call for an atomic rename. 927 */ 928 retval = xfs_attr_leaf_lookup_int(bp, args); 929 if ((args->flags & ATTR_REPLACE) && (retval == ENOATTR)) { 930 xfs_da_brelse(args->trans, bp); 931 return(retval); 932 } else if (retval == EEXIST) { 933 if (args->flags & ATTR_CREATE) { /* pure create op */ 934 xfs_da_brelse(args->trans, bp); 935 return(retval); 936 } 937 args->op_flags |= XFS_DA_OP_RENAME; /* an atomic rename */ 938 args->blkno2 = args->blkno; /* set 2nd entry info*/ 939 args->index2 = args->index; 940 args->rmtblkno2 = args->rmtblkno; 941 args->rmtblkcnt2 = args->rmtblkcnt; 942 } 943 944 /* 945 * Add the attribute to the leaf block, transitioning to a Btree 946 * if required. 947 */ 948 retval = xfs_attr_leaf_add(bp, args); 949 xfs_da_buf_done(bp); 950 if (retval == ENOSPC) { 951 /* 952 * Promote the attribute list to the Btree format, then 953 * Commit that transaction so that the node_addname() call 954 * can manage its own transactions. 955 */ 956 xfs_bmap_init(args->flist, args->firstblock); 957 error = xfs_attr_leaf_to_node(args); 958 if (!error) { 959 error = xfs_bmap_finish(&args->trans, args->flist, 960 &committed); 961 } 962 if (error) { 963 ASSERT(committed); 964 args->trans = NULL; 965 xfs_bmap_cancel(args->flist); 966 return(error); 967 } 968 969 /* 970 * bmap_finish() may have committed the last trans and started 971 * a new one. We need the inode to be in all transactions. 972 */ 973 if (committed) 974 xfs_trans_ijoin(args->trans, dp); 975 976 /* 977 * Commit the current trans (including the inode) and start 978 * a new one. 979 */ 980 error = xfs_trans_roll(&args->trans, dp); 981 if (error) 982 return (error); 983 984 /* 985 * Fob the whole rest of the problem off on the Btree code. 986 */ 987 error = xfs_attr_node_addname(args); 988 return(error); 989 } 990 991 /* 992 * Commit the transaction that added the attr name so that 993 * later routines can manage their own transactions. 994 */ 995 error = xfs_trans_roll(&args->trans, dp); 996 if (error) 997 return (error); 998 999 /* 1000 * If there was an out-of-line value, allocate the blocks we 1001 * identified for its storage and copy the value. This is done 1002 * after we create the attribute so that we don't overflow the 1003 * maximum size of a transaction and/or hit a deadlock. 1004 */ 1005 if (args->rmtblkno > 0) { 1006 error = xfs_attr_rmtval_set(args); 1007 if (error) 1008 return(error); 1009 } 1010 1011 /* 1012 * If this is an atomic rename operation, we must "flip" the 1013 * incomplete flags on the "new" and "old" attribute/value pairs 1014 * so that one disappears and one appears atomically. Then we 1015 * must remove the "old" attribute/value pair. 1016 */ 1017 if (args->op_flags & XFS_DA_OP_RENAME) { 1018 /* 1019 * In a separate transaction, set the incomplete flag on the 1020 * "old" attr and clear the incomplete flag on the "new" attr. 1021 */ 1022 error = xfs_attr_leaf_flipflags(args); 1023 if (error) 1024 return(error); 1025 1026 /* 1027 * Dismantle the "old" attribute/value pair by removing 1028 * a "remote" value (if it exists). 1029 */ 1030 args->index = args->index2; 1031 args->blkno = args->blkno2; 1032 args->rmtblkno = args->rmtblkno2; 1033 args->rmtblkcnt = args->rmtblkcnt2; 1034 if (args->rmtblkno) { 1035 error = xfs_attr_rmtval_remove(args); 1036 if (error) 1037 return(error); 1038 } 1039 1040 /* 1041 * Read in the block containing the "old" attr, then 1042 * remove the "old" attr from that block (neat, huh!) 1043 */ 1044 error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, 1045 &bp, XFS_ATTR_FORK); 1046 if (error) 1047 return(error); 1048 ASSERT(bp != NULL); 1049 (void)xfs_attr_leaf_remove(bp, args); 1050 1051 /* 1052 * If the result is small enough, shrink it all into the inode. 1053 */ 1054 if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) { 1055 xfs_bmap_init(args->flist, args->firstblock); 1056 error = xfs_attr_leaf_to_shortform(bp, args, forkoff); 1057 /* bp is gone due to xfs_da_shrink_inode */ 1058 if (!error) { 1059 error = xfs_bmap_finish(&args->trans, 1060 args->flist, 1061 &committed); 1062 } 1063 if (error) { 1064 ASSERT(committed); 1065 args->trans = NULL; 1066 xfs_bmap_cancel(args->flist); 1067 return(error); 1068 } 1069 1070 /* 1071 * bmap_finish() may have committed the last trans 1072 * and started a new one. We need the inode to be 1073 * in all transactions. 1074 */ 1075 if (committed) 1076 xfs_trans_ijoin(args->trans, dp); 1077 } else 1078 xfs_da_buf_done(bp); 1079 1080 /* 1081 * Commit the remove and start the next trans in series. 1082 */ 1083 error = xfs_trans_roll(&args->trans, dp); 1084 1085 } else if (args->rmtblkno > 0) { 1086 /* 1087 * Added a "remote" value, just clear the incomplete flag. 1088 */ 1089 error = xfs_attr_leaf_clearflag(args); 1090 } 1091 return(error); 1092} 1093 1094/* 1095 * Remove a name from the leaf attribute list structure 1096 * 1097 * This leaf block cannot have a "remote" value, we only call this routine 1098 * if bmap_one_block() says there is only one block (ie: no remote blks). 1099 */ 1100STATIC int 1101xfs_attr_leaf_removename(xfs_da_args_t *args) 1102{ 1103 xfs_inode_t *dp; 1104 xfs_dabuf_t *bp; 1105 int error, committed, forkoff; 1106 1107 /* 1108 * Remove the attribute. 1109 */ 1110 dp = args->dp; 1111 args->blkno = 0; 1112 error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp, 1113 XFS_ATTR_FORK); 1114 if (error) { 1115 return(error); 1116 } 1117 1118 ASSERT(bp != NULL); 1119 error = xfs_attr_leaf_lookup_int(bp, args); 1120 if (error == ENOATTR) { 1121 xfs_da_brelse(args->trans, bp); 1122 return(error); 1123 } 1124 1125 (void)xfs_attr_leaf_remove(bp, args); 1126 1127 /* 1128 * If the result is small enough, shrink it all into the inode. 1129 */ 1130 if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) { 1131 xfs_bmap_init(args->flist, args->firstblock); 1132 error = xfs_attr_leaf_to_shortform(bp, args, forkoff); 1133 /* bp is gone due to xfs_da_shrink_inode */ 1134 if (!error) { 1135 error = xfs_bmap_finish(&args->trans, args->flist, 1136 &committed); 1137 } 1138 if (error) { 1139 ASSERT(committed); 1140 args->trans = NULL; 1141 xfs_bmap_cancel(args->flist); 1142 return(error); 1143 } 1144 1145 /* 1146 * bmap_finish() may have committed the last trans and started 1147 * a new one. We need the inode to be in all transactions. 1148 */ 1149 if (committed) 1150 xfs_trans_ijoin(args->trans, dp); 1151 } else 1152 xfs_da_buf_done(bp); 1153 return(0); 1154} 1155 1156/* 1157 * Look up a name in a leaf attribute list structure. 1158 * 1159 * This leaf block cannot have a "remote" value, we only call this routine 1160 * if bmap_one_block() says there is only one block (ie: no remote blks). 1161 */ 1162STATIC int 1163xfs_attr_leaf_get(xfs_da_args_t *args) 1164{ 1165 xfs_dabuf_t *bp; 1166 int error; 1167 1168 args->blkno = 0; 1169 error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp, 1170 XFS_ATTR_FORK); 1171 if (error) 1172 return(error); 1173 ASSERT(bp != NULL); 1174 1175 error = xfs_attr_leaf_lookup_int(bp, args); 1176 if (error != EEXIST) { 1177 xfs_da_brelse(args->trans, bp); 1178 return(error); 1179 } 1180 error = xfs_attr_leaf_getvalue(bp, args); 1181 xfs_da_brelse(args->trans, bp); 1182 if (!error && (args->rmtblkno > 0) && !(args->flags & ATTR_KERNOVAL)) { 1183 error = xfs_attr_rmtval_get(args); 1184 } 1185 return(error); 1186} 1187 1188/* 1189 * Copy out attribute entries for attr_list(), for leaf attribute lists. 1190 */ 1191STATIC int 1192xfs_attr_leaf_list(xfs_attr_list_context_t *context) 1193{ 1194 xfs_attr_leafblock_t *leaf; 1195 int error; 1196 xfs_dabuf_t *bp; 1197 1198 context->cursor->blkno = 0; 1199 error = xfs_da_read_buf(NULL, context->dp, 0, -1, &bp, XFS_ATTR_FORK); 1200 if (error) 1201 return XFS_ERROR(error); 1202 ASSERT(bp != NULL); 1203 leaf = bp->data; 1204 if (unlikely(be16_to_cpu(leaf->hdr.info.magic) != XFS_ATTR_LEAF_MAGIC)) { 1205 XFS_CORRUPTION_ERROR("xfs_attr_leaf_list", XFS_ERRLEVEL_LOW, 1206 context->dp->i_mount, leaf); 1207 xfs_da_brelse(NULL, bp); 1208 return XFS_ERROR(EFSCORRUPTED); 1209 } 1210 1211 error = xfs_attr_leaf_list_int(bp, context); 1212 xfs_da_brelse(NULL, bp); 1213 return XFS_ERROR(error); 1214} 1215 1216 1217/*======================================================================== 1218 * External routines when attribute list size > XFS_LBSIZE(mp). 1219 *========================================================================*/ 1220 1221/* 1222 * Add a name to a Btree-format attribute list. 1223 * 1224 * This will involve walking down the Btree, and may involve splitting 1225 * leaf nodes and even splitting intermediate nodes up to and including 1226 * the root node (a special case of an intermediate node). 1227 * 1228 * "Remote" attribute values confuse the issue and atomic rename operations 1229 * add a whole extra layer of confusion on top of that. 1230 */ 1231STATIC int 1232xfs_attr_node_addname(xfs_da_args_t *args) 1233{ 1234 xfs_da_state_t *state; 1235 xfs_da_state_blk_t *blk; 1236 xfs_inode_t *dp; 1237 xfs_mount_t *mp; 1238 int committed, retval, error; 1239 1240 /* 1241 * Fill in bucket of arguments/results/context to carry around. 1242 */ 1243 dp = args->dp; 1244 mp = dp->i_mount; 1245restart: 1246 state = xfs_da_state_alloc(); 1247 state->args = args; 1248 state->mp = mp; 1249 state->blocksize = state->mp->m_sb.sb_blocksize; 1250 state->node_ents = state->mp->m_attr_node_ents; 1251 1252 /* 1253 * Search to see if name already exists, and get back a pointer 1254 * to where it should go. 1255 */ 1256 error = xfs_da_node_lookup_int(state, &retval); 1257 if (error) 1258 goto out; 1259 blk = &state->path.blk[ state->path.active-1 ]; 1260 ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC); 1261 if ((args->flags & ATTR_REPLACE) && (retval == ENOATTR)) { 1262 goto out; 1263 } else if (retval == EEXIST) { 1264 if (args->flags & ATTR_CREATE) 1265 goto out; 1266 args->op_flags |= XFS_DA_OP_RENAME; /* atomic rename op */ 1267 args->blkno2 = args->blkno; /* set 2nd entry info*/ 1268 args->index2 = args->index; 1269 args->rmtblkno2 = args->rmtblkno; 1270 args->rmtblkcnt2 = args->rmtblkcnt; 1271 args->rmtblkno = 0; 1272 args->rmtblkcnt = 0; 1273 } 1274 1275 retval = xfs_attr_leaf_add(blk->bp, state->args); 1276 if (retval == ENOSPC) { 1277 if (state->path.active == 1) { 1278 /* 1279 * Its really a single leaf node, but it had 1280 * out-of-line values so it looked like it *might* 1281 * have been a b-tree. 1282 */ 1283 xfs_da_state_free(state); 1284 xfs_bmap_init(args->flist, args->firstblock); 1285 error = xfs_attr_leaf_to_node(args); 1286 if (!error) { 1287 error = xfs_bmap_finish(&args->trans, 1288 args->flist, 1289 &committed); 1290 } 1291 if (error) { 1292 ASSERT(committed); 1293 args->trans = NULL; 1294 xfs_bmap_cancel(args->flist); 1295 goto out; 1296 } 1297 1298 /* 1299 * bmap_finish() may have committed the last trans 1300 * and started a new one. We need the inode to be 1301 * in all transactions. 1302 */ 1303 if (committed) 1304 xfs_trans_ijoin(args->trans, dp); 1305 1306 /* 1307 * Commit the node conversion and start the next 1308 * trans in the chain. 1309 */ 1310 error = xfs_trans_roll(&args->trans, dp); 1311 if (error) 1312 goto out; 1313 1314 goto restart; 1315 } 1316 1317 /* 1318 * Split as many Btree elements as required. 1319 * This code tracks the new and old attr's location 1320 * in the index/blkno/rmtblkno/rmtblkcnt fields and 1321 * in the index2/blkno2/rmtblkno2/rmtblkcnt2 fields. 1322 */ 1323 xfs_bmap_init(args->flist, args->firstblock); 1324 error = xfs_da_split(state); 1325 if (!error) { 1326 error = xfs_bmap_finish(&args->trans, args->flist, 1327 &committed); 1328 } 1329 if (error) { 1330 ASSERT(committed); 1331 args->trans = NULL; 1332 xfs_bmap_cancel(args->flist); 1333 goto out; 1334 } 1335 1336 /* 1337 * bmap_finish() may have committed the last trans and started 1338 * a new one. We need the inode to be in all transactions. 1339 */ 1340 if (committed) 1341 xfs_trans_ijoin(args->trans, dp); 1342 } else { 1343 /* 1344 * Addition succeeded, update Btree hashvals. 1345 */ 1346 xfs_da_fixhashpath(state, &state->path); 1347 } 1348 1349 /* 1350 * Kill the state structure, we're done with it and need to 1351 * allow the buffers to come back later. 1352 */ 1353 xfs_da_state_free(state); 1354 state = NULL; 1355 1356 /* 1357 * Commit the leaf addition or btree split and start the next 1358 * trans in the chain. 1359 */ 1360 error = xfs_trans_roll(&args->trans, dp); 1361 if (error) 1362 goto out; 1363 1364 /* 1365 * If there was an out-of-line value, allocate the blocks we 1366 * identified for its storage and copy the value. This is done 1367 * after we create the attribute so that we don't overflow the 1368 * maximum size of a transaction and/or hit a deadlock. 1369 */ 1370 if (args->rmtblkno > 0) { 1371 error = xfs_attr_rmtval_set(args); 1372 if (error) 1373 return(error); 1374 } 1375 1376 /* 1377 * If this is an atomic rename operation, we must "flip" the 1378 * incomplete flags on the "new" and "old" attribute/value pairs 1379 * so that one disappears and one appears atomically. Then we 1380 * must remove the "old" attribute/value pair. 1381 */ 1382 if (args->op_flags & XFS_DA_OP_RENAME) { 1383 /* 1384 * In a separate transaction, set the incomplete flag on the 1385 * "old" attr and clear the incomplete flag on the "new" attr. 1386 */ 1387 error = xfs_attr_leaf_flipflags(args); 1388 if (error) 1389 goto out; 1390 1391 /* 1392 * Dismantle the "old" attribute/value pair by removing 1393 * a "remote" value (if it exists). 1394 */ 1395 args->index = args->index2; 1396 args->blkno = args->blkno2; 1397 args->rmtblkno = args->rmtblkno2; 1398 args->rmtblkcnt = args->rmtblkcnt2; 1399 if (args->rmtblkno) { 1400 error = xfs_attr_rmtval_remove(args); 1401 if (error) 1402 return(error); 1403 } 1404 1405 /* 1406 * Re-find the "old" attribute entry after any split ops. 1407 * The INCOMPLETE flag means that we will find the "old" 1408 * attr, not the "new" one. 1409 */ 1410 args->flags |= XFS_ATTR_INCOMPLETE; 1411 state = xfs_da_state_alloc(); 1412 state->args = args; 1413 state->mp = mp; 1414 state->blocksize = state->mp->m_sb.sb_blocksize; 1415 state->node_ents = state->mp->m_attr_node_ents; 1416 state->inleaf = 0; 1417 error = xfs_da_node_lookup_int(state, &retval); 1418 if (error) 1419 goto out; 1420 1421 /* 1422 * Remove the name and update the hashvals in the tree. 1423 */ 1424 blk = &state->path.blk[ state->path.active-1 ]; 1425 ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC); 1426 error = xfs_attr_leaf_remove(blk->bp, args); 1427 xfs_da_fixhashpath(state, &state->path); 1428 1429 /* 1430 * Check to see if the tree needs to be collapsed. 1431 */ 1432 if (retval && (state->path.active > 1)) { 1433 xfs_bmap_init(args->flist, args->firstblock); 1434 error = xfs_da_join(state); 1435 if (!error) { 1436 error = xfs_bmap_finish(&args->trans, 1437 args->flist, 1438 &committed); 1439 } 1440 if (error) { 1441 ASSERT(committed); 1442 args->trans = NULL; 1443 xfs_bmap_cancel(args->flist); 1444 goto out; 1445 } 1446 1447 /* 1448 * bmap_finish() may have committed the last trans 1449 * and started a new one. We need the inode to be 1450 * in all transactions. 1451 */ 1452 if (committed) 1453 xfs_trans_ijoin(args->trans, dp); 1454 } 1455 1456 /* 1457 * Commit and start the next trans in the chain. 1458 */ 1459 error = xfs_trans_roll(&args->trans, dp); 1460 if (error) 1461 goto out; 1462 1463 } else if (args->rmtblkno > 0) { 1464 /* 1465 * Added a "remote" value, just clear the incomplete flag. 1466 */ 1467 error = xfs_attr_leaf_clearflag(args); 1468 if (error) 1469 goto out; 1470 } 1471 retval = error = 0; 1472 1473out: 1474 if (state) 1475 xfs_da_state_free(state); 1476 if (error) 1477 return(error); 1478 return(retval); 1479} 1480 1481/* 1482 * Remove a name from a B-tree attribute list. 1483 * 1484 * This will involve walking down the Btree, and may involve joining 1485 * leaf nodes and even joining intermediate nodes up to and including 1486 * the root node (a special case of an intermediate node). 1487 */ 1488STATIC int 1489xfs_attr_node_removename(xfs_da_args_t *args) 1490{ 1491 xfs_da_state_t *state; 1492 xfs_da_state_blk_t *blk; 1493 xfs_inode_t *dp; 1494 xfs_dabuf_t *bp; 1495 int retval, error, committed, forkoff; 1496 1497 /* 1498 * Tie a string around our finger to remind us where we are. 1499 */ 1500 dp = args->dp; 1501 state = xfs_da_state_alloc(); 1502 state->args = args; 1503 state->mp = dp->i_mount; 1504 state->blocksize = state->mp->m_sb.sb_blocksize; 1505 state->node_ents = state->mp->m_attr_node_ents; 1506 1507 /* 1508 * Search to see if name exists, and get back a pointer to it. 1509 */ 1510 error = xfs_da_node_lookup_int(state, &retval); 1511 if (error || (retval != EEXIST)) { 1512 if (error == 0) 1513 error = retval; 1514 goto out; 1515 } 1516 1517 /* 1518 * If there is an out-of-line value, de-allocate the blocks. 1519 * This is done before we remove the attribute so that we don't 1520 * overflow the maximum size of a transaction and/or hit a deadlock. 1521 */ 1522 blk = &state->path.blk[ state->path.active-1 ]; 1523 ASSERT(blk->bp != NULL); 1524 ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC); 1525 if (args->rmtblkno > 0) { 1526 /* 1527 * Fill in disk block numbers in the state structure 1528 * so that we can get the buffers back after we commit 1529 * several transactions in the following calls. 1530 */ 1531 error = xfs_attr_fillstate(state); 1532 if (error) 1533 goto out; 1534 1535 /* 1536 * Mark the attribute as INCOMPLETE, then bunmapi() the 1537 * remote value. 1538 */ 1539 error = xfs_attr_leaf_setflag(args); 1540 if (error) 1541 goto out; 1542 error = xfs_attr_rmtval_remove(args); 1543 if (error) 1544 goto out; 1545 1546 /* 1547 * Refill the state structure with buffers, the prior calls 1548 * released our buffers. 1549 */ 1550 error = xfs_attr_refillstate(state); 1551 if (error) 1552 goto out; 1553 } 1554 1555 /* 1556 * Remove the name and update the hashvals in the tree. 1557 */ 1558 blk = &state->path.blk[ state->path.active-1 ]; 1559 ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC); 1560 retval = xfs_attr_leaf_remove(blk->bp, args); 1561 xfs_da_fixhashpath(state, &state->path); 1562 1563 /* 1564 * Check to see if the tree needs to be collapsed. 1565 */ 1566 if (retval && (state->path.active > 1)) { 1567 xfs_bmap_init(args->flist, args->firstblock); 1568 error = xfs_da_join(state); 1569 if (!error) { 1570 error = xfs_bmap_finish(&args->trans, args->flist, 1571 &committed); 1572 } 1573 if (error) { 1574 ASSERT(committed); 1575 args->trans = NULL; 1576 xfs_bmap_cancel(args->flist); 1577 goto out; 1578 } 1579 1580 /* 1581 * bmap_finish() may have committed the last trans and started 1582 * a new one. We need the inode to be in all transactions. 1583 */ 1584 if (committed) 1585 xfs_trans_ijoin(args->trans, dp); 1586 1587 /* 1588 * Commit the Btree join operation and start a new trans. 1589 */ 1590 error = xfs_trans_roll(&args->trans, dp); 1591 if (error) 1592 goto out; 1593 } 1594 1595 /* 1596 * If the result is small enough, push it all into the inode. 1597 */ 1598 if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) { 1599 /* 1600 * Have to get rid of the copy of this dabuf in the state. 1601 */ 1602 ASSERT(state->path.active == 1); 1603 ASSERT(state->path.blk[0].bp); 1604 xfs_da_buf_done(state->path.blk[0].bp); 1605 state->path.blk[0].bp = NULL; 1606 1607 error = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp, 1608 XFS_ATTR_FORK); 1609 if (error) 1610 goto out; 1611 ASSERT(be16_to_cpu(((xfs_attr_leafblock_t *) 1612 bp->data)->hdr.info.magic) 1613 == XFS_ATTR_LEAF_MAGIC); 1614 1615 if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) { 1616 xfs_bmap_init(args->flist, args->firstblock); 1617 error = xfs_attr_leaf_to_shortform(bp, args, forkoff); 1618 /* bp is gone due to xfs_da_shrink_inode */ 1619 if (!error) { 1620 error = xfs_bmap_finish(&args->trans, 1621 args->flist, 1622 &committed); 1623 } 1624 if (error) { 1625 ASSERT(committed); 1626 args->trans = NULL; 1627 xfs_bmap_cancel(args->flist); 1628 goto out; 1629 } 1630 1631 /* 1632 * bmap_finish() may have committed the last trans 1633 * and started a new one. We need the inode to be 1634 * in all transactions. 1635 */ 1636 if (committed) 1637 xfs_trans_ijoin(args->trans, dp); 1638 } else 1639 xfs_da_brelse(args->trans, bp); 1640 } 1641 error = 0; 1642 1643out: 1644 xfs_da_state_free(state); 1645 return(error); 1646} 1647 1648/* 1649 * Fill in the disk block numbers in the state structure for the buffers 1650 * that are attached to the state structure. 1651 * This is done so that we can quickly reattach ourselves to those buffers 1652 * after some set of transaction commits have released these buffers. 1653 */ 1654STATIC int 1655xfs_attr_fillstate(xfs_da_state_t *state) 1656{ 1657 xfs_da_state_path_t *path; 1658 xfs_da_state_blk_t *blk; 1659 int level; 1660 1661 /* 1662 * Roll down the "path" in the state structure, storing the on-disk 1663 * block number for those buffers in the "path". 1664 */ 1665 path = &state->path; 1666 ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH)); 1667 for (blk = path->blk, level = 0; level < path->active; blk++, level++) { 1668 if (blk->bp) { 1669 blk->disk_blkno = xfs_da_blkno(blk->bp); 1670 xfs_da_buf_done(blk->bp); 1671 blk->bp = NULL; 1672 } else { 1673 blk->disk_blkno = 0; 1674 } 1675 } 1676 1677 /* 1678 * Roll down the "altpath" in the state structure, storing the on-disk 1679 * block number for those buffers in the "altpath". 1680 */ 1681 path = &state->altpath; 1682 ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH)); 1683 for (blk = path->blk, level = 0; level < path->active; blk++, level++) { 1684 if (blk->bp) { 1685 blk->disk_blkno = xfs_da_blkno(blk->bp); 1686 xfs_da_buf_done(blk->bp); 1687 blk->bp = NULL; 1688 } else { 1689 blk->disk_blkno = 0; 1690 } 1691 } 1692 1693 return(0); 1694} 1695 1696/* 1697 * Reattach the buffers to the state structure based on the disk block 1698 * numbers stored in the state structure. 1699 * This is done after some set of transaction commits have released those 1700 * buffers from our grip. 1701 */ 1702STATIC int 1703xfs_attr_refillstate(xfs_da_state_t *state) 1704{ 1705 xfs_da_state_path_t *path; 1706 xfs_da_state_blk_t *blk; 1707 int level, error; 1708 1709 /* 1710 * Roll down the "path" in the state structure, storing the on-disk 1711 * block number for those buffers in the "path". 1712 */ 1713 path = &state->path; 1714 ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH)); 1715 for (blk = path->blk, level = 0; level < path->active; blk++, level++) { 1716 if (blk->disk_blkno) { 1717 error = xfs_da_read_buf(state->args->trans, 1718 state->args->dp, 1719 blk->blkno, blk->disk_blkno, 1720 &blk->bp, XFS_ATTR_FORK); 1721 if (error) 1722 return(error); 1723 } else { 1724 blk->bp = NULL; 1725 } 1726 } 1727 1728 /* 1729 * Roll down the "altpath" in the state structure, storing the on-disk 1730 * block number for those buffers in the "altpath". 1731 */ 1732 path = &state->altpath; 1733 ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH)); 1734 for (blk = path->blk, level = 0; level < path->active; blk++, level++) { 1735 if (blk->disk_blkno) { 1736 error = xfs_da_read_buf(state->args->trans, 1737 state->args->dp, 1738 blk->blkno, blk->disk_blkno, 1739 &blk->bp, XFS_ATTR_FORK); 1740 if (error) 1741 return(error); 1742 } else { 1743 blk->bp = NULL; 1744 } 1745 } 1746 1747 return(0); 1748} 1749 1750/* 1751 * Look up a filename in a node attribute list. 1752 * 1753 * This routine gets called for any attribute fork that has more than one 1754 * block, ie: both true Btree attr lists and for single-leaf-blocks with 1755 * "remote" values taking up more blocks. 1756 */ 1757STATIC int 1758xfs_attr_node_get(xfs_da_args_t *args) 1759{ 1760 xfs_da_state_t *state; 1761 xfs_da_state_blk_t *blk; 1762 int error, retval; 1763 int i; 1764 1765 state = xfs_da_state_alloc(); 1766 state->args = args; 1767 state->mp = args->dp->i_mount; 1768 state->blocksize = state->mp->m_sb.sb_blocksize; 1769 state->node_ents = state->mp->m_attr_node_ents; 1770 1771 /* 1772 * Search to see if name exists, and get back a pointer to it. 1773 */ 1774 error = xfs_da_node_lookup_int(state, &retval); 1775 if (error) { 1776 retval = error; 1777 } else if (retval == EEXIST) { 1778 blk = &state->path.blk[ state->path.active-1 ]; 1779 ASSERT(blk->bp != NULL); 1780 ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC); 1781 1782 /* 1783 * Get the value, local or "remote" 1784 */ 1785 retval = xfs_attr_leaf_getvalue(blk->bp, args); 1786 if (!retval && (args->rmtblkno > 0) 1787 && !(args->flags & ATTR_KERNOVAL)) { 1788 retval = xfs_attr_rmtval_get(args); 1789 } 1790 } 1791 1792 /* 1793 * If not in a transaction, we have to release all the buffers. 1794 */ 1795 for (i = 0; i < state->path.active; i++) { 1796 xfs_da_brelse(args->trans, state->path.blk[i].bp); 1797 state->path.blk[i].bp = NULL; 1798 } 1799 1800 xfs_da_state_free(state); 1801 return(retval); 1802} 1803 1804STATIC int /* error */ 1805xfs_attr_node_list(xfs_attr_list_context_t *context) 1806{ 1807 attrlist_cursor_kern_t *cursor; 1808 xfs_attr_leafblock_t *leaf; 1809 xfs_da_intnode_t *node; 1810 xfs_da_node_entry_t *btree; 1811 int error, i; 1812 xfs_dabuf_t *bp; 1813 1814 cursor = context->cursor; 1815 cursor->initted = 1; 1816 1817 /* 1818 * Do all sorts of validation on the passed-in cursor structure. 1819 * If anything is amiss, ignore the cursor and look up the hashval 1820 * starting from the btree root. 1821 */ 1822 bp = NULL; 1823 if (cursor->blkno > 0) { 1824 error = xfs_da_read_buf(NULL, context->dp, cursor->blkno, -1, 1825 &bp, XFS_ATTR_FORK); 1826 if ((error != 0) && (error != EFSCORRUPTED)) 1827 return(error); 1828 if (bp) { 1829 node = bp->data; 1830 switch (be16_to_cpu(node->hdr.info.magic)) { 1831 case XFS_DA_NODE_MAGIC: 1832 trace_xfs_attr_list_wrong_blk(context); 1833 xfs_da_brelse(NULL, bp); 1834 bp = NULL; 1835 break; 1836 case XFS_ATTR_LEAF_MAGIC: 1837 leaf = bp->data; 1838 if (cursor->hashval > be32_to_cpu(leaf->entries[ 1839 be16_to_cpu(leaf->hdr.count)-1].hashval)) { 1840 trace_xfs_attr_list_wrong_blk(context); 1841 xfs_da_brelse(NULL, bp); 1842 bp = NULL; 1843 } else if (cursor->hashval <= 1844 be32_to_cpu(leaf->entries[0].hashval)) { 1845 trace_xfs_attr_list_wrong_blk(context); 1846 xfs_da_brelse(NULL, bp); 1847 bp = NULL; 1848 } 1849 break; 1850 default: 1851 trace_xfs_attr_list_wrong_blk(context); 1852 xfs_da_brelse(NULL, bp); 1853 bp = NULL; 1854 } 1855 } 1856 } 1857 1858 /* 1859 * We did not find what we expected given the cursor's contents, 1860 * so we start from the top and work down based on the hash value. 1861 * Note that start of node block is same as start of leaf block. 1862 */ 1863 if (bp == NULL) { 1864 cursor->blkno = 0; 1865 for (;;) { 1866 error = xfs_da_read_buf(NULL, context->dp, 1867 cursor->blkno, -1, &bp, 1868 XFS_ATTR_FORK); 1869 if (error) 1870 return(error); 1871 if (unlikely(bp == NULL)) { 1872 XFS_ERROR_REPORT("xfs_attr_node_list(2)", 1873 XFS_ERRLEVEL_LOW, 1874 context->dp->i_mount); 1875 return(XFS_ERROR(EFSCORRUPTED)); 1876 } 1877 node = bp->data; 1878 if (be16_to_cpu(node->hdr.info.magic) 1879 == XFS_ATTR_LEAF_MAGIC) 1880 break; 1881 if (unlikely(be16_to_cpu(node->hdr.info.magic) 1882 != XFS_DA_NODE_MAGIC)) { 1883 XFS_CORRUPTION_ERROR("xfs_attr_node_list(3)", 1884 XFS_ERRLEVEL_LOW, 1885 context->dp->i_mount, 1886 node); 1887 xfs_da_brelse(NULL, bp); 1888 return(XFS_ERROR(EFSCORRUPTED)); 1889 } 1890 btree = node->btree; 1891 for (i = 0; i < be16_to_cpu(node->hdr.count); 1892 btree++, i++) { 1893 if (cursor->hashval 1894 <= be32_to_cpu(btree->hashval)) { 1895 cursor->blkno = be32_to_cpu(btree->before); 1896 trace_xfs_attr_list_node_descend(context, 1897 btree); 1898 break; 1899 } 1900 } 1901 if (i == be16_to_cpu(node->hdr.count)) { 1902 xfs_da_brelse(NULL, bp); 1903 return(0); 1904 } 1905 xfs_da_brelse(NULL, bp); 1906 } 1907 } 1908 ASSERT(bp != NULL); 1909 1910 /* 1911 * Roll upward through the blocks, processing each leaf block in 1912 * order. As long as there is space in the result buffer, keep 1913 * adding the information. 1914 */ 1915 for (;;) { 1916 leaf = bp->data; 1917 if (unlikely(be16_to_cpu(leaf->hdr.info.magic) 1918 != XFS_ATTR_LEAF_MAGIC)) { 1919 XFS_CORRUPTION_ERROR("xfs_attr_node_list(4)", 1920 XFS_ERRLEVEL_LOW, 1921 context->dp->i_mount, leaf); 1922 xfs_da_brelse(NULL, bp); 1923 return(XFS_ERROR(EFSCORRUPTED)); 1924 } 1925 error = xfs_attr_leaf_list_int(bp, context); 1926 if (error) { 1927 xfs_da_brelse(NULL, bp); 1928 return error; 1929 } 1930 if (context->seen_enough || leaf->hdr.info.forw == 0) 1931 break; 1932 cursor->blkno = be32_to_cpu(leaf->hdr.info.forw); 1933 xfs_da_brelse(NULL, bp); 1934 error = xfs_da_read_buf(NULL, context->dp, cursor->blkno, -1, 1935 &bp, XFS_ATTR_FORK); 1936 if (error) 1937 return(error); 1938 if (unlikely((bp == NULL))) { 1939 XFS_ERROR_REPORT("xfs_attr_node_list(5)", 1940 XFS_ERRLEVEL_LOW, 1941 context->dp->i_mount); 1942 return(XFS_ERROR(EFSCORRUPTED)); 1943 } 1944 } 1945 xfs_da_brelse(NULL, bp); 1946 return(0); 1947} 1948 1949 1950/*======================================================================== 1951 * External routines for manipulating out-of-line attribute values. 1952 *========================================================================*/ 1953 1954/* 1955 * Read the value associated with an attribute from the out-of-line buffer 1956 * that we stored it in. 1957 */ 1958int 1959xfs_attr_rmtval_get(xfs_da_args_t *args) 1960{ 1961 xfs_bmbt_irec_t map[ATTR_RMTVALUE_MAPSIZE]; 1962 xfs_mount_t *mp; 1963 xfs_daddr_t dblkno; 1964 void *dst; 1965 xfs_buf_t *bp; 1966 int nmap, error, tmp, valuelen, blkcnt, i; 1967 xfs_dablk_t lblkno; 1968 1969 ASSERT(!(args->flags & ATTR_KERNOVAL)); 1970 1971 mp = args->dp->i_mount; 1972 dst = args->value; 1973 valuelen = args->valuelen; 1974 lblkno = args->rmtblkno; 1975 while (valuelen > 0) { 1976 nmap = ATTR_RMTVALUE_MAPSIZE; 1977 error = xfs_bmapi(args->trans, args->dp, (xfs_fileoff_t)lblkno, 1978 args->rmtblkcnt, 1979 XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA, 1980 NULL, 0, map, &nmap, NULL); 1981 if (error) 1982 return(error); 1983 ASSERT(nmap >= 1); 1984 1985 for (i = 0; (i < nmap) && (valuelen > 0); i++) { 1986 ASSERT((map[i].br_startblock != DELAYSTARTBLOCK) && 1987 (map[i].br_startblock != HOLESTARTBLOCK)); 1988 dblkno = XFS_FSB_TO_DADDR(mp, map[i].br_startblock); 1989 blkcnt = XFS_FSB_TO_BB(mp, map[i].br_blockcount); 1990 error = xfs_read_buf(mp, mp->m_ddev_targp, dblkno, 1991 blkcnt, XBF_LOCK | XBF_DONT_BLOCK, 1992 &bp); 1993 if (error) 1994 return(error); 1995 1996 tmp = (valuelen < XFS_BUF_SIZE(bp)) 1997 ? valuelen : XFS_BUF_SIZE(bp); 1998 xfs_biomove(bp, 0, tmp, dst, XBF_READ); 1999 xfs_buf_relse(bp); 2000 dst += tmp; 2001 valuelen -= tmp; 2002 2003 lblkno += map[i].br_blockcount; 2004 } 2005 } 2006 ASSERT(valuelen == 0); 2007 return(0); 2008} 2009 2010/* 2011 * Write the value associated with an attribute into the out-of-line buffer 2012 * that we have defined for it. 2013 */ 2014STATIC int 2015xfs_attr_rmtval_set(xfs_da_args_t *args) 2016{ 2017 xfs_mount_t *mp; 2018 xfs_fileoff_t lfileoff; 2019 xfs_inode_t *dp; 2020 xfs_bmbt_irec_t map; 2021 xfs_daddr_t dblkno; 2022 void *src; 2023 xfs_buf_t *bp; 2024 xfs_dablk_t lblkno; 2025 int blkcnt, valuelen, nmap, error, tmp, committed; 2026 2027 dp = args->dp; 2028 mp = dp->i_mount; 2029 src = args->value; 2030 2031 /* 2032 * Find a "hole" in the attribute address space large enough for 2033 * us to drop the new attribute's value into. 2034 */ 2035 blkcnt = XFS_B_TO_FSB(mp, args->valuelen); 2036 lfileoff = 0; 2037 error = xfs_bmap_first_unused(args->trans, args->dp, blkcnt, &lfileoff, 2038 XFS_ATTR_FORK); 2039 if (error) { 2040 return(error); 2041 } 2042 args->rmtblkno = lblkno = (xfs_dablk_t)lfileoff; 2043 args->rmtblkcnt = blkcnt; 2044 2045 /* 2046 * Roll through the "value", allocating blocks on disk as required. 2047 */ 2048 while (blkcnt > 0) { 2049 /* 2050 * Allocate a single extent, up to the size of the value. 2051 */ 2052 xfs_bmap_init(args->flist, args->firstblock); 2053 nmap = 1; 2054 error = xfs_bmapi(args->trans, dp, (xfs_fileoff_t)lblkno, 2055 blkcnt, 2056 XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA | 2057 XFS_BMAPI_WRITE, 2058 args->firstblock, args->total, &map, &nmap, 2059 args->flist); 2060 if (!error) { 2061 error = xfs_bmap_finish(&args->trans, args->flist, 2062 &committed); 2063 } 2064 if (error) { 2065 ASSERT(committed); 2066 args->trans = NULL; 2067 xfs_bmap_cancel(args->flist); 2068 return(error); 2069 } 2070 2071 /* 2072 * bmap_finish() may have committed the last trans and started 2073 * a new one. We need the inode to be in all transactions. 2074 */ 2075 if (committed) 2076 xfs_trans_ijoin(args->trans, dp); 2077 2078 ASSERT(nmap == 1); 2079 ASSERT((map.br_startblock != DELAYSTARTBLOCK) && 2080 (map.br_startblock != HOLESTARTBLOCK)); 2081 lblkno += map.br_blockcount; 2082 blkcnt -= map.br_blockcount; 2083 2084 /* 2085 * Start the next trans in the chain. 2086 */ 2087 error = xfs_trans_roll(&args->trans, dp); 2088 if (error) 2089 return (error); 2090 } 2091 2092 /* 2093 * Roll through the "value", copying the attribute value to the 2094 * already-allocated blocks. Blocks are written synchronously 2095 * so that we can know they are all on disk before we turn off 2096 * the INCOMPLETE flag. 2097 */ 2098 lblkno = args->rmtblkno; 2099 valuelen = args->valuelen; 2100 while (valuelen > 0) { 2101 /* 2102 * Try to remember where we decided to put the value. 2103 */ 2104 xfs_bmap_init(args->flist, args->firstblock); 2105 nmap = 1; 2106 error = xfs_bmapi(NULL, dp, (xfs_fileoff_t)lblkno, 2107 args->rmtblkcnt, 2108 XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA, 2109 args->firstblock, 0, &map, &nmap, 2110 NULL); 2111 if (error) { 2112 return(error); 2113 } 2114 ASSERT(nmap == 1); 2115 ASSERT((map.br_startblock != DELAYSTARTBLOCK) && 2116 (map.br_startblock != HOLESTARTBLOCK)); 2117 2118 dblkno = XFS_FSB_TO_DADDR(mp, map.br_startblock), 2119 blkcnt = XFS_FSB_TO_BB(mp, map.br_blockcount); 2120 2121 bp = xfs_buf_get(mp->m_ddev_targp, dblkno, blkcnt, 2122 XBF_LOCK | XBF_DONT_BLOCK); 2123 ASSERT(bp); 2124 ASSERT(!XFS_BUF_GETERROR(bp)); 2125 2126 tmp = (valuelen < XFS_BUF_SIZE(bp)) ? valuelen : 2127 XFS_BUF_SIZE(bp); 2128 xfs_biomove(bp, 0, tmp, src, XBF_WRITE); 2129 if (tmp < XFS_BUF_SIZE(bp)) 2130 xfs_biozero(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} 2241