1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2000-2005 Silicon Graphics, Inc. 4 * Copyright (c) 2013 Red Hat, Inc. 5 * All Rights Reserved. 6 */ 7 #include "xfs.h" 8 #include "xfs_fs.h" 9 #include "xfs_shared.h" 10 #include "xfs_format.h" 11 #include "xfs_log_format.h" 12 #include "xfs_trans_resv.h" 13 #include "xfs_bit.h" 14 #include "xfs_mount.h" 15 #include "xfs_da_format.h" 16 #include "xfs_da_btree.h" 17 #include "xfs_inode.h" 18 #include "xfs_attr.h" 19 #include "xfs_attr_remote.h" 20 #include "xfs_trans.h" 21 #include "xfs_bmap.h" 22 #include "xfs_attr_leaf.h" 23 #include "xfs_quota.h" 24 #include "xfs_dir2.h" 25 #include "xfs_error.h" 26 #include "xfs_health.h" 27 28 /* 29 * Invalidate any incore buffers associated with this remote attribute value 30 * extent. We never log remote attribute value buffers, which means that they 31 * won't be attached to a transaction and are therefore safe to mark stale. 32 * The actual bunmapi will be taken care of later. 33 */ 34 STATIC int 35 xfs_attr3_rmt_stale( 36 struct xfs_inode *dp, 37 xfs_dablk_t blkno, 38 int blkcnt) 39 { 40 struct xfs_bmbt_irec map; 41 int nmap; 42 int error; 43 44 /* 45 * Roll through the "value", invalidating the attribute value's 46 * blocks. 47 */ 48 while (blkcnt > 0) { 49 /* 50 * Try to remember where we decided to put the value. 51 */ 52 nmap = 1; 53 error = xfs_bmapi_read(dp, (xfs_fileoff_t)blkno, blkcnt, 54 &map, &nmap, XFS_BMAPI_ATTRFORK); 55 if (error) 56 return error; 57 if (XFS_IS_CORRUPT(dp->i_mount, nmap != 1)) 58 return -EFSCORRUPTED; 59 60 /* 61 * Mark any incore buffers for the remote value as stale. We 62 * never log remote attr value buffers, so the buffer should be 63 * easy to kill. 64 */ 65 error = xfs_attr_rmtval_stale(dp, &map, 0); 66 if (error) 67 return error; 68 69 blkno += map.br_blockcount; 70 blkcnt -= map.br_blockcount; 71 } 72 73 return 0; 74 } 75 76 /* 77 * Invalidate all of the "remote" value regions pointed to by a particular 78 * leaf block. 79 * Note that we must release the lock on the buffer so that we are not 80 * caught holding something that the logging code wants to flush to disk. 81 */ 82 STATIC int 83 xfs_attr3_leaf_inactive( 84 struct xfs_trans **trans, 85 struct xfs_inode *dp, 86 struct xfs_buf *bp) 87 { 88 struct xfs_attr3_icleaf_hdr ichdr; 89 struct xfs_mount *mp = bp->b_mount; 90 struct xfs_attr_leafblock *leaf = bp->b_addr; 91 struct xfs_attr_leaf_entry *entry; 92 struct xfs_attr_leaf_name_remote *name_rmt; 93 int error = 0; 94 int i; 95 96 xfs_attr3_leaf_hdr_from_disk(mp->m_attr_geo, &ichdr, leaf); 97 98 /* 99 * Find the remote value extents for this leaf and invalidate their 100 * incore buffers. 101 */ 102 entry = xfs_attr3_leaf_entryp(leaf); 103 for (i = 0; i < ichdr.count; entry++, i++) { 104 int blkcnt; 105 106 if (!entry->nameidx || (entry->flags & XFS_ATTR_LOCAL)) 107 continue; 108 109 name_rmt = xfs_attr3_leaf_name_remote(leaf, i); 110 if (!name_rmt->valueblk) 111 continue; 112 113 blkcnt = xfs_attr3_rmt_blocks(dp->i_mount, 114 be32_to_cpu(name_rmt->valuelen)); 115 error = xfs_attr3_rmt_stale(dp, 116 be32_to_cpu(name_rmt->valueblk), blkcnt); 117 if (error) 118 goto err; 119 } 120 121 xfs_trans_brelse(*trans, bp); 122 err: 123 return error; 124 } 125 126 /* 127 * Recurse (gasp!) through the attribute nodes until we find leaves. 128 * We're doing a depth-first traversal in order to invalidate everything. 129 */ 130 STATIC int 131 xfs_attr3_node_inactive( 132 struct xfs_trans **trans, 133 struct xfs_inode *dp, 134 struct xfs_buf *bp, 135 int level) 136 { 137 struct xfs_mount *mp = dp->i_mount; 138 struct xfs_da_blkinfo *info; 139 xfs_dablk_t child_fsb; 140 xfs_daddr_t parent_blkno, child_blkno; 141 struct xfs_buf *child_bp; 142 struct xfs_da3_icnode_hdr ichdr; 143 int error, i; 144 145 /* 146 * Since this code is recursive (gasp!) we must protect ourselves. 147 */ 148 if (level > XFS_DA_NODE_MAXDEPTH) { 149 xfs_buf_mark_corrupt(bp); 150 xfs_trans_brelse(*trans, bp); /* no locks for later trans */ 151 xfs_dirattr_mark_sick(dp, XFS_ATTR_FORK); 152 return -EFSCORRUPTED; 153 } 154 155 xfs_da3_node_hdr_from_disk(dp->i_mount, &ichdr, bp->b_addr); 156 parent_blkno = xfs_buf_daddr(bp); 157 if (!ichdr.count) { 158 xfs_trans_brelse(*trans, bp); 159 return 0; 160 } 161 child_fsb = be32_to_cpu(ichdr.btree[0].before); 162 xfs_trans_brelse(*trans, bp); /* no locks for later trans */ 163 bp = NULL; 164 165 /* 166 * If this is the node level just above the leaves, simply loop 167 * over the leaves removing all of them. If this is higher up 168 * in the tree, recurse downward. 169 */ 170 for (i = 0; i < ichdr.count; i++) { 171 /* 172 * Read the subsidiary block to see what we have to work with. 173 * Don't do this in a transaction. This is a depth-first 174 * traversal of the tree so we may deal with many blocks 175 * before we come back to this one. 176 */ 177 error = xfs_da3_node_read(*trans, dp, child_fsb, &child_bp, 178 XFS_ATTR_FORK); 179 if (error) 180 return error; 181 182 /* save for re-read later */ 183 child_blkno = xfs_buf_daddr(child_bp); 184 185 /* 186 * Invalidate the subtree, however we have to. 187 */ 188 info = child_bp->b_addr; 189 switch (info->magic) { 190 case cpu_to_be16(XFS_DA_NODE_MAGIC): 191 case cpu_to_be16(XFS_DA3_NODE_MAGIC): 192 error = xfs_attr3_node_inactive(trans, dp, child_bp, 193 level + 1); 194 break; 195 case cpu_to_be16(XFS_ATTR_LEAF_MAGIC): 196 case cpu_to_be16(XFS_ATTR3_LEAF_MAGIC): 197 error = xfs_attr3_leaf_inactive(trans, dp, child_bp); 198 break; 199 default: 200 xfs_buf_mark_corrupt(child_bp); 201 xfs_trans_brelse(*trans, child_bp); 202 xfs_dirattr_mark_sick(dp, XFS_ATTR_FORK); 203 error = -EFSCORRUPTED; 204 break; 205 } 206 if (error) 207 return error; 208 209 /* 210 * Remove the subsidiary block from the cache and from the log. 211 */ 212 error = xfs_trans_get_buf(*trans, mp->m_ddev_targp, 213 child_blkno, 214 XFS_FSB_TO_BB(mp, mp->m_attr_geo->fsbcount), 0, 215 &child_bp); 216 if (error) 217 return error; 218 xfs_trans_binval(*trans, child_bp); 219 child_bp = NULL; 220 221 /* 222 * If we're not done, re-read the parent to get the next 223 * child block number. 224 */ 225 if (i + 1 < ichdr.count) { 226 struct xfs_da3_icnode_hdr phdr; 227 228 error = xfs_da3_node_read_mapped(*trans, dp, 229 parent_blkno, &bp, XFS_ATTR_FORK); 230 if (error) 231 return error; 232 xfs_da3_node_hdr_from_disk(dp->i_mount, &phdr, 233 bp->b_addr); 234 child_fsb = be32_to_cpu(phdr.btree[i + 1].before); 235 xfs_trans_brelse(*trans, bp); 236 bp = NULL; 237 } 238 /* 239 * Atomically commit the whole invalidate stuff. 240 */ 241 error = xfs_trans_roll_inode(trans, dp); 242 if (error) 243 return error; 244 } 245 246 return 0; 247 } 248 249 /* 250 * Indiscriminately delete the entire attribute fork 251 * 252 * Recurse (gasp!) through the attribute nodes until we find leaves. 253 * We're doing a depth-first traversal in order to invalidate everything. 254 */ 255 static int 256 xfs_attr3_root_inactive( 257 struct xfs_trans **trans, 258 struct xfs_inode *dp) 259 { 260 struct xfs_mount *mp = dp->i_mount; 261 struct xfs_da_blkinfo *info; 262 struct xfs_buf *bp; 263 xfs_daddr_t blkno; 264 int error; 265 266 /* 267 * Read block 0 to see what we have to work with. 268 * We only get here if we have extents, since we remove 269 * the extents in reverse order the extent containing 270 * block 0 must still be there. 271 */ 272 error = xfs_da3_node_read(*trans, dp, 0, &bp, XFS_ATTR_FORK); 273 if (error) 274 return error; 275 blkno = xfs_buf_daddr(bp); 276 277 /* 278 * Invalidate the tree, even if the "tree" is only a single leaf block. 279 * This is a depth-first traversal! 280 */ 281 info = bp->b_addr; 282 switch (info->magic) { 283 case cpu_to_be16(XFS_DA_NODE_MAGIC): 284 case cpu_to_be16(XFS_DA3_NODE_MAGIC): 285 error = xfs_attr3_node_inactive(trans, dp, bp, 1); 286 break; 287 case cpu_to_be16(XFS_ATTR_LEAF_MAGIC): 288 case cpu_to_be16(XFS_ATTR3_LEAF_MAGIC): 289 error = xfs_attr3_leaf_inactive(trans, dp, bp); 290 break; 291 default: 292 xfs_dirattr_mark_sick(dp, XFS_ATTR_FORK); 293 error = -EFSCORRUPTED; 294 xfs_buf_mark_corrupt(bp); 295 xfs_trans_brelse(*trans, bp); 296 break; 297 } 298 if (error) 299 return error; 300 301 /* 302 * Invalidate the incore copy of the root block. 303 */ 304 error = xfs_trans_get_buf(*trans, mp->m_ddev_targp, blkno, 305 XFS_FSB_TO_BB(mp, mp->m_attr_geo->fsbcount), 0, &bp); 306 if (error) 307 return error; 308 xfs_trans_binval(*trans, bp); /* remove from cache */ 309 /* 310 * Commit the invalidate and start the next transaction. 311 */ 312 error = xfs_trans_roll_inode(trans, dp); 313 314 return error; 315 } 316 317 /* 318 * xfs_attr_inactive kills all traces of an attribute fork on an inode. It 319 * removes both the on-disk and in-memory inode fork. Note that this also has to 320 * handle the condition of inodes without attributes but with an attribute fork 321 * configured, so we can't use xfs_inode_hasattr() here. 322 * 323 * The in-memory attribute fork is removed even on error. 324 */ 325 int 326 xfs_attr_inactive( 327 struct xfs_inode *dp) 328 { 329 struct xfs_trans *trans; 330 struct xfs_mount *mp; 331 int lock_mode = XFS_ILOCK_SHARED; 332 int error = 0; 333 334 mp = dp->i_mount; 335 336 xfs_ilock(dp, lock_mode); 337 if (!xfs_inode_has_attr_fork(dp)) 338 goto out_destroy_fork; 339 xfs_iunlock(dp, lock_mode); 340 341 lock_mode = 0; 342 343 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_attrinval, 0, 0, 0, &trans); 344 if (error) 345 goto out_destroy_fork; 346 347 lock_mode = XFS_ILOCK_EXCL; 348 xfs_ilock(dp, lock_mode); 349 350 if (!xfs_inode_has_attr_fork(dp)) 351 goto out_cancel; 352 353 /* 354 * No need to make quota reservations here. We expect to release some 355 * blocks, not allocate, in the common case. 356 */ 357 xfs_trans_ijoin(trans, dp, 0); 358 359 /* 360 * Invalidate and truncate the attribute fork extents. Make sure the 361 * fork actually has xattr blocks as otherwise the invalidation has no 362 * blocks to read and returns an error. In this case, just do the fork 363 * removal below. 364 */ 365 if (dp->i_af.if_nextents > 0) { 366 error = xfs_attr3_root_inactive(&trans, dp); 367 if (error) 368 goto out_cancel; 369 370 error = xfs_itruncate_extents(&trans, dp, XFS_ATTR_FORK, 0); 371 if (error) 372 goto out_cancel; 373 } 374 375 /* Reset the attribute fork - this also destroys the in-core fork */ 376 xfs_attr_fork_remove(dp, trans); 377 378 error = xfs_trans_commit(trans); 379 xfs_iunlock(dp, lock_mode); 380 return error; 381 382 out_cancel: 383 xfs_trans_cancel(trans); 384 out_destroy_fork: 385 /* kill the in-core attr fork before we drop the inode lock */ 386 xfs_ifork_zap_attr(dp); 387 if (lock_mode) 388 xfs_iunlock(dp, lock_mode); 389 return error; 390 } 391