fs/xfs/libxfs/xfs_attr.c

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