1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (C) 2016 Oracle. All Rights Reserved. 4 * Author: Darrick J. Wong <darrick.wong@oracle.com> 5 */ 6 #include "xfs.h" 7 #include "xfs_fs.h" 8 #include "xfs_format.h" 9 #include "xfs_log_format.h" 10 #include "xfs_trans_resv.h" 11 #include "xfs_bit.h" 12 #include "xfs_shared.h" 13 #include "xfs_mount.h" 14 #include "xfs_defer.h" 15 #include "xfs_trans.h" 16 #include "xfs_trans_priv.h" 17 #include "xfs_rmap_item.h" 18 #include "xfs_log.h" 19 #include "xfs_rmap.h" 20 21 22 kmem_zone_t *xfs_rui_zone; 23 kmem_zone_t *xfs_rud_zone; 24 25 static inline struct xfs_rui_log_item *RUI_ITEM(struct xfs_log_item *lip) 26 { 27 return container_of(lip, struct xfs_rui_log_item, rui_item); 28 } 29 30 void 31 xfs_rui_item_free( 32 struct xfs_rui_log_item *ruip) 33 { 34 if (ruip->rui_format.rui_nextents > XFS_RUI_MAX_FAST_EXTENTS) 35 kmem_free(ruip); 36 else 37 kmem_zone_free(xfs_rui_zone, ruip); 38 } 39 40 /* 41 * Freeing the RUI requires that we remove it from the AIL if it has already 42 * been placed there. However, the RUI may not yet have been placed in the AIL 43 * when called by xfs_rui_release() from RUD processing due to the ordering of 44 * committed vs unpin operations in bulk insert operations. Hence the reference 45 * count to ensure only the last caller frees the RUI. 46 */ 47 void 48 xfs_rui_release( 49 struct xfs_rui_log_item *ruip) 50 { 51 ASSERT(atomic_read(&ruip->rui_refcount) > 0); 52 if (atomic_dec_and_test(&ruip->rui_refcount)) { 53 xfs_trans_ail_remove(&ruip->rui_item, SHUTDOWN_LOG_IO_ERROR); 54 xfs_rui_item_free(ruip); 55 } 56 } 57 58 STATIC void 59 xfs_rui_item_size( 60 struct xfs_log_item *lip, 61 int *nvecs, 62 int *nbytes) 63 { 64 struct xfs_rui_log_item *ruip = RUI_ITEM(lip); 65 66 *nvecs += 1; 67 *nbytes += xfs_rui_log_format_sizeof(ruip->rui_format.rui_nextents); 68 } 69 70 /* 71 * This is called to fill in the vector of log iovecs for the 72 * given rui log item. We use only 1 iovec, and we point that 73 * at the rui_log_format structure embedded in the rui item. 74 * It is at this point that we assert that all of the extent 75 * slots in the rui item have been filled. 76 */ 77 STATIC void 78 xfs_rui_item_format( 79 struct xfs_log_item *lip, 80 struct xfs_log_vec *lv) 81 { 82 struct xfs_rui_log_item *ruip = RUI_ITEM(lip); 83 struct xfs_log_iovec *vecp = NULL; 84 85 ASSERT(atomic_read(&ruip->rui_next_extent) == 86 ruip->rui_format.rui_nextents); 87 88 ruip->rui_format.rui_type = XFS_LI_RUI; 89 ruip->rui_format.rui_size = 1; 90 91 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_RUI_FORMAT, &ruip->rui_format, 92 xfs_rui_log_format_sizeof(ruip->rui_format.rui_nextents)); 93 } 94 95 /* 96 * The unpin operation is the last place an RUI is manipulated in the log. It is 97 * either inserted in the AIL or aborted in the event of a log I/O error. In 98 * either case, the RUI transaction has been successfully committed to make it 99 * this far. Therefore, we expect whoever committed the RUI to either construct 100 * and commit the RUD or drop the RUD's reference in the event of error. Simply 101 * drop the log's RUI reference now that the log is done with it. 102 */ 103 STATIC void 104 xfs_rui_item_unpin( 105 struct xfs_log_item *lip, 106 int remove) 107 { 108 struct xfs_rui_log_item *ruip = RUI_ITEM(lip); 109 110 xfs_rui_release(ruip); 111 } 112 113 /* 114 * The RUI has been either committed or aborted if the transaction has been 115 * cancelled. If the transaction was cancelled, an RUD isn't going to be 116 * constructed and thus we free the RUI here directly. 117 */ 118 STATIC void 119 xfs_rui_item_release( 120 struct xfs_log_item *lip) 121 { 122 xfs_rui_release(RUI_ITEM(lip)); 123 } 124 125 static const struct xfs_item_ops xfs_rui_item_ops = { 126 .iop_size = xfs_rui_item_size, 127 .iop_format = xfs_rui_item_format, 128 .iop_unpin = xfs_rui_item_unpin, 129 .iop_release = xfs_rui_item_release, 130 }; 131 132 /* 133 * Allocate and initialize an rui item with the given number of extents. 134 */ 135 struct xfs_rui_log_item * 136 xfs_rui_init( 137 struct xfs_mount *mp, 138 uint nextents) 139 140 { 141 struct xfs_rui_log_item *ruip; 142 143 ASSERT(nextents > 0); 144 if (nextents > XFS_RUI_MAX_FAST_EXTENTS) 145 ruip = kmem_zalloc(xfs_rui_log_item_sizeof(nextents), 0); 146 else 147 ruip = kmem_zone_zalloc(xfs_rui_zone, 0); 148 149 xfs_log_item_init(mp, &ruip->rui_item, XFS_LI_RUI, &xfs_rui_item_ops); 150 ruip->rui_format.rui_nextents = nextents; 151 ruip->rui_format.rui_id = (uintptr_t)(void *)ruip; 152 atomic_set(&ruip->rui_next_extent, 0); 153 atomic_set(&ruip->rui_refcount, 2); 154 155 return ruip; 156 } 157 158 /* 159 * Copy an RUI format buffer from the given buf, and into the destination 160 * RUI format structure. The RUI/RUD items were designed not to need any 161 * special alignment handling. 162 */ 163 int 164 xfs_rui_copy_format( 165 struct xfs_log_iovec *buf, 166 struct xfs_rui_log_format *dst_rui_fmt) 167 { 168 struct xfs_rui_log_format *src_rui_fmt; 169 uint len; 170 171 src_rui_fmt = buf->i_addr; 172 len = xfs_rui_log_format_sizeof(src_rui_fmt->rui_nextents); 173 174 if (buf->i_len != len) 175 return -EFSCORRUPTED; 176 177 memcpy(dst_rui_fmt, src_rui_fmt, len); 178 return 0; 179 } 180 181 static inline struct xfs_rud_log_item *RUD_ITEM(struct xfs_log_item *lip) 182 { 183 return container_of(lip, struct xfs_rud_log_item, rud_item); 184 } 185 186 STATIC void 187 xfs_rud_item_size( 188 struct xfs_log_item *lip, 189 int *nvecs, 190 int *nbytes) 191 { 192 *nvecs += 1; 193 *nbytes += sizeof(struct xfs_rud_log_format); 194 } 195 196 /* 197 * This is called to fill in the vector of log iovecs for the 198 * given rud log item. We use only 1 iovec, and we point that 199 * at the rud_log_format structure embedded in the rud item. 200 * It is at this point that we assert that all of the extent 201 * slots in the rud item have been filled. 202 */ 203 STATIC void 204 xfs_rud_item_format( 205 struct xfs_log_item *lip, 206 struct xfs_log_vec *lv) 207 { 208 struct xfs_rud_log_item *rudp = RUD_ITEM(lip); 209 struct xfs_log_iovec *vecp = NULL; 210 211 rudp->rud_format.rud_type = XFS_LI_RUD; 212 rudp->rud_format.rud_size = 1; 213 214 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_RUD_FORMAT, &rudp->rud_format, 215 sizeof(struct xfs_rud_log_format)); 216 } 217 218 /* 219 * The RUD is either committed or aborted if the transaction is cancelled. If 220 * the transaction is cancelled, drop our reference to the RUI and free the 221 * RUD. 222 */ 223 STATIC void 224 xfs_rud_item_release( 225 struct xfs_log_item *lip) 226 { 227 struct xfs_rud_log_item *rudp = RUD_ITEM(lip); 228 229 xfs_rui_release(rudp->rud_ruip); 230 kmem_zone_free(xfs_rud_zone, rudp); 231 } 232 233 static const struct xfs_item_ops xfs_rud_item_ops = { 234 .flags = XFS_ITEM_RELEASE_WHEN_COMMITTED, 235 .iop_size = xfs_rud_item_size, 236 .iop_format = xfs_rud_item_format, 237 .iop_release = xfs_rud_item_release, 238 }; 239 240 static struct xfs_rud_log_item * 241 xfs_trans_get_rud( 242 struct xfs_trans *tp, 243 struct xfs_rui_log_item *ruip) 244 { 245 struct xfs_rud_log_item *rudp; 246 247 rudp = kmem_zone_zalloc(xfs_rud_zone, 0); 248 xfs_log_item_init(tp->t_mountp, &rudp->rud_item, XFS_LI_RUD, 249 &xfs_rud_item_ops); 250 rudp->rud_ruip = ruip; 251 rudp->rud_format.rud_rui_id = ruip->rui_format.rui_id; 252 253 xfs_trans_add_item(tp, &rudp->rud_item); 254 return rudp; 255 } 256 257 /* Set the map extent flags for this reverse mapping. */ 258 static void 259 xfs_trans_set_rmap_flags( 260 struct xfs_map_extent *rmap, 261 enum xfs_rmap_intent_type type, 262 int whichfork, 263 xfs_exntst_t state) 264 { 265 rmap->me_flags = 0; 266 if (state == XFS_EXT_UNWRITTEN) 267 rmap->me_flags |= XFS_RMAP_EXTENT_UNWRITTEN; 268 if (whichfork == XFS_ATTR_FORK) 269 rmap->me_flags |= XFS_RMAP_EXTENT_ATTR_FORK; 270 switch (type) { 271 case XFS_RMAP_MAP: 272 rmap->me_flags |= XFS_RMAP_EXTENT_MAP; 273 break; 274 case XFS_RMAP_MAP_SHARED: 275 rmap->me_flags |= XFS_RMAP_EXTENT_MAP_SHARED; 276 break; 277 case XFS_RMAP_UNMAP: 278 rmap->me_flags |= XFS_RMAP_EXTENT_UNMAP; 279 break; 280 case XFS_RMAP_UNMAP_SHARED: 281 rmap->me_flags |= XFS_RMAP_EXTENT_UNMAP_SHARED; 282 break; 283 case XFS_RMAP_CONVERT: 284 rmap->me_flags |= XFS_RMAP_EXTENT_CONVERT; 285 break; 286 case XFS_RMAP_CONVERT_SHARED: 287 rmap->me_flags |= XFS_RMAP_EXTENT_CONVERT_SHARED; 288 break; 289 case XFS_RMAP_ALLOC: 290 rmap->me_flags |= XFS_RMAP_EXTENT_ALLOC; 291 break; 292 case XFS_RMAP_FREE: 293 rmap->me_flags |= XFS_RMAP_EXTENT_FREE; 294 break; 295 default: 296 ASSERT(0); 297 } 298 } 299 300 /* 301 * Finish an rmap update and log it to the RUD. Note that the transaction is 302 * marked dirty regardless of whether the rmap update succeeds or fails to 303 * support the RUI/RUD lifecycle rules. 304 */ 305 static int 306 xfs_trans_log_finish_rmap_update( 307 struct xfs_trans *tp, 308 struct xfs_rud_log_item *rudp, 309 enum xfs_rmap_intent_type type, 310 uint64_t owner, 311 int whichfork, 312 xfs_fileoff_t startoff, 313 xfs_fsblock_t startblock, 314 xfs_filblks_t blockcount, 315 xfs_exntst_t state, 316 struct xfs_btree_cur **pcur) 317 { 318 int error; 319 320 error = xfs_rmap_finish_one(tp, type, owner, whichfork, startoff, 321 startblock, blockcount, state, pcur); 322 323 /* 324 * Mark the transaction dirty, even on error. This ensures the 325 * transaction is aborted, which: 326 * 327 * 1.) releases the RUI and frees the RUD 328 * 2.) shuts down the filesystem 329 */ 330 tp->t_flags |= XFS_TRANS_DIRTY; 331 set_bit(XFS_LI_DIRTY, &rudp->rud_item.li_flags); 332 333 return error; 334 } 335 336 /* Sort rmap intents by AG. */ 337 static int 338 xfs_rmap_update_diff_items( 339 void *priv, 340 struct list_head *a, 341 struct list_head *b) 342 { 343 struct xfs_mount *mp = priv; 344 struct xfs_rmap_intent *ra; 345 struct xfs_rmap_intent *rb; 346 347 ra = container_of(a, struct xfs_rmap_intent, ri_list); 348 rb = container_of(b, struct xfs_rmap_intent, ri_list); 349 return XFS_FSB_TO_AGNO(mp, ra->ri_bmap.br_startblock) - 350 XFS_FSB_TO_AGNO(mp, rb->ri_bmap.br_startblock); 351 } 352 353 /* Get an RUI. */ 354 STATIC void * 355 xfs_rmap_update_create_intent( 356 struct xfs_trans *tp, 357 unsigned int count) 358 { 359 struct xfs_rui_log_item *ruip; 360 361 ASSERT(tp != NULL); 362 ASSERT(count > 0); 363 364 ruip = xfs_rui_init(tp->t_mountp, count); 365 ASSERT(ruip != NULL); 366 367 /* 368 * Get a log_item_desc to point at the new item. 369 */ 370 xfs_trans_add_item(tp, &ruip->rui_item); 371 return ruip; 372 } 373 374 /* Log rmap updates in the intent item. */ 375 STATIC void 376 xfs_rmap_update_log_item( 377 struct xfs_trans *tp, 378 void *intent, 379 struct list_head *item) 380 { 381 struct xfs_rui_log_item *ruip = intent; 382 struct xfs_rmap_intent *rmap; 383 uint next_extent; 384 struct xfs_map_extent *map; 385 386 rmap = container_of(item, struct xfs_rmap_intent, ri_list); 387 388 tp->t_flags |= XFS_TRANS_DIRTY; 389 set_bit(XFS_LI_DIRTY, &ruip->rui_item.li_flags); 390 391 /* 392 * atomic_inc_return gives us the value after the increment; 393 * we want to use it as an array index so we need to subtract 1 from 394 * it. 395 */ 396 next_extent = atomic_inc_return(&ruip->rui_next_extent) - 1; 397 ASSERT(next_extent < ruip->rui_format.rui_nextents); 398 map = &ruip->rui_format.rui_extents[next_extent]; 399 map->me_owner = rmap->ri_owner; 400 map->me_startblock = rmap->ri_bmap.br_startblock; 401 map->me_startoff = rmap->ri_bmap.br_startoff; 402 map->me_len = rmap->ri_bmap.br_blockcount; 403 xfs_trans_set_rmap_flags(map, rmap->ri_type, rmap->ri_whichfork, 404 rmap->ri_bmap.br_state); 405 } 406 407 /* Get an RUD so we can process all the deferred rmap updates. */ 408 STATIC void * 409 xfs_rmap_update_create_done( 410 struct xfs_trans *tp, 411 void *intent, 412 unsigned int count) 413 { 414 return xfs_trans_get_rud(tp, intent); 415 } 416 417 /* Process a deferred rmap update. */ 418 STATIC int 419 xfs_rmap_update_finish_item( 420 struct xfs_trans *tp, 421 struct list_head *item, 422 void *done_item, 423 void **state) 424 { 425 struct xfs_rmap_intent *rmap; 426 int error; 427 428 rmap = container_of(item, struct xfs_rmap_intent, ri_list); 429 error = xfs_trans_log_finish_rmap_update(tp, done_item, 430 rmap->ri_type, 431 rmap->ri_owner, rmap->ri_whichfork, 432 rmap->ri_bmap.br_startoff, 433 rmap->ri_bmap.br_startblock, 434 rmap->ri_bmap.br_blockcount, 435 rmap->ri_bmap.br_state, 436 (struct xfs_btree_cur **)state); 437 kmem_free(rmap); 438 return error; 439 } 440 441 /* Clean up after processing deferred rmaps. */ 442 STATIC void 443 xfs_rmap_update_finish_cleanup( 444 struct xfs_trans *tp, 445 void *state, 446 int error) 447 { 448 struct xfs_btree_cur *rcur = state; 449 450 xfs_rmap_finish_one_cleanup(tp, rcur, error); 451 } 452 453 /* Abort all pending RUIs. */ 454 STATIC void 455 xfs_rmap_update_abort_intent( 456 void *intent) 457 { 458 xfs_rui_release(intent); 459 } 460 461 /* Cancel a deferred rmap update. */ 462 STATIC void 463 xfs_rmap_update_cancel_item( 464 struct list_head *item) 465 { 466 struct xfs_rmap_intent *rmap; 467 468 rmap = container_of(item, struct xfs_rmap_intent, ri_list); 469 kmem_free(rmap); 470 } 471 472 const struct xfs_defer_op_type xfs_rmap_update_defer_type = { 473 .max_items = XFS_RUI_MAX_FAST_EXTENTS, 474 .diff_items = xfs_rmap_update_diff_items, 475 .create_intent = xfs_rmap_update_create_intent, 476 .abort_intent = xfs_rmap_update_abort_intent, 477 .log_item = xfs_rmap_update_log_item, 478 .create_done = xfs_rmap_update_create_done, 479 .finish_item = xfs_rmap_update_finish_item, 480 .finish_cleanup = xfs_rmap_update_finish_cleanup, 481 .cancel_item = xfs_rmap_update_cancel_item, 482 }; 483 484 /* 485 * Process an rmap update intent item that was recovered from the log. 486 * We need to update the rmapbt. 487 */ 488 int 489 xfs_rui_recover( 490 struct xfs_mount *mp, 491 struct xfs_rui_log_item *ruip) 492 { 493 int i; 494 int error = 0; 495 struct xfs_map_extent *rmap; 496 xfs_fsblock_t startblock_fsb; 497 bool op_ok; 498 struct xfs_rud_log_item *rudp; 499 enum xfs_rmap_intent_type type; 500 int whichfork; 501 xfs_exntst_t state; 502 struct xfs_trans *tp; 503 struct xfs_btree_cur *rcur = NULL; 504 505 ASSERT(!test_bit(XFS_RUI_RECOVERED, &ruip->rui_flags)); 506 507 /* 508 * First check the validity of the extents described by the 509 * RUI. If any are bad, then assume that all are bad and 510 * just toss the RUI. 511 */ 512 for (i = 0; i < ruip->rui_format.rui_nextents; i++) { 513 rmap = &ruip->rui_format.rui_extents[i]; 514 startblock_fsb = XFS_BB_TO_FSB(mp, 515 XFS_FSB_TO_DADDR(mp, rmap->me_startblock)); 516 switch (rmap->me_flags & XFS_RMAP_EXTENT_TYPE_MASK) { 517 case XFS_RMAP_EXTENT_MAP: 518 case XFS_RMAP_EXTENT_MAP_SHARED: 519 case XFS_RMAP_EXTENT_UNMAP: 520 case XFS_RMAP_EXTENT_UNMAP_SHARED: 521 case XFS_RMAP_EXTENT_CONVERT: 522 case XFS_RMAP_EXTENT_CONVERT_SHARED: 523 case XFS_RMAP_EXTENT_ALLOC: 524 case XFS_RMAP_EXTENT_FREE: 525 op_ok = true; 526 break; 527 default: 528 op_ok = false; 529 break; 530 } 531 if (!op_ok || startblock_fsb == 0 || 532 rmap->me_len == 0 || 533 startblock_fsb >= mp->m_sb.sb_dblocks || 534 rmap->me_len >= mp->m_sb.sb_agblocks || 535 (rmap->me_flags & ~XFS_RMAP_EXTENT_FLAGS)) { 536 /* 537 * This will pull the RUI from the AIL and 538 * free the memory associated with it. 539 */ 540 set_bit(XFS_RUI_RECOVERED, &ruip->rui_flags); 541 xfs_rui_release(ruip); 542 return -EIO; 543 } 544 } 545 546 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 547 mp->m_rmap_maxlevels, 0, XFS_TRANS_RESERVE, &tp); 548 if (error) 549 return error; 550 rudp = xfs_trans_get_rud(tp, ruip); 551 552 for (i = 0; i < ruip->rui_format.rui_nextents; i++) { 553 rmap = &ruip->rui_format.rui_extents[i]; 554 state = (rmap->me_flags & XFS_RMAP_EXTENT_UNWRITTEN) ? 555 XFS_EXT_UNWRITTEN : XFS_EXT_NORM; 556 whichfork = (rmap->me_flags & XFS_RMAP_EXTENT_ATTR_FORK) ? 557 XFS_ATTR_FORK : XFS_DATA_FORK; 558 switch (rmap->me_flags & XFS_RMAP_EXTENT_TYPE_MASK) { 559 case XFS_RMAP_EXTENT_MAP: 560 type = XFS_RMAP_MAP; 561 break; 562 case XFS_RMAP_EXTENT_MAP_SHARED: 563 type = XFS_RMAP_MAP_SHARED; 564 break; 565 case XFS_RMAP_EXTENT_UNMAP: 566 type = XFS_RMAP_UNMAP; 567 break; 568 case XFS_RMAP_EXTENT_UNMAP_SHARED: 569 type = XFS_RMAP_UNMAP_SHARED; 570 break; 571 case XFS_RMAP_EXTENT_CONVERT: 572 type = XFS_RMAP_CONVERT; 573 break; 574 case XFS_RMAP_EXTENT_CONVERT_SHARED: 575 type = XFS_RMAP_CONVERT_SHARED; 576 break; 577 case XFS_RMAP_EXTENT_ALLOC: 578 type = XFS_RMAP_ALLOC; 579 break; 580 case XFS_RMAP_EXTENT_FREE: 581 type = XFS_RMAP_FREE; 582 break; 583 default: 584 error = -EFSCORRUPTED; 585 goto abort_error; 586 } 587 error = xfs_trans_log_finish_rmap_update(tp, rudp, type, 588 rmap->me_owner, whichfork, 589 rmap->me_startoff, rmap->me_startblock, 590 rmap->me_len, state, &rcur); 591 if (error) 592 goto abort_error; 593 594 } 595 596 xfs_rmap_finish_one_cleanup(tp, rcur, error); 597 set_bit(XFS_RUI_RECOVERED, &ruip->rui_flags); 598 error = xfs_trans_commit(tp); 599 return error; 600 601 abort_error: 602 xfs_rmap_finish_one_cleanup(tp, rcur, error); 603 xfs_trans_cancel(tp); 604 return error; 605 } 606