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 } 454