1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2000-2006 Silicon Graphics, Inc. 4 * All Rights Reserved. 5 */ 6 #include "xfs.h" 7 #include "xfs_fs.h" 8 #include "xfs_shared.h" 9 #include "xfs_format.h" 10 #include "xfs_log_format.h" 11 #include "xfs_trans_resv.h" 12 #include "xfs_bit.h" 13 #include "xfs_mount.h" 14 #include "xfs_trans.h" 15 #include "xfs_buf_item.h" 16 #include "xfs_trans_priv.h" 17 #include "xfs_trace.h" 18 #include "xfs_log.h" 19 #include "xfs_log_priv.h" 20 #include "xfs_log_recover.h" 21 #include "xfs_error.h" 22 #include "xfs_inode.h" 23 #include "xfs_dir2.h" 24 #include "xfs_quota.h" 25 26 /* 27 * This structure is used during recovery to record the buf log items which 28 * have been canceled and should not be replayed. 29 */ 30 struct xfs_buf_cancel { 31 xfs_daddr_t bc_blkno; 32 uint bc_len; 33 int bc_refcount; 34 struct list_head bc_list; 35 }; 36 37 static struct xfs_buf_cancel * 38 xlog_find_buffer_cancelled( 39 struct xlog *log, 40 xfs_daddr_t blkno, 41 uint len) 42 { 43 struct list_head *bucket; 44 struct xfs_buf_cancel *bcp; 45 46 if (!log->l_buf_cancel_table) 47 return NULL; 48 49 bucket = XLOG_BUF_CANCEL_BUCKET(log, blkno); 50 list_for_each_entry(bcp, bucket, bc_list) { 51 if (bcp->bc_blkno == blkno && bcp->bc_len == len) 52 return bcp; 53 } 54 55 return NULL; 56 } 57 58 static bool 59 xlog_add_buffer_cancelled( 60 struct xlog *log, 61 xfs_daddr_t blkno, 62 uint len) 63 { 64 struct xfs_buf_cancel *bcp; 65 66 /* 67 * If we find an existing cancel record, this indicates that the buffer 68 * was cancelled multiple times. To ensure that during pass 2 we keep 69 * the record in the table until we reach its last occurrence in the 70 * log, a reference count is kept to tell how many times we expect to 71 * see this record during the second pass. 72 */ 73 bcp = xlog_find_buffer_cancelled(log, blkno, len); 74 if (bcp) { 75 bcp->bc_refcount++; 76 return false; 77 } 78 79 bcp = kmem_alloc(sizeof(struct xfs_buf_cancel), 0); 80 bcp->bc_blkno = blkno; 81 bcp->bc_len = len; 82 bcp->bc_refcount = 1; 83 list_add_tail(&bcp->bc_list, XLOG_BUF_CANCEL_BUCKET(log, blkno)); 84 return true; 85 } 86 87 /* 88 * Check if there is and entry for blkno, len in the buffer cancel record table. 89 */ 90 bool 91 xlog_is_buffer_cancelled( 92 struct xlog *log, 93 xfs_daddr_t blkno, 94 uint len) 95 { 96 return xlog_find_buffer_cancelled(log, blkno, len) != NULL; 97 } 98 99 /* 100 * Check if there is and entry for blkno, len in the buffer cancel record table, 101 * and decremented the reference count on it if there is one. 102 * 103 * Remove the cancel record once the refcount hits zero, so that if the same 104 * buffer is re-used again after its last cancellation we actually replay the 105 * changes made at that point. 106 */ 107 static bool 108 xlog_put_buffer_cancelled( 109 struct xlog *log, 110 xfs_daddr_t blkno, 111 uint len) 112 { 113 struct xfs_buf_cancel *bcp; 114 115 bcp = xlog_find_buffer_cancelled(log, blkno, len); 116 if (!bcp) { 117 ASSERT(0); 118 return false; 119 } 120 121 if (--bcp->bc_refcount == 0) { 122 list_del(&bcp->bc_list); 123 kmem_free(bcp); 124 } 125 return true; 126 } 127 128 /* log buffer item recovery */ 129 130 /* 131 * Sort buffer items for log recovery. Most buffer items should end up on the 132 * buffer list and are recovered first, with the following exceptions: 133 * 134 * 1. XFS_BLF_CANCEL buffers must be processed last because some log items 135 * might depend on the incor ecancellation record, and replaying a cancelled 136 * buffer item can remove the incore record. 137 * 138 * 2. XFS_BLF_INODE_BUF buffers are handled after most regular items so that 139 * we replay di_next_unlinked only after flushing the inode 'free' state 140 * to the inode buffer. 141 * 142 * See xlog_recover_reorder_trans for more details. 143 */ 144 STATIC enum xlog_recover_reorder 145 xlog_recover_buf_reorder( 146 struct xlog_recover_item *item) 147 { 148 struct xfs_buf_log_format *buf_f = item->ri_buf[0].i_addr; 149 150 if (buf_f->blf_flags & XFS_BLF_CANCEL) 151 return XLOG_REORDER_CANCEL_LIST; 152 if (buf_f->blf_flags & XFS_BLF_INODE_BUF) 153 return XLOG_REORDER_INODE_BUFFER_LIST; 154 return XLOG_REORDER_BUFFER_LIST; 155 } 156 157 STATIC void 158 xlog_recover_buf_ra_pass2( 159 struct xlog *log, 160 struct xlog_recover_item *item) 161 { 162 struct xfs_buf_log_format *buf_f = item->ri_buf[0].i_addr; 163 164 xlog_buf_readahead(log, buf_f->blf_blkno, buf_f->blf_len, NULL); 165 } 166 167 /* 168 * Build up the table of buf cancel records so that we don't replay cancelled 169 * data in the second pass. 170 */ 171 static int 172 xlog_recover_buf_commit_pass1( 173 struct xlog *log, 174 struct xlog_recover_item *item) 175 { 176 struct xfs_buf_log_format *bf = item->ri_buf[0].i_addr; 177 178 if (!xfs_buf_log_check_iovec(&item->ri_buf[0])) { 179 xfs_err(log->l_mp, "bad buffer log item size (%d)", 180 item->ri_buf[0].i_len); 181 return -EFSCORRUPTED; 182 } 183 184 if (!(bf->blf_flags & XFS_BLF_CANCEL)) 185 trace_xfs_log_recover_buf_not_cancel(log, bf); 186 else if (xlog_add_buffer_cancelled(log, bf->blf_blkno, bf->blf_len)) 187 trace_xfs_log_recover_buf_cancel_add(log, bf); 188 else 189 trace_xfs_log_recover_buf_cancel_ref_inc(log, bf); 190 return 0; 191 } 192 193 /* 194 * Validate the recovered buffer is of the correct type and attach the 195 * appropriate buffer operations to them for writeback. Magic numbers are in a 196 * few places: 197 * the first 16 bits of the buffer (inode buffer, dquot buffer), 198 * the first 32 bits of the buffer (most blocks), 199 * inside a struct xfs_da_blkinfo at the start of the buffer. 200 */ 201 static void 202 xlog_recover_validate_buf_type( 203 struct xfs_mount *mp, 204 struct xfs_buf *bp, 205 struct xfs_buf_log_format *buf_f, 206 xfs_lsn_t current_lsn) 207 { 208 struct xfs_da_blkinfo *info = bp->b_addr; 209 uint32_t magic32; 210 uint16_t magic16; 211 uint16_t magicda; 212 char *warnmsg = NULL; 213 214 /* 215 * We can only do post recovery validation on items on CRC enabled 216 * fielsystems as we need to know when the buffer was written to be able 217 * to determine if we should have replayed the item. If we replay old 218 * metadata over a newer buffer, then it will enter a temporarily 219 * inconsistent state resulting in verification failures. Hence for now 220 * just avoid the verification stage for non-crc filesystems 221 */ 222 if (!xfs_has_crc(mp)) 223 return; 224 225 magic32 = be32_to_cpu(*(__be32 *)bp->b_addr); 226 magic16 = be16_to_cpu(*(__be16*)bp->b_addr); 227 magicda = be16_to_cpu(info->magic); 228 switch (xfs_blft_from_flags(buf_f)) { 229 case XFS_BLFT_BTREE_BUF: 230 switch (magic32) { 231 case XFS_ABTB_CRC_MAGIC: 232 case XFS_ABTB_MAGIC: 233 bp->b_ops = &xfs_bnobt_buf_ops; 234 break; 235 case XFS_ABTC_CRC_MAGIC: 236 case XFS_ABTC_MAGIC: 237 bp->b_ops = &xfs_cntbt_buf_ops; 238 break; 239 case XFS_IBT_CRC_MAGIC: 240 case XFS_IBT_MAGIC: 241 bp->b_ops = &xfs_inobt_buf_ops; 242 break; 243 case XFS_FIBT_CRC_MAGIC: 244 case XFS_FIBT_MAGIC: 245 bp->b_ops = &xfs_finobt_buf_ops; 246 break; 247 case XFS_BMAP_CRC_MAGIC: 248 case XFS_BMAP_MAGIC: 249 bp->b_ops = &xfs_bmbt_buf_ops; 250 break; 251 case XFS_RMAP_CRC_MAGIC: 252 bp->b_ops = &xfs_rmapbt_buf_ops; 253 break; 254 case XFS_REFC_CRC_MAGIC: 255 bp->b_ops = &xfs_refcountbt_buf_ops; 256 break; 257 default: 258 warnmsg = "Bad btree block magic!"; 259 break; 260 } 261 break; 262 case XFS_BLFT_AGF_BUF: 263 if (magic32 != XFS_AGF_MAGIC) { 264 warnmsg = "Bad AGF block magic!"; 265 break; 266 } 267 bp->b_ops = &xfs_agf_buf_ops; 268 break; 269 case XFS_BLFT_AGFL_BUF: 270 if (magic32 != XFS_AGFL_MAGIC) { 271 warnmsg = "Bad AGFL block magic!"; 272 break; 273 } 274 bp->b_ops = &xfs_agfl_buf_ops; 275 break; 276 case XFS_BLFT_AGI_BUF: 277 if (magic32 != XFS_AGI_MAGIC) { 278 warnmsg = "Bad AGI block magic!"; 279 break; 280 } 281 bp->b_ops = &xfs_agi_buf_ops; 282 break; 283 case XFS_BLFT_UDQUOT_BUF: 284 case XFS_BLFT_PDQUOT_BUF: 285 case XFS_BLFT_GDQUOT_BUF: 286 #ifdef CONFIG_XFS_QUOTA 287 if (magic16 != XFS_DQUOT_MAGIC) { 288 warnmsg = "Bad DQUOT block magic!"; 289 break; 290 } 291 bp->b_ops = &xfs_dquot_buf_ops; 292 #else 293 xfs_alert(mp, 294 "Trying to recover dquots without QUOTA support built in!"); 295 ASSERT(0); 296 #endif 297 break; 298 case XFS_BLFT_DINO_BUF: 299 if (magic16 != XFS_DINODE_MAGIC) { 300 warnmsg = "Bad INODE block magic!"; 301 break; 302 } 303 bp->b_ops = &xfs_inode_buf_ops; 304 break; 305 case XFS_BLFT_SYMLINK_BUF: 306 if (magic32 != XFS_SYMLINK_MAGIC) { 307 warnmsg = "Bad symlink block magic!"; 308 break; 309 } 310 bp->b_ops = &xfs_symlink_buf_ops; 311 break; 312 case XFS_BLFT_DIR_BLOCK_BUF: 313 if (magic32 != XFS_DIR2_BLOCK_MAGIC && 314 magic32 != XFS_DIR3_BLOCK_MAGIC) { 315 warnmsg = "Bad dir block magic!"; 316 break; 317 } 318 bp->b_ops = &xfs_dir3_block_buf_ops; 319 break; 320 case XFS_BLFT_DIR_DATA_BUF: 321 if (magic32 != XFS_DIR2_DATA_MAGIC && 322 magic32 != XFS_DIR3_DATA_MAGIC) { 323 warnmsg = "Bad dir data magic!"; 324 break; 325 } 326 bp->b_ops = &xfs_dir3_data_buf_ops; 327 break; 328 case XFS_BLFT_DIR_FREE_BUF: 329 if (magic32 != XFS_DIR2_FREE_MAGIC && 330 magic32 != XFS_DIR3_FREE_MAGIC) { 331 warnmsg = "Bad dir3 free magic!"; 332 break; 333 } 334 bp->b_ops = &xfs_dir3_free_buf_ops; 335 break; 336 case XFS_BLFT_DIR_LEAF1_BUF: 337 if (magicda != XFS_DIR2_LEAF1_MAGIC && 338 magicda != XFS_DIR3_LEAF1_MAGIC) { 339 warnmsg = "Bad dir leaf1 magic!"; 340 break; 341 } 342 bp->b_ops = &xfs_dir3_leaf1_buf_ops; 343 break; 344 case XFS_BLFT_DIR_LEAFN_BUF: 345 if (magicda != XFS_DIR2_LEAFN_MAGIC && 346 magicda != XFS_DIR3_LEAFN_MAGIC) { 347 warnmsg = "Bad dir leafn magic!"; 348 break; 349 } 350 bp->b_ops = &xfs_dir3_leafn_buf_ops; 351 break; 352 case XFS_BLFT_DA_NODE_BUF: 353 if (magicda != XFS_DA_NODE_MAGIC && 354 magicda != XFS_DA3_NODE_MAGIC) { 355 warnmsg = "Bad da node magic!"; 356 break; 357 } 358 bp->b_ops = &xfs_da3_node_buf_ops; 359 break; 360 case XFS_BLFT_ATTR_LEAF_BUF: 361 if (magicda != XFS_ATTR_LEAF_MAGIC && 362 magicda != XFS_ATTR3_LEAF_MAGIC) { 363 warnmsg = "Bad attr leaf magic!"; 364 break; 365 } 366 bp->b_ops = &xfs_attr3_leaf_buf_ops; 367 break; 368 case XFS_BLFT_ATTR_RMT_BUF: 369 if (magic32 != XFS_ATTR3_RMT_MAGIC) { 370 warnmsg = "Bad attr remote magic!"; 371 break; 372 } 373 bp->b_ops = &xfs_attr3_rmt_buf_ops; 374 break; 375 case XFS_BLFT_SB_BUF: 376 if (magic32 != XFS_SB_MAGIC) { 377 warnmsg = "Bad SB block magic!"; 378 break; 379 } 380 bp->b_ops = &xfs_sb_buf_ops; 381 break; 382 #ifdef CONFIG_XFS_RT 383 case XFS_BLFT_RTBITMAP_BUF: 384 case XFS_BLFT_RTSUMMARY_BUF: 385 /* no magic numbers for verification of RT buffers */ 386 bp->b_ops = &xfs_rtbuf_ops; 387 break; 388 #endif /* CONFIG_XFS_RT */ 389 default: 390 xfs_warn(mp, "Unknown buffer type %d!", 391 xfs_blft_from_flags(buf_f)); 392 break; 393 } 394 395 /* 396 * Nothing else to do in the case of a NULL current LSN as this means 397 * the buffer is more recent than the change in the log and will be 398 * skipped. 399 */ 400 if (current_lsn == NULLCOMMITLSN) 401 return; 402 403 if (warnmsg) { 404 xfs_warn(mp, warnmsg); 405 ASSERT(0); 406 } 407 408 /* 409 * We must update the metadata LSN of the buffer as it is written out to 410 * ensure that older transactions never replay over this one and corrupt 411 * the buffer. This can occur if log recovery is interrupted at some 412 * point after the current transaction completes, at which point a 413 * subsequent mount starts recovery from the beginning. 414 * 415 * Write verifiers update the metadata LSN from log items attached to 416 * the buffer. Therefore, initialize a bli purely to carry the LSN to 417 * the verifier. 418 */ 419 if (bp->b_ops) { 420 struct xfs_buf_log_item *bip; 421 422 bp->b_flags |= _XBF_LOGRECOVERY; 423 xfs_buf_item_init(bp, mp); 424 bip = bp->b_log_item; 425 bip->bli_item.li_lsn = current_lsn; 426 } 427 } 428 429 /* 430 * Perform a 'normal' buffer recovery. Each logged region of the 431 * buffer should be copied over the corresponding region in the 432 * given buffer. The bitmap in the buf log format structure indicates 433 * where to place the logged data. 434 */ 435 STATIC void 436 xlog_recover_do_reg_buffer( 437 struct xfs_mount *mp, 438 struct xlog_recover_item *item, 439 struct xfs_buf *bp, 440 struct xfs_buf_log_format *buf_f, 441 xfs_lsn_t current_lsn) 442 { 443 int i; 444 int bit; 445 int nbits; 446 xfs_failaddr_t fa; 447 const size_t size_disk_dquot = sizeof(struct xfs_disk_dquot); 448 449 trace_xfs_log_recover_buf_reg_buf(mp->m_log, buf_f); 450 451 bit = 0; 452 i = 1; /* 0 is the buf format structure */ 453 while (1) { 454 bit = xfs_next_bit(buf_f->blf_data_map, 455 buf_f->blf_map_size, bit); 456 if (bit == -1) 457 break; 458 nbits = xfs_contig_bits(buf_f->blf_data_map, 459 buf_f->blf_map_size, bit); 460 ASSERT(nbits > 0); 461 ASSERT(item->ri_buf[i].i_addr != NULL); 462 ASSERT(item->ri_buf[i].i_len % XFS_BLF_CHUNK == 0); 463 ASSERT(BBTOB(bp->b_length) >= 464 ((uint)bit << XFS_BLF_SHIFT) + (nbits << XFS_BLF_SHIFT)); 465 466 /* 467 * The dirty regions logged in the buffer, even though 468 * contiguous, may span multiple chunks. This is because the 469 * dirty region may span a physical page boundary in a buffer 470 * and hence be split into two separate vectors for writing into 471 * the log. Hence we need to trim nbits back to the length of 472 * the current region being copied out of the log. 473 */ 474 if (item->ri_buf[i].i_len < (nbits << XFS_BLF_SHIFT)) 475 nbits = item->ri_buf[i].i_len >> XFS_BLF_SHIFT; 476 477 /* 478 * Do a sanity check if this is a dquot buffer. Just checking 479 * the first dquot in the buffer should do. XXXThis is 480 * probably a good thing to do for other buf types also. 481 */ 482 fa = NULL; 483 if (buf_f->blf_flags & 484 (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) { 485 if (item->ri_buf[i].i_addr == NULL) { 486 xfs_alert(mp, 487 "XFS: NULL dquot in %s.", __func__); 488 goto next; 489 } 490 if (item->ri_buf[i].i_len < size_disk_dquot) { 491 xfs_alert(mp, 492 "XFS: dquot too small (%d) in %s.", 493 item->ri_buf[i].i_len, __func__); 494 goto next; 495 } 496 fa = xfs_dquot_verify(mp, item->ri_buf[i].i_addr, -1); 497 if (fa) { 498 xfs_alert(mp, 499 "dquot corrupt at %pS trying to replay into block 0x%llx", 500 fa, xfs_buf_daddr(bp)); 501 goto next; 502 } 503 } 504 505 memcpy(xfs_buf_offset(bp, 506 (uint)bit << XFS_BLF_SHIFT), /* dest */ 507 item->ri_buf[i].i_addr, /* source */ 508 nbits<<XFS_BLF_SHIFT); /* length */ 509 next: 510 i++; 511 bit += nbits; 512 } 513 514 /* Shouldn't be any more regions */ 515 ASSERT(i == item->ri_total); 516 517 xlog_recover_validate_buf_type(mp, bp, buf_f, current_lsn); 518 } 519 520 /* 521 * Perform a dquot buffer recovery. 522 * Simple algorithm: if we have found a QUOTAOFF log item of the same type 523 * (ie. USR or GRP), then just toss this buffer away; don't recover it. 524 * Else, treat it as a regular buffer and do recovery. 525 * 526 * Return false if the buffer was tossed and true if we recovered the buffer to 527 * indicate to the caller if the buffer needs writing. 528 */ 529 STATIC bool 530 xlog_recover_do_dquot_buffer( 531 struct xfs_mount *mp, 532 struct xlog *log, 533 struct xlog_recover_item *item, 534 struct xfs_buf *bp, 535 struct xfs_buf_log_format *buf_f) 536 { 537 uint type; 538 539 trace_xfs_log_recover_buf_dquot_buf(log, buf_f); 540 541 /* 542 * Filesystems are required to send in quota flags at mount time. 543 */ 544 if (!mp->m_qflags) 545 return false; 546 547 type = 0; 548 if (buf_f->blf_flags & XFS_BLF_UDQUOT_BUF) 549 type |= XFS_DQTYPE_USER; 550 if (buf_f->blf_flags & XFS_BLF_PDQUOT_BUF) 551 type |= XFS_DQTYPE_PROJ; 552 if (buf_f->blf_flags & XFS_BLF_GDQUOT_BUF) 553 type |= XFS_DQTYPE_GROUP; 554 /* 555 * This type of quotas was turned off, so ignore this buffer 556 */ 557 if (log->l_quotaoffs_flag & type) 558 return false; 559 560 xlog_recover_do_reg_buffer(mp, item, bp, buf_f, NULLCOMMITLSN); 561 return true; 562 } 563 564 /* 565 * Perform recovery for a buffer full of inodes. In these buffers, the only 566 * data which should be recovered is that which corresponds to the 567 * di_next_unlinked pointers in the on disk inode structures. The rest of the 568 * data for the inodes is always logged through the inodes themselves rather 569 * than the inode buffer and is recovered in xlog_recover_inode_pass2(). 570 * 571 * The only time when buffers full of inodes are fully recovered is when the 572 * buffer is full of newly allocated inodes. In this case the buffer will 573 * not be marked as an inode buffer and so will be sent to 574 * xlog_recover_do_reg_buffer() below during recovery. 575 */ 576 STATIC int 577 xlog_recover_do_inode_buffer( 578 struct xfs_mount *mp, 579 struct xlog_recover_item *item, 580 struct xfs_buf *bp, 581 struct xfs_buf_log_format *buf_f) 582 { 583 int i; 584 int item_index = 0; 585 int bit = 0; 586 int nbits = 0; 587 int reg_buf_offset = 0; 588 int reg_buf_bytes = 0; 589 int next_unlinked_offset; 590 int inodes_per_buf; 591 xfs_agino_t *logged_nextp; 592 xfs_agino_t *buffer_nextp; 593 594 trace_xfs_log_recover_buf_inode_buf(mp->m_log, buf_f); 595 596 /* 597 * Post recovery validation only works properly on CRC enabled 598 * filesystems. 599 */ 600 if (xfs_has_crc(mp)) 601 bp->b_ops = &xfs_inode_buf_ops; 602 603 inodes_per_buf = BBTOB(bp->b_length) >> mp->m_sb.sb_inodelog; 604 for (i = 0; i < inodes_per_buf; i++) { 605 next_unlinked_offset = (i * mp->m_sb.sb_inodesize) + 606 offsetof(struct xfs_dinode, di_next_unlinked); 607 608 while (next_unlinked_offset >= 609 (reg_buf_offset + reg_buf_bytes)) { 610 /* 611 * The next di_next_unlinked field is beyond 612 * the current logged region. Find the next 613 * logged region that contains or is beyond 614 * the current di_next_unlinked field. 615 */ 616 bit += nbits; 617 bit = xfs_next_bit(buf_f->blf_data_map, 618 buf_f->blf_map_size, bit); 619 620 /* 621 * If there are no more logged regions in the 622 * buffer, then we're done. 623 */ 624 if (bit == -1) 625 return 0; 626 627 nbits = xfs_contig_bits(buf_f->blf_data_map, 628 buf_f->blf_map_size, bit); 629 ASSERT(nbits > 0); 630 reg_buf_offset = bit << XFS_BLF_SHIFT; 631 reg_buf_bytes = nbits << XFS_BLF_SHIFT; 632 item_index++; 633 } 634 635 /* 636 * If the current logged region starts after the current 637 * di_next_unlinked field, then move on to the next 638 * di_next_unlinked field. 639 */ 640 if (next_unlinked_offset < reg_buf_offset) 641 continue; 642 643 ASSERT(item->ri_buf[item_index].i_addr != NULL); 644 ASSERT((item->ri_buf[item_index].i_len % XFS_BLF_CHUNK) == 0); 645 ASSERT((reg_buf_offset + reg_buf_bytes) <= BBTOB(bp->b_length)); 646 647 /* 648 * The current logged region contains a copy of the 649 * current di_next_unlinked field. Extract its value 650 * and copy it to the buffer copy. 651 */ 652 logged_nextp = item->ri_buf[item_index].i_addr + 653 next_unlinked_offset - reg_buf_offset; 654 if (XFS_IS_CORRUPT(mp, *logged_nextp == 0)) { 655 xfs_alert(mp, 656 "Bad inode buffer log record (ptr = "PTR_FMT", bp = "PTR_FMT"). " 657 "Trying to replay bad (0) inode di_next_unlinked field.", 658 item, bp); 659 return -EFSCORRUPTED; 660 } 661 662 buffer_nextp = xfs_buf_offset(bp, next_unlinked_offset); 663 *buffer_nextp = *logged_nextp; 664 665 /* 666 * If necessary, recalculate the CRC in the on-disk inode. We 667 * have to leave the inode in a consistent state for whoever 668 * reads it next.... 669 */ 670 xfs_dinode_calc_crc(mp, 671 xfs_buf_offset(bp, i * mp->m_sb.sb_inodesize)); 672 673 } 674 675 return 0; 676 } 677 678 /* 679 * V5 filesystems know the age of the buffer on disk being recovered. We can 680 * have newer objects on disk than we are replaying, and so for these cases we 681 * don't want to replay the current change as that will make the buffer contents 682 * temporarily invalid on disk. 683 * 684 * The magic number might not match the buffer type we are going to recover 685 * (e.g. reallocated blocks), so we ignore the xfs_buf_log_format flags. Hence 686 * extract the LSN of the existing object in the buffer based on it's current 687 * magic number. If we don't recognise the magic number in the buffer, then 688 * return a LSN of -1 so that the caller knows it was an unrecognised block and 689 * so can recover the buffer. 690 * 691 * Note: we cannot rely solely on magic number matches to determine that the 692 * buffer has a valid LSN - we also need to verify that it belongs to this 693 * filesystem, so we need to extract the object's LSN and compare it to that 694 * which we read from the superblock. If the UUIDs don't match, then we've got a 695 * stale metadata block from an old filesystem instance that we need to recover 696 * over the top of. 697 */ 698 static xfs_lsn_t 699 xlog_recover_get_buf_lsn( 700 struct xfs_mount *mp, 701 struct xfs_buf *bp, 702 struct xfs_buf_log_format *buf_f) 703 { 704 uint32_t magic32; 705 uint16_t magic16; 706 uint16_t magicda; 707 void *blk = bp->b_addr; 708 uuid_t *uuid; 709 xfs_lsn_t lsn = -1; 710 uint16_t blft; 711 712 /* v4 filesystems always recover immediately */ 713 if (!xfs_has_crc(mp)) 714 goto recover_immediately; 715 716 /* 717 * realtime bitmap and summary file blocks do not have magic numbers or 718 * UUIDs, so we must recover them immediately. 719 */ 720 blft = xfs_blft_from_flags(buf_f); 721 if (blft == XFS_BLFT_RTBITMAP_BUF || blft == XFS_BLFT_RTSUMMARY_BUF) 722 goto recover_immediately; 723 724 magic32 = be32_to_cpu(*(__be32 *)blk); 725 switch (magic32) { 726 case XFS_ABTB_CRC_MAGIC: 727 case XFS_ABTC_CRC_MAGIC: 728 case XFS_ABTB_MAGIC: 729 case XFS_ABTC_MAGIC: 730 case XFS_RMAP_CRC_MAGIC: 731 case XFS_REFC_CRC_MAGIC: 732 case XFS_FIBT_CRC_MAGIC: 733 case XFS_FIBT_MAGIC: 734 case XFS_IBT_CRC_MAGIC: 735 case XFS_IBT_MAGIC: { 736 struct xfs_btree_block *btb = blk; 737 738 lsn = be64_to_cpu(btb->bb_u.s.bb_lsn); 739 uuid = &btb->bb_u.s.bb_uuid; 740 break; 741 } 742 case XFS_BMAP_CRC_MAGIC: 743 case XFS_BMAP_MAGIC: { 744 struct xfs_btree_block *btb = blk; 745 746 lsn = be64_to_cpu(btb->bb_u.l.bb_lsn); 747 uuid = &btb->bb_u.l.bb_uuid; 748 break; 749 } 750 case XFS_AGF_MAGIC: 751 lsn = be64_to_cpu(((struct xfs_agf *)blk)->agf_lsn); 752 uuid = &((struct xfs_agf *)blk)->agf_uuid; 753 break; 754 case XFS_AGFL_MAGIC: 755 lsn = be64_to_cpu(((struct xfs_agfl *)blk)->agfl_lsn); 756 uuid = &((struct xfs_agfl *)blk)->agfl_uuid; 757 break; 758 case XFS_AGI_MAGIC: 759 lsn = be64_to_cpu(((struct xfs_agi *)blk)->agi_lsn); 760 uuid = &((struct xfs_agi *)blk)->agi_uuid; 761 break; 762 case XFS_SYMLINK_MAGIC: 763 lsn = be64_to_cpu(((struct xfs_dsymlink_hdr *)blk)->sl_lsn); 764 uuid = &((struct xfs_dsymlink_hdr *)blk)->sl_uuid; 765 break; 766 case XFS_DIR3_BLOCK_MAGIC: 767 case XFS_DIR3_DATA_MAGIC: 768 case XFS_DIR3_FREE_MAGIC: 769 lsn = be64_to_cpu(((struct xfs_dir3_blk_hdr *)blk)->lsn); 770 uuid = &((struct xfs_dir3_blk_hdr *)blk)->uuid; 771 break; 772 case XFS_ATTR3_RMT_MAGIC: 773 /* 774 * Remote attr blocks are written synchronously, rather than 775 * being logged. That means they do not contain a valid LSN 776 * (i.e. transactionally ordered) in them, and hence any time we 777 * see a buffer to replay over the top of a remote attribute 778 * block we should simply do so. 779 */ 780 goto recover_immediately; 781 case XFS_SB_MAGIC: 782 /* 783 * superblock uuids are magic. We may or may not have a 784 * sb_meta_uuid on disk, but it will be set in the in-core 785 * superblock. We set the uuid pointer for verification 786 * according to the superblock feature mask to ensure we check 787 * the relevant UUID in the superblock. 788 */ 789 lsn = be64_to_cpu(((struct xfs_dsb *)blk)->sb_lsn); 790 if (xfs_has_metauuid(mp)) 791 uuid = &((struct xfs_dsb *)blk)->sb_meta_uuid; 792 else 793 uuid = &((struct xfs_dsb *)blk)->sb_uuid; 794 break; 795 default: 796 break; 797 } 798 799 if (lsn != (xfs_lsn_t)-1) { 800 if (!uuid_equal(&mp->m_sb.sb_meta_uuid, uuid)) 801 goto recover_immediately; 802 return lsn; 803 } 804 805 magicda = be16_to_cpu(((struct xfs_da_blkinfo *)blk)->magic); 806 switch (magicda) { 807 case XFS_DIR3_LEAF1_MAGIC: 808 case XFS_DIR3_LEAFN_MAGIC: 809 case XFS_ATTR3_LEAF_MAGIC: 810 case XFS_DA3_NODE_MAGIC: 811 lsn = be64_to_cpu(((struct xfs_da3_blkinfo *)blk)->lsn); 812 uuid = &((struct xfs_da3_blkinfo *)blk)->uuid; 813 break; 814 default: 815 break; 816 } 817 818 if (lsn != (xfs_lsn_t)-1) { 819 if (!uuid_equal(&mp->m_sb.sb_meta_uuid, uuid)) 820 goto recover_immediately; 821 return lsn; 822 } 823 824 /* 825 * We do individual object checks on dquot and inode buffers as they 826 * have their own individual LSN records. Also, we could have a stale 827 * buffer here, so we have to at least recognise these buffer types. 828 * 829 * A notd complexity here is inode unlinked list processing - it logs 830 * the inode directly in the buffer, but we don't know which inodes have 831 * been modified, and there is no global buffer LSN. Hence we need to 832 * recover all inode buffer types immediately. This problem will be 833 * fixed by logical logging of the unlinked list modifications. 834 */ 835 magic16 = be16_to_cpu(*(__be16 *)blk); 836 switch (magic16) { 837 case XFS_DQUOT_MAGIC: 838 case XFS_DINODE_MAGIC: 839 goto recover_immediately; 840 default: 841 break; 842 } 843 844 /* unknown buffer contents, recover immediately */ 845 846 recover_immediately: 847 return (xfs_lsn_t)-1; 848 849 } 850 851 /* 852 * This routine replays a modification made to a buffer at runtime. 853 * There are actually two types of buffer, regular and inode, which 854 * are handled differently. Inode buffers are handled differently 855 * in that we only recover a specific set of data from them, namely 856 * the inode di_next_unlinked fields. This is because all other inode 857 * data is actually logged via inode records and any data we replay 858 * here which overlaps that may be stale. 859 * 860 * When meta-data buffers are freed at run time we log a buffer item 861 * with the XFS_BLF_CANCEL bit set to indicate that previous copies 862 * of the buffer in the log should not be replayed at recovery time. 863 * This is so that if the blocks covered by the buffer are reused for 864 * file data before we crash we don't end up replaying old, freed 865 * meta-data into a user's file. 866 * 867 * To handle the cancellation of buffer log items, we make two passes 868 * over the log during recovery. During the first we build a table of 869 * those buffers which have been cancelled, and during the second we 870 * only replay those buffers which do not have corresponding cancel 871 * records in the table. See xlog_recover_buf_pass[1,2] above 872 * for more details on the implementation of the table of cancel records. 873 */ 874 STATIC int 875 xlog_recover_buf_commit_pass2( 876 struct xlog *log, 877 struct list_head *buffer_list, 878 struct xlog_recover_item *item, 879 xfs_lsn_t current_lsn) 880 { 881 struct xfs_buf_log_format *buf_f = item->ri_buf[0].i_addr; 882 struct xfs_mount *mp = log->l_mp; 883 struct xfs_buf *bp; 884 int error; 885 uint buf_flags; 886 xfs_lsn_t lsn; 887 888 /* 889 * In this pass we only want to recover all the buffers which have 890 * not been cancelled and are not cancellation buffers themselves. 891 */ 892 if (buf_f->blf_flags & XFS_BLF_CANCEL) { 893 if (xlog_put_buffer_cancelled(log, buf_f->blf_blkno, 894 buf_f->blf_len)) 895 goto cancelled; 896 } else { 897 898 if (xlog_is_buffer_cancelled(log, buf_f->blf_blkno, 899 buf_f->blf_len)) 900 goto cancelled; 901 } 902 903 trace_xfs_log_recover_buf_recover(log, buf_f); 904 905 buf_flags = 0; 906 if (buf_f->blf_flags & XFS_BLF_INODE_BUF) 907 buf_flags |= XBF_UNMAPPED; 908 909 error = xfs_buf_read(mp->m_ddev_targp, buf_f->blf_blkno, buf_f->blf_len, 910 buf_flags, &bp, NULL); 911 if (error) 912 return error; 913 914 /* 915 * Recover the buffer only if we get an LSN from it and it's less than 916 * the lsn of the transaction we are replaying. 917 * 918 * Note that we have to be extremely careful of readahead here. 919 * Readahead does not attach verfiers to the buffers so if we don't 920 * actually do any replay after readahead because of the LSN we found 921 * in the buffer if more recent than that current transaction then we 922 * need to attach the verifier directly. Failure to do so can lead to 923 * future recovery actions (e.g. EFI and unlinked list recovery) can 924 * operate on the buffers and they won't get the verifier attached. This 925 * can lead to blocks on disk having the correct content but a stale 926 * CRC. 927 * 928 * It is safe to assume these clean buffers are currently up to date. 929 * If the buffer is dirtied by a later transaction being replayed, then 930 * the verifier will be reset to match whatever recover turns that 931 * buffer into. 932 */ 933 lsn = xlog_recover_get_buf_lsn(mp, bp, buf_f); 934 if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0) { 935 trace_xfs_log_recover_buf_skip(log, buf_f); 936 xlog_recover_validate_buf_type(mp, bp, buf_f, NULLCOMMITLSN); 937 goto out_release; 938 } 939 940 if (buf_f->blf_flags & XFS_BLF_INODE_BUF) { 941 error = xlog_recover_do_inode_buffer(mp, item, bp, buf_f); 942 if (error) 943 goto out_release; 944 } else if (buf_f->blf_flags & 945 (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) { 946 bool dirty; 947 948 dirty = xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f); 949 if (!dirty) 950 goto out_release; 951 } else { 952 xlog_recover_do_reg_buffer(mp, item, bp, buf_f, current_lsn); 953 } 954 955 /* 956 * Perform delayed write on the buffer. Asynchronous writes will be 957 * slower when taking into account all the buffers to be flushed. 958 * 959 * Also make sure that only inode buffers with good sizes stay in 960 * the buffer cache. The kernel moves inodes in buffers of 1 block 961 * or inode_cluster_size bytes, whichever is bigger. The inode 962 * buffers in the log can be a different size if the log was generated 963 * by an older kernel using unclustered inode buffers or a newer kernel 964 * running with a different inode cluster size. Regardless, if 965 * the inode buffer size isn't max(blocksize, inode_cluster_size) 966 * for *our* value of inode_cluster_size, then we need to keep 967 * the buffer out of the buffer cache so that the buffer won't 968 * overlap with future reads of those inodes. 969 */ 970 if (XFS_DINODE_MAGIC == 971 be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) && 972 (BBTOB(bp->b_length) != M_IGEO(log->l_mp)->inode_cluster_size)) { 973 xfs_buf_stale(bp); 974 error = xfs_bwrite(bp); 975 } else { 976 ASSERT(bp->b_mount == mp); 977 bp->b_flags |= _XBF_LOGRECOVERY; 978 xfs_buf_delwri_queue(bp, buffer_list); 979 } 980 981 out_release: 982 xfs_buf_relse(bp); 983 return error; 984 cancelled: 985 trace_xfs_log_recover_buf_cancel(log, buf_f); 986 return 0; 987 } 988 989 const struct xlog_recover_item_ops xlog_buf_item_ops = { 990 .item_type = XFS_LI_BUF, 991 .reorder = xlog_recover_buf_reorder, 992 .ra_pass2 = xlog_recover_buf_ra_pass2, 993 .commit_pass1 = xlog_recover_buf_commit_pass1, 994 .commit_pass2 = xlog_recover_buf_commit_pass2, 995 }; 996