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_inode.h" 16#include "xfs_trans.h" 17#include "xfs_trans_priv.h" 18#include "xfs_bmap_item.h" 19#include "xfs_log.h" 20#include "xfs_bmap.h" 21#include "xfs_icache.h" 22#include "xfs_bmap_btree.h" 23#include "xfs_trans_space.h" 24#include "xfs_error.h" 25#include "xfs_log_priv.h" 26#include "xfs_log_recover.h" 27#include "xfs_ag.h" 28#include "xfs_trace.h" 29 30struct kmem_cache *xfs_bui_cache; 31struct kmem_cache *xfs_bud_cache; 32 33static const struct xfs_item_ops xfs_bui_item_ops; 34 35static inline struct xfs_bui_log_item *BUI_ITEM(struct xfs_log_item *lip) 36{ 37 return container_of(lip, struct xfs_bui_log_item, bui_item); 38} 39 40STATIC void 41xfs_bui_item_free( 42 struct xfs_bui_log_item *buip) 43{ 44 kvfree(buip->bui_item.li_lv_shadow); 45 kmem_cache_free(xfs_bui_cache, buip); 46} 47 48/* 49 * Freeing the BUI requires that we remove it from the AIL if it has already 50 * been placed there. However, the BUI may not yet have been placed in the AIL 51 * when called by xfs_bui_release() from BUD processing due to the ordering of 52 * committed vs unpin operations in bulk insert operations. Hence the reference 53 * count to ensure only the last caller frees the BUI. 54 */ 55STATIC void 56xfs_bui_release( 57 struct xfs_bui_log_item *buip) 58{ 59 ASSERT(atomic_read(&buip->bui_refcount) > 0); 60 if (!atomic_dec_and_test(&buip->bui_refcount)) 61 return; 62 63 xfs_trans_ail_delete(&buip->bui_item, 0); 64 xfs_bui_item_free(buip); 65} 66 67 68STATIC void 69xfs_bui_item_size( 70 struct xfs_log_item *lip, 71 int *nvecs, 72 int *nbytes) 73{ 74 struct xfs_bui_log_item *buip = BUI_ITEM(lip); 75 76 *nvecs += 1; 77 *nbytes += xfs_bui_log_format_sizeof(buip->bui_format.bui_nextents); 78} 79 80/* 81 * This is called to fill in the vector of log iovecs for the 82 * given bui log item. We use only 1 iovec, and we point that 83 * at the bui_log_format structure embedded in the bui item. 84 * It is at this point that we assert that all of the extent 85 * slots in the bui item have been filled. 86 */ 87STATIC void 88xfs_bui_item_format( 89 struct xfs_log_item *lip, 90 struct xfs_log_vec *lv) 91{ 92 struct xfs_bui_log_item *buip = BUI_ITEM(lip); 93 struct xfs_log_iovec *vecp = NULL; 94 95 ASSERT(atomic_read(&buip->bui_next_extent) == 96 buip->bui_format.bui_nextents); 97 98 buip->bui_format.bui_type = XFS_LI_BUI; 99 buip->bui_format.bui_size = 1; 100 101 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_BUI_FORMAT, &buip->bui_format, 102 xfs_bui_log_format_sizeof(buip->bui_format.bui_nextents)); 103} 104 105/* 106 * The unpin operation is the last place an BUI is manipulated in the log. It is 107 * either inserted in the AIL or aborted in the event of a log I/O error. In 108 * either case, the BUI transaction has been successfully committed to make it 109 * this far. Therefore, we expect whoever committed the BUI to either construct 110 * and commit the BUD or drop the BUD's reference in the event of error. Simply 111 * drop the log's BUI reference now that the log is done with it. 112 */ 113STATIC void 114xfs_bui_item_unpin( 115 struct xfs_log_item *lip, 116 int remove) 117{ 118 struct xfs_bui_log_item *buip = BUI_ITEM(lip); 119 120 xfs_bui_release(buip); 121} 122 123/* 124 * The BUI has been either committed or aborted if the transaction has been 125 * cancelled. If the transaction was cancelled, an BUD isn't going to be 126 * constructed and thus we free the BUI here directly. 127 */ 128STATIC void 129xfs_bui_item_release( 130 struct xfs_log_item *lip) 131{ 132 xfs_bui_release(BUI_ITEM(lip)); 133} 134 135/* 136 * Allocate and initialize an bui item with the given number of extents. 137 */ 138STATIC struct xfs_bui_log_item * 139xfs_bui_init( 140 struct xfs_mount *mp) 141 142{ 143 struct xfs_bui_log_item *buip; 144 145 buip = kmem_cache_zalloc(xfs_bui_cache, GFP_KERNEL | __GFP_NOFAIL); 146 147 xfs_log_item_init(mp, &buip->bui_item, XFS_LI_BUI, &xfs_bui_item_ops); 148 buip->bui_format.bui_nextents = XFS_BUI_MAX_FAST_EXTENTS; 149 buip->bui_format.bui_id = (uintptr_t)(void *)buip; 150 atomic_set(&buip->bui_next_extent, 0); 151 atomic_set(&buip->bui_refcount, 2); 152 153 return buip; 154} 155 156static inline struct xfs_bud_log_item *BUD_ITEM(struct xfs_log_item *lip) 157{ 158 return container_of(lip, struct xfs_bud_log_item, bud_item); 159} 160 161STATIC void 162xfs_bud_item_size( 163 struct xfs_log_item *lip, 164 int *nvecs, 165 int *nbytes) 166{ 167 *nvecs += 1; 168 *nbytes += sizeof(struct xfs_bud_log_format); 169} 170 171/* 172 * This is called to fill in the vector of log iovecs for the 173 * given bud log item. We use only 1 iovec, and we point that 174 * at the bud_log_format structure embedded in the bud item. 175 * It is at this point that we assert that all of the extent 176 * slots in the bud item have been filled. 177 */ 178STATIC void 179xfs_bud_item_format( 180 struct xfs_log_item *lip, 181 struct xfs_log_vec *lv) 182{ 183 struct xfs_bud_log_item *budp = BUD_ITEM(lip); 184 struct xfs_log_iovec *vecp = NULL; 185 186 budp->bud_format.bud_type = XFS_LI_BUD; 187 budp->bud_format.bud_size = 1; 188 189 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_BUD_FORMAT, &budp->bud_format, 190 sizeof(struct xfs_bud_log_format)); 191} 192 193/* 194 * The BUD is either committed or aborted if the transaction is cancelled. If 195 * the transaction is cancelled, drop our reference to the BUI and free the 196 * BUD. 197 */ 198STATIC void 199xfs_bud_item_release( 200 struct xfs_log_item *lip) 201{ 202 struct xfs_bud_log_item *budp = BUD_ITEM(lip); 203 204 xfs_bui_release(budp->bud_buip); 205 kvfree(budp->bud_item.li_lv_shadow); 206 kmem_cache_free(xfs_bud_cache, budp); 207} 208 209static struct xfs_log_item * 210xfs_bud_item_intent( 211 struct xfs_log_item *lip) 212{ 213 return &BUD_ITEM(lip)->bud_buip->bui_item; 214} 215 216static const struct xfs_item_ops xfs_bud_item_ops = { 217 .flags = XFS_ITEM_RELEASE_WHEN_COMMITTED | 218 XFS_ITEM_INTENT_DONE, 219 .iop_size = xfs_bud_item_size, 220 .iop_format = xfs_bud_item_format, 221 .iop_release = xfs_bud_item_release, 222 .iop_intent = xfs_bud_item_intent, 223}; 224 225static inline struct xfs_bmap_intent *bi_entry(const struct list_head *e) 226{ 227 return list_entry(e, struct xfs_bmap_intent, bi_list); 228} 229 230/* Sort bmap intents by inode. */ 231static int 232xfs_bmap_update_diff_items( 233 void *priv, 234 const struct list_head *a, 235 const struct list_head *b) 236{ 237 struct xfs_bmap_intent *ba = bi_entry(a); 238 struct xfs_bmap_intent *bb = bi_entry(b); 239 240 return ba->bi_owner->i_ino - bb->bi_owner->i_ino; 241} 242 243/* Log bmap updates in the intent item. */ 244STATIC void 245xfs_bmap_update_log_item( 246 struct xfs_trans *tp, 247 struct xfs_bui_log_item *buip, 248 struct xfs_bmap_intent *bi) 249{ 250 uint next_extent; 251 struct xfs_map_extent *map; 252 253 /* 254 * atomic_inc_return gives us the value after the increment; 255 * we want to use it as an array index so we need to subtract 1 from 256 * it. 257 */ 258 next_extent = atomic_inc_return(&buip->bui_next_extent) - 1; 259 ASSERT(next_extent < buip->bui_format.bui_nextents); 260 map = &buip->bui_format.bui_extents[next_extent]; 261 map->me_owner = bi->bi_owner->i_ino; 262 map->me_startblock = bi->bi_bmap.br_startblock; 263 map->me_startoff = bi->bi_bmap.br_startoff; 264 map->me_len = bi->bi_bmap.br_blockcount; 265 266 switch (bi->bi_type) { 267 case XFS_BMAP_MAP: 268 case XFS_BMAP_UNMAP: 269 map->me_flags = bi->bi_type; 270 break; 271 default: 272 ASSERT(0); 273 } 274 if (bi->bi_bmap.br_state == XFS_EXT_UNWRITTEN) 275 map->me_flags |= XFS_BMAP_EXTENT_UNWRITTEN; 276 if (bi->bi_whichfork == XFS_ATTR_FORK) 277 map->me_flags |= XFS_BMAP_EXTENT_ATTR_FORK; 278 if (xfs_ifork_is_realtime(bi->bi_owner, bi->bi_whichfork)) 279 map->me_flags |= XFS_BMAP_EXTENT_REALTIME; 280} 281 282static struct xfs_log_item * 283xfs_bmap_update_create_intent( 284 struct xfs_trans *tp, 285 struct list_head *items, 286 unsigned int count, 287 bool sort) 288{ 289 struct xfs_mount *mp = tp->t_mountp; 290 struct xfs_bui_log_item *buip = xfs_bui_init(mp); 291 struct xfs_bmap_intent *bi; 292 293 ASSERT(count == XFS_BUI_MAX_FAST_EXTENTS); 294 295 if (sort) 296 list_sort(mp, items, xfs_bmap_update_diff_items); 297 list_for_each_entry(bi, items, bi_list) 298 xfs_bmap_update_log_item(tp, buip, bi); 299 return &buip->bui_item; 300} 301 302/* Get an BUD so we can process all the deferred bmap updates. */ 303static struct xfs_log_item * 304xfs_bmap_update_create_done( 305 struct xfs_trans *tp, 306 struct xfs_log_item *intent, 307 unsigned int count) 308{ 309 struct xfs_bui_log_item *buip = BUI_ITEM(intent); 310 struct xfs_bud_log_item *budp; 311 312 budp = kmem_cache_zalloc(xfs_bud_cache, GFP_KERNEL | __GFP_NOFAIL); 313 xfs_log_item_init(tp->t_mountp, &budp->bud_item, XFS_LI_BUD, 314 &xfs_bud_item_ops); 315 budp->bud_buip = buip; 316 budp->bud_format.bud_bui_id = buip->bui_format.bui_id; 317 318 return &budp->bud_item; 319} 320 321/* Take a passive ref to the AG containing the space we're mapping. */ 322static inline void 323xfs_bmap_update_get_group( 324 struct xfs_mount *mp, 325 struct xfs_bmap_intent *bi) 326{ 327 xfs_agnumber_t agno; 328 329 if (xfs_ifork_is_realtime(bi->bi_owner, bi->bi_whichfork)) 330 return; 331 332 agno = XFS_FSB_TO_AGNO(mp, bi->bi_bmap.br_startblock); 333 334 /* 335 * Bump the intent count on behalf of the deferred rmap and refcount 336 * intent items that that we can queue when we finish this bmap work. 337 * This new intent item will bump the intent count before the bmap 338 * intent drops the intent count, ensuring that the intent count 339 * remains nonzero across the transaction roll. 340 */ 341 bi->bi_pag = xfs_perag_intent_get(mp, agno); 342} 343 344/* Add this deferred BUI to the transaction. */ 345void 346xfs_bmap_defer_add( 347 struct xfs_trans *tp, 348 struct xfs_bmap_intent *bi) 349{ 350 trace_xfs_bmap_defer(bi); 351 352 xfs_bmap_update_get_group(tp->t_mountp, bi); 353 xfs_defer_add(tp, &bi->bi_list, &xfs_bmap_update_defer_type); 354} 355 356/* Release a passive AG ref after finishing mapping work. */ 357static inline void 358xfs_bmap_update_put_group( 359 struct xfs_bmap_intent *bi) 360{ 361 if (xfs_ifork_is_realtime(bi->bi_owner, bi->bi_whichfork)) 362 return; 363 364 xfs_perag_intent_put(bi->bi_pag); 365} 366 367/* Cancel a deferred bmap update. */ 368STATIC void 369xfs_bmap_update_cancel_item( 370 struct list_head *item) 371{ 372 struct xfs_bmap_intent *bi = bi_entry(item); 373 374 xfs_bmap_update_put_group(bi); 375 kmem_cache_free(xfs_bmap_intent_cache, bi); 376} 377 378/* Process a deferred bmap update. */ 379STATIC int 380xfs_bmap_update_finish_item( 381 struct xfs_trans *tp, 382 struct xfs_log_item *done, 383 struct list_head *item, 384 struct xfs_btree_cur **state) 385{ 386 struct xfs_bmap_intent *bi = bi_entry(item); 387 int error; 388 389 error = xfs_bmap_finish_one(tp, bi); 390 if (!error && bi->bi_bmap.br_blockcount > 0) { 391 ASSERT(bi->bi_type == XFS_BMAP_UNMAP); 392 return -EAGAIN; 393 } 394 395 xfs_bmap_update_cancel_item(item); 396 return error; 397} 398 399/* Abort all pending BUIs. */ 400STATIC void 401xfs_bmap_update_abort_intent( 402 struct xfs_log_item *intent) 403{ 404 xfs_bui_release(BUI_ITEM(intent)); 405} 406 407/* Is this recovered BUI ok? */ 408static inline bool 409xfs_bui_validate( 410 struct xfs_mount *mp, 411 struct xfs_bui_log_item *buip) 412{ 413 struct xfs_map_extent *map; 414 415 /* Only one mapping operation per BUI... */ 416 if (buip->bui_format.bui_nextents != XFS_BUI_MAX_FAST_EXTENTS) 417 return false; 418 419 map = &buip->bui_format.bui_extents[0]; 420 421 if (map->me_flags & ~XFS_BMAP_EXTENT_FLAGS) 422 return false; 423 424 switch (map->me_flags & XFS_BMAP_EXTENT_TYPE_MASK) { 425 case XFS_BMAP_MAP: 426 case XFS_BMAP_UNMAP: 427 break; 428 default: 429 return false; 430 } 431 432 if (!xfs_verify_ino(mp, map->me_owner)) 433 return false; 434 435 if (!xfs_verify_fileext(mp, map->me_startoff, map->me_len)) 436 return false; 437 438 if (map->me_flags & XFS_BMAP_EXTENT_REALTIME) 439 return xfs_verify_rtbext(mp, map->me_startblock, map->me_len); 440 441 return xfs_verify_fsbext(mp, map->me_startblock, map->me_len); 442} 443 444static inline struct xfs_bmap_intent * 445xfs_bui_recover_work( 446 struct xfs_mount *mp, 447 struct xfs_defer_pending *dfp, 448 struct xfs_inode **ipp, 449 struct xfs_map_extent *map) 450{ 451 struct xfs_bmap_intent *bi; 452 int error; 453 454 error = xlog_recover_iget(mp, map->me_owner, ipp); 455 if (error) 456 return ERR_PTR(error); 457 458 bi = kmem_cache_zalloc(xfs_bmap_intent_cache, 459 GFP_KERNEL | __GFP_NOFAIL); 460 bi->bi_whichfork = (map->me_flags & XFS_BMAP_EXTENT_ATTR_FORK) ? 461 XFS_ATTR_FORK : XFS_DATA_FORK; 462 bi->bi_type = map->me_flags & XFS_BMAP_EXTENT_TYPE_MASK; 463 bi->bi_bmap.br_startblock = map->me_startblock; 464 bi->bi_bmap.br_startoff = map->me_startoff; 465 bi->bi_bmap.br_blockcount = map->me_len; 466 bi->bi_bmap.br_state = (map->me_flags & XFS_BMAP_EXTENT_UNWRITTEN) ? 467 XFS_EXT_UNWRITTEN : XFS_EXT_NORM; 468 bi->bi_owner = *ipp; 469 xfs_bmap_update_get_group(mp, bi); 470 471 xfs_defer_add_item(dfp, &bi->bi_list); 472 return bi; 473} 474 475/* 476 * Process a bmap update intent item that was recovered from the log. 477 * We need to update some inode's bmbt. 478 */ 479STATIC int 480xfs_bmap_recover_work( 481 struct xfs_defer_pending *dfp, 482 struct list_head *capture_list) 483{ 484 struct xfs_trans_res resv; 485 struct xfs_log_item *lip = dfp->dfp_intent; 486 struct xfs_bui_log_item *buip = BUI_ITEM(lip); 487 struct xfs_trans *tp; 488 struct xfs_inode *ip = NULL; 489 struct xfs_mount *mp = lip->li_log->l_mp; 490 struct xfs_map_extent *map; 491 struct xfs_bmap_intent *work; 492 int iext_delta; 493 int error = 0; 494 495 if (!xfs_bui_validate(mp, buip)) { 496 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, 497 &buip->bui_format, sizeof(buip->bui_format)); 498 return -EFSCORRUPTED; 499 } 500 501 map = &buip->bui_format.bui_extents[0]; 502 work = xfs_bui_recover_work(mp, dfp, &ip, map); 503 if (IS_ERR(work)) 504 return PTR_ERR(work); 505 506 /* Allocate transaction and do the work. */ 507 resv = xlog_recover_resv(&M_RES(mp)->tr_itruncate); 508 error = xfs_trans_alloc(mp, &resv, 509 XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK), 0, 0, &tp); 510 if (error) 511 goto err_rele; 512 513 xfs_ilock(ip, XFS_ILOCK_EXCL); 514 xfs_trans_ijoin(tp, ip, 0); 515 516 if (!!(map->me_flags & XFS_BMAP_EXTENT_REALTIME) != 517 xfs_ifork_is_realtime(ip, work->bi_whichfork)) { 518 error = -EFSCORRUPTED; 519 goto err_cancel; 520 } 521 522 if (work->bi_type == XFS_BMAP_MAP) 523 iext_delta = XFS_IEXT_ADD_NOSPLIT_CNT; 524 else 525 iext_delta = XFS_IEXT_PUNCH_HOLE_CNT; 526 527 error = xfs_iext_count_may_overflow(ip, work->bi_whichfork, iext_delta); 528 if (error == -EFBIG) 529 error = xfs_iext_count_upgrade(tp, ip, iext_delta); 530 if (error) 531 goto err_cancel; 532 533 error = xlog_recover_finish_intent(tp, dfp); 534 if (error == -EFSCORRUPTED) 535 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, 536 &buip->bui_format, sizeof(buip->bui_format)); 537 if (error) 538 goto err_cancel; 539 540 /* 541 * Commit transaction, which frees the transaction and saves the inode 542 * for later replay activities. 543 */ 544 error = xfs_defer_ops_capture_and_commit(tp, capture_list); 545 if (error) 546 goto err_unlock; 547 548 xfs_iunlock(ip, XFS_ILOCK_EXCL); 549 xfs_irele(ip); 550 return 0; 551 552err_cancel: 553 xfs_trans_cancel(tp); 554err_unlock: 555 xfs_iunlock(ip, XFS_ILOCK_EXCL); 556err_rele: 557 xfs_irele(ip); 558 return error; 559} 560 561/* Relog an intent item to push the log tail forward. */ 562static struct xfs_log_item * 563xfs_bmap_relog_intent( 564 struct xfs_trans *tp, 565 struct xfs_log_item *intent, 566 struct xfs_log_item *done_item) 567{ 568 struct xfs_bui_log_item *buip; 569 struct xfs_map_extent *map; 570 unsigned int count; 571 572 count = BUI_ITEM(intent)->bui_format.bui_nextents; 573 map = BUI_ITEM(intent)->bui_format.bui_extents; 574 575 buip = xfs_bui_init(tp->t_mountp); 576 memcpy(buip->bui_format.bui_extents, map, count * sizeof(*map)); 577 atomic_set(&buip->bui_next_extent, count); 578 579 return &buip->bui_item; 580} 581 582const struct xfs_defer_op_type xfs_bmap_update_defer_type = { 583 .name = "bmap", 584 .max_items = XFS_BUI_MAX_FAST_EXTENTS, 585 .create_intent = xfs_bmap_update_create_intent, 586 .abort_intent = xfs_bmap_update_abort_intent, 587 .create_done = xfs_bmap_update_create_done, 588 .finish_item = xfs_bmap_update_finish_item, 589 .cancel_item = xfs_bmap_update_cancel_item, 590 .recover_work = xfs_bmap_recover_work, 591 .relog_intent = xfs_bmap_relog_intent, 592}; 593 594STATIC bool 595xfs_bui_item_match( 596 struct xfs_log_item *lip, 597 uint64_t intent_id) 598{ 599 return BUI_ITEM(lip)->bui_format.bui_id == intent_id; 600} 601 602static const struct xfs_item_ops xfs_bui_item_ops = { 603 .flags = XFS_ITEM_INTENT, 604 .iop_size = xfs_bui_item_size, 605 .iop_format = xfs_bui_item_format, 606 .iop_unpin = xfs_bui_item_unpin, 607 .iop_release = xfs_bui_item_release, 608 .iop_match = xfs_bui_item_match, 609}; 610 611static inline void 612xfs_bui_copy_format( 613 struct xfs_bui_log_format *dst, 614 const struct xfs_bui_log_format *src) 615{ 616 unsigned int i; 617 618 memcpy(dst, src, offsetof(struct xfs_bui_log_format, bui_extents)); 619 620 for (i = 0; i < src->bui_nextents; i++) 621 memcpy(&dst->bui_extents[i], &src->bui_extents[i], 622 sizeof(struct xfs_map_extent)); 623} 624 625/* 626 * This routine is called to create an in-core extent bmap update 627 * item from the bui format structure which was logged on disk. 628 * It allocates an in-core bui, copies the extents from the format 629 * structure into it, and adds the bui to the AIL with the given 630 * LSN. 631 */ 632STATIC int 633xlog_recover_bui_commit_pass2( 634 struct xlog *log, 635 struct list_head *buffer_list, 636 struct xlog_recover_item *item, 637 xfs_lsn_t lsn) 638{ 639 struct xfs_mount *mp = log->l_mp; 640 struct xfs_bui_log_item *buip; 641 struct xfs_bui_log_format *bui_formatp; 642 size_t len; 643 644 bui_formatp = item->ri_buf[0].i_addr; 645 646 if (item->ri_buf[0].i_len < xfs_bui_log_format_sizeof(0)) { 647 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, 648 item->ri_buf[0].i_addr, item->ri_buf[0].i_len); 649 return -EFSCORRUPTED; 650 } 651 652 if (bui_formatp->bui_nextents != XFS_BUI_MAX_FAST_EXTENTS) { 653 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, 654 item->ri_buf[0].i_addr, item->ri_buf[0].i_len); 655 return -EFSCORRUPTED; 656 } 657 658 len = xfs_bui_log_format_sizeof(bui_formatp->bui_nextents); 659 if (item->ri_buf[0].i_len != len) { 660 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, 661 item->ri_buf[0].i_addr, item->ri_buf[0].i_len); 662 return -EFSCORRUPTED; 663 } 664 665 buip = xfs_bui_init(mp); 666 xfs_bui_copy_format(&buip->bui_format, bui_formatp); 667 atomic_set(&buip->bui_next_extent, bui_formatp->bui_nextents); 668 669 xlog_recover_intent_item(log, &buip->bui_item, lsn, 670 &xfs_bmap_update_defer_type); 671 return 0; 672} 673 674const struct xlog_recover_item_ops xlog_bui_item_ops = { 675 .item_type = XFS_LI_BUI, 676 .commit_pass2 = xlog_recover_bui_commit_pass2, 677}; 678 679/* 680 * This routine is called when an BUD format structure is found in a committed 681 * transaction in the log. Its purpose is to cancel the corresponding BUI if it 682 * was still in the log. To do this it searches the AIL for the BUI with an id 683 * equal to that in the BUD format structure. If we find it we drop the BUD 684 * reference, which removes the BUI from the AIL and frees it. 685 */ 686STATIC int 687xlog_recover_bud_commit_pass2( 688 struct xlog *log, 689 struct list_head *buffer_list, 690 struct xlog_recover_item *item, 691 xfs_lsn_t lsn) 692{ 693 struct xfs_bud_log_format *bud_formatp; 694 695 bud_formatp = item->ri_buf[0].i_addr; 696 if (item->ri_buf[0].i_len != sizeof(struct xfs_bud_log_format)) { 697 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp, 698 item->ri_buf[0].i_addr, item->ri_buf[0].i_len); 699 return -EFSCORRUPTED; 700 } 701 702 xlog_recover_release_intent(log, XFS_LI_BUI, bud_formatp->bud_bui_id); 703 return 0; 704} 705 706const struct xlog_recover_item_ops xlog_bud_item_ops = { 707 .item_type = XFS_LI_BUD, 708 .commit_pass2 = xlog_recover_bud_commit_pass2, 709}; 710