fs/xfs/xfs_attr_inactive.c

   1 /*
   2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   3  * Copyright (c) 2013 Red Hat, Inc.
   4  * All Rights Reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it would be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write the Free Software Foundation,
  17  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  */
  19 #include "xfs.h"
  20 #include "xfs_fs.h"
  21 #include "xfs_format.h"
  22 #include "xfs_bit.h"
  23 #include "xfs_log.h"
  24 #include "xfs_trans.h"
  25 #include "xfs_sb.h"
  26 #include "xfs_ag.h"
  27 #include "xfs_mount.h"
  28 #include "xfs_da_btree.h"
  29 #include "xfs_bmap_btree.h"
  30 #include "xfs_alloc_btree.h"
  31 #include "xfs_ialloc_btree.h"
  32 #include "xfs_alloc.h"
  33 #include "xfs_btree.h"
  34 #include "xfs_attr_remote.h"
  35 #include "xfs_dinode.h"
  36 #include "xfs_inode.h"
  37 #include "xfs_inode_item.h"
  38 #include "xfs_bmap.h"
  39 #include "xfs_attr.h"
  40 #include "xfs_attr_leaf.h"
  41 #include "xfs_error.h"
  42 #include "xfs_quota.h"
  43 #include "xfs_trace.h"
  44 #include "xfs_trans_priv.h"
  45
  46 /*
  47  * Look at all the extents for this logical region,
  48  * invalidate any buffers that are incore/in transactions.
  49  */
  50 STATIC int
  51 xfs_attr3_leaf_freextent(
  52         struct xfs_trans        **trans,
  53         struct xfs_inode        *dp,
  54         xfs_dablk_t             blkno,
  55         int                     blkcnt)
  56 {
  57         struct xfs_bmbt_irec    map;
  58         struct xfs_buf          *bp;
  59         xfs_dablk_t             tblkno;
  60         xfs_daddr_t             dblkno;
  61         int                     tblkcnt;
  62         int                     dblkcnt;
  63         int                     nmap;
  64         int                     error;
  65
  66         /*
  67          * Roll through the "value", invalidating the attribute value's
  68          * blocks.
  69          */
  70         tblkno = blkno;
  71         tblkcnt = blkcnt;
  72         while (tblkcnt > 0) {
  73                 /*
  74                  * Try to remember where we decided to put the value.
  75                  */
  76                 nmap = 1;
  77                 error = xfs_bmapi_read(dp, (xfs_fileoff_t)tblkno, tblkcnt,
  78                                        &map, &nmap, XFS_BMAPI_ATTRFORK);
  79                 if (error) {
  80                         return(error);
  81                 }
  82                 ASSERT(nmap == 1);
  83                 ASSERT(map.br_startblock != DELAYSTARTBLOCK);
  84
  85                 /*
  86                  * If it's a hole, these are already unmapped
  87                  * so there's nothing to invalidate.
  88                  */
  89                 if (map.br_startblock != HOLESTARTBLOCK) {
  90
  91                         dblkno = XFS_FSB_TO_DADDR(dp->i_mount,
  92                                                   map.br_startblock);
  93                         dblkcnt = XFS_FSB_TO_BB(dp->i_mount,
  94                                                 map.br_blockcount);
  95                         bp = xfs_trans_get_buf(*trans,
  96                                         dp->i_mount->m_ddev_targp,
  97                                         dblkno, dblkcnt, 0);
  98                         if (!bp)
  99                                 return ENOMEM;
 100                         xfs_trans_binval(*trans, bp);
 101                         /*
 102                          * Roll to next transaction.
 103                          */
 104                         error = xfs_trans_roll(trans, dp);
 105                         if (error)
 106                                 return (error);
 107                 }
 108
 109                 tblkno += map.br_blockcount;
 110                 tblkcnt -= map.br_blockcount;
 111         }
 112
 113         return(0);
 114 }
 115
 116 /*
 117  * Invalidate all of the "remote" value regions pointed to by a particular
 118  * leaf block.
 119  * Note that we must release the lock on the buffer so that we are not
 120  * caught holding something that the logging code wants to flush to disk.
 121  */
 122 STATIC int
 123 xfs_attr3_leaf_inactive(
 124         struct xfs_trans        **trans,
 125         struct xfs_inode        *dp,
 126         struct xfs_buf          *bp)
 127 {
 128         struct xfs_attr_leafblock *leaf;
 129         struct xfs_attr3_icleaf_hdr ichdr;
 130         struct xfs_attr_leaf_entry *entry;
 131         struct xfs_attr_leaf_name_remote *name_rmt;
 132         struct xfs_attr_inactive_list *list;
 133         struct xfs_attr_inactive_list *lp;
 134         int                     error;
 135         int                     count;
 136         int                     size;
 137         int                     tmp;
 138         int                     i;
 139
 140         leaf = bp->b_addr;
 141         xfs_attr3_leaf_hdr_from_disk(&ichdr, leaf);
 142
 143         /*
 144          * Count the number of "remote" value extents.
 145          */
 146         count = 0;
 147         entry = xfs_attr3_leaf_entryp(leaf);
 148         for (i = 0; i < ichdr.count; entry++, i++) {
 149                 if (be16_to_cpu(entry->nameidx) &&
 150                     ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
 151                         name_rmt = xfs_attr3_leaf_name_remote(leaf, i);
 152                         if (name_rmt->valueblk)
 153                                 count++;
 154                 }
 155         }
 156
 157         /*
 158          * If there are no "remote" values, we're done.
 159          */
 160         if (count == 0) {
 161                 xfs_trans_brelse(*trans, bp);
 162                 return 0;
 163         }
 164
 165         /*
 166          * Allocate storage for a list of all the "remote" value extents.
 167          */
 168         size = count * sizeof(xfs_attr_inactive_list_t);
 169         list = kmem_alloc(size, KM_SLEEP);
 170
 171         /*
 172          * Identify each of the "remote" value extents.
 173          */
 174         lp = list;
 175         entry = xfs_attr3_leaf_entryp(leaf);
 176         for (i = 0; i < ichdr.count; entry++, i++) {
 177                 if (be16_to_cpu(entry->nameidx) &&
 178                     ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
 179                         name_rmt = xfs_attr3_leaf_name_remote(leaf, i);
 180                         if (name_rmt->valueblk) {
 181                                 lp->valueblk = be32_to_cpu(name_rmt->valueblk);
 182                                 lp->valuelen = xfs_attr3_rmt_blocks(dp->i_mount,
 183                                                     be32_to_cpu(name_rmt->valuelen));
 184                                 lp++;
 185                         }
 186                 }
 187         }
 188         xfs_trans_brelse(*trans, bp);   /* unlock for trans. in freextent() */
 189
 190         /*
 191          * Invalidate each of the "remote" value extents.
 192          */
 193         error = 0;
 194         for (lp = list, i = 0; i < count; i++, lp++) {
 195                 tmp = xfs_attr3_leaf_freextent(trans, dp,
 196                                 lp->valueblk, lp->valuelen);
 197
 198                 if (error == 0)
 199                         error = tmp;    /* save only the 1st errno */
 200         }
 201
 202         kmem_free(list);
 203         return error;
 204 }
 205
 206 /*
 207  * Recurse (gasp!) through the attribute nodes until we find leaves.
 208  * We're doing a depth-first traversal in order to invalidate everything.
 209  */
 210 STATIC int
 211 xfs_attr3_node_inactive(
 212         struct xfs_trans **trans,
 213         struct xfs_inode *dp,
 214         struct xfs_buf  *bp,
 215         int             level)
 216 {
 217         xfs_da_blkinfo_t *info;
 218         xfs_da_intnode_t *node;
 219         xfs_dablk_t child_fsb;
 220         xfs_daddr_t parent_blkno, child_blkno;
 221         int error, i;
 222         struct xfs_buf *child_bp;
 223         struct xfs_da_node_entry *btree;
 224         struct xfs_da3_icnode_hdr ichdr;
 225
 226         /*
 227          * Since this code is recursive (gasp!) we must protect ourselves.
 228          */
 229         if (level > XFS_DA_NODE_MAXDEPTH) {
 230                 xfs_trans_brelse(*trans, bp);   /* no locks for later trans */
 231                 return XFS_ERROR(EIO);
 232         }
 233
 234         node = bp->b_addr;
 235         xfs_da3_node_hdr_from_disk(&ichdr, node);
 236         parent_blkno = bp->b_bn;
 237         if (!ichdr.count) {
 238                 xfs_trans_brelse(*trans, bp);
 239                 return 0;
 240         }
 241         btree = xfs_da3_node_tree_p(node);
 242         child_fsb = be32_to_cpu(btree[0].before);
 243         xfs_trans_brelse(*trans, bp);   /* no locks for later trans */
 244
 245         /*
 246          * If this is the node level just above the leaves, simply loop
 247          * over the leaves removing all of them.  If this is higher up
 248          * in the tree, recurse downward.
 249          */
 250         for (i = 0; i < ichdr.count; i++) {
 251                 /*
 252                  * Read the subsidiary block to see what we have to work with.
 253                  * Don't do this in a transaction.  This is a depth-first
 254                  * traversal of the tree so we may deal with many blocks
 255                  * before we come back to this one.
 256                  */
 257                 error = xfs_da3_node_read(*trans, dp, child_fsb, -2, &child_bp,
 258                                                 XFS_ATTR_FORK);
 259                 if (error)
 260                         return(error);
 261                 if (child_bp) {
 262                                                 /* save for re-read later */
 263                         child_blkno = XFS_BUF_ADDR(child_bp);
 264
 265                         /*
 266                          * Invalidate the subtree, however we have to.
 267                          */
 268                         info = child_bp->b_addr;
 269                         switch (info->magic) {
 270                         case cpu_to_be16(XFS_DA_NODE_MAGIC):
 271                         case cpu_to_be16(XFS_DA3_NODE_MAGIC):
 272                                 error = xfs_attr3_node_inactive(trans, dp,
 273                                                         child_bp, level + 1);
 274                                 break;
 275                         case cpu_to_be16(XFS_ATTR_LEAF_MAGIC):
 276                         case cpu_to_be16(XFS_ATTR3_LEAF_MAGIC):
 277                                 error = xfs_attr3_leaf_inactive(trans, dp,
 278                                                         child_bp);
 279                                 break;
 280                         default:
 281                                 error = XFS_ERROR(EIO);
 282                                 xfs_trans_brelse(*trans, child_bp);
 283                                 break;
 284                         }
 285                         if (error)
 286                                 return error;
 287
 288                         /*
 289                          * Remove the subsidiary block from the cache
 290                          * and from the log.
 291                          */
 292                         error = xfs_da_get_buf(*trans, dp, 0, child_blkno,
 293                                 &child_bp, XFS_ATTR_FORK);
 294                         if (error)
 295                                 return error;
 296                         xfs_trans_binval(*trans, child_bp);
 297                 }
 298
 299                 /*
 300                  * If we're not done, re-read the parent to get the next
 301                  * child block number.
 302                  */
 303                 if (i + 1 < ichdr.count) {
 304                         error = xfs_da3_node_read(*trans, dp, 0, parent_blkno,
 305                                                  &bp, XFS_ATTR_FORK);
 306                         if (error)
 307                                 return error;
 308                         child_fsb = be32_to_cpu(btree[i + 1].before);
 309                         xfs_trans_brelse(*trans, bp);
 310                 }
 311                 /*
 312                  * Atomically commit the whole invalidate stuff.
 313                  */
 314                 error = xfs_trans_roll(trans, dp);
 315                 if (error)
 316                         return  error;
 317         }
 318
 319         return 0;
 320 }
 321
 322 /*
 323  * Indiscriminately delete the entire attribute fork
 324  *
 325  * Recurse (gasp!) through the attribute nodes until we find leaves.
 326  * We're doing a depth-first traversal in order to invalidate everything.
 327  */
 328 int
 329 xfs_attr3_root_inactive(
 330         struct xfs_trans        **trans,
 331         struct xfs_inode        *dp)
 332 {
 333         struct xfs_da_blkinfo   *info;
 334         struct xfs_buf          *bp;
 335         xfs_daddr_t             blkno;
 336         int                     error;
 337
 338         /*
 339          * Read block 0 to see what we have to work with.
 340          * We only get here if we have extents, since we remove
 341          * the extents in reverse order the extent containing
 342          * block 0 must still be there.
 343          */
 344         error = xfs_da3_node_read(*trans, dp, 0, -1, &bp, XFS_ATTR_FORK);
 345         if (error)
 346                 return error;
 347         blkno = bp->b_bn;
 348
 349         /*
 350          * Invalidate the tree, even if the "tree" is only a single leaf block.
 351          * This is a depth-first traversal!
 352          */
 353         info = bp->b_addr;
 354         switch (info->magic) {
 355         case cpu_to_be16(XFS_DA_NODE_MAGIC):
 356         case cpu_to_be16(XFS_DA3_NODE_MAGIC):
 357                 error = xfs_attr3_node_inactive(trans, dp, bp, 1);
 358                 break;
 359         case cpu_to_be16(XFS_ATTR_LEAF_MAGIC):
 360         case cpu_to_be16(XFS_ATTR3_LEAF_MAGIC):
 361                 error = xfs_attr3_leaf_inactive(trans, dp, bp);
 362                 break;
 363         default:
 364                 error = XFS_ERROR(EIO);
 365                 xfs_trans_brelse(*trans, bp);
 366                 break;
 367         }
 368         if (error)
 369                 return error;
 370
 371         /*
 372          * Invalidate the incore copy of the root block.
 373          */
 374         error = xfs_da_get_buf(*trans, dp, 0, blkno, &bp, XFS_ATTR_FORK);
 375         if (error)
 376                 return error;
 377         xfs_trans_binval(*trans, bp);   /* remove from cache */
 378         /*
 379          * Commit the invalidate and start the next transaction.
 380          */
 381         error = xfs_trans_roll(trans, dp);
 382
 383         return error;
 384 }
 385
 386 int
 387 xfs_attr_inactive(xfs_inode_t *dp)
 388 {
 389         xfs_trans_t *trans;
 390         xfs_mount_t *mp;
 391         int error;
 392
 393         mp = dp->i_mount;
 394         ASSERT(! XFS_NOT_DQATTACHED(mp, dp));
 395
 396         xfs_ilock(dp, XFS_ILOCK_SHARED);
 397         if (!xfs_inode_hasattr(dp) ||
 398             dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
 399                 xfs_iunlock(dp, XFS_ILOCK_SHARED);
 400                 return 0;
 401         }
 402         xfs_iunlock(dp, XFS_ILOCK_SHARED);
 403
 404         /*
 405          * Start our first transaction of the day.
 406          *
 407          * All future transactions during this code must be "chained" off
 408          * this one via the trans_dup() call.  All transactions will contain
 409          * the inode, and the inode will always be marked with trans_ihold().
 410          * Since the inode will be locked in all transactions, we must log
 411          * the inode in every transaction to let it float upward through
 412          * the log.
 413          */
 414         trans = xfs_trans_alloc(mp, XFS_TRANS_ATTRINVAL);
 415         error = xfs_trans_reserve(trans, &M_RES(mp)->tr_attrinval, 0, 0);
 416         if (error) {
 417                 xfs_trans_cancel(trans, 0);
 418                 return(error);
 419         }
 420         xfs_ilock(dp, XFS_ILOCK_EXCL);
 421
 422         /*
 423          * No need to make quota reservations here. We expect to release some
 424          * blocks, not allocate, in the common case.
 425          */
 426         xfs_trans_ijoin(trans, dp, 0);
 427
 428         /*
 429          * Decide on what work routines to call based on the inode size.
 430          */
 431         if (!xfs_inode_hasattr(dp) ||
 432             dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
 433                 error = 0;
 434                 goto out;
 435         }
 436         error = xfs_attr3_root_inactive(&trans, dp);
 437         if (error)
 438                 goto out;
 439
 440         error = xfs_itruncate_extents(&trans, dp, XFS_ATTR_FORK, 0);
 441         if (error)
 442                 goto out;
 443
 444         error = xfs_trans_commit(trans, XFS_TRANS_RELEASE_LOG_RES);
 445         xfs_iunlock(dp, XFS_ILOCK_EXCL);
 446
 447         return(error);
 448
 449 out:
 450         xfs_trans_cancel(trans, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
 451         xfs_iunlock(dp, XFS_ILOCK_EXCL);
 452         return(error);
 453 }