1 /* 2 * Copyright (c) 2000-2006 Silicon Graphics, Inc. 3 * All Rights Reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it would be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write the Free Software Foundation, 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 17 */ 18 #include "xfs.h" 19 #include "xfs_fs.h" 20 #include "xfs_shared.h" 21 #include "xfs_format.h" 22 #include "xfs_log_format.h" 23 #include "xfs_trans_resv.h" 24 #include "xfs_bit.h" 25 #include "xfs_sb.h" 26 #include "xfs_mount.h" 27 #include "xfs_da_format.h" 28 #include "xfs_da_btree.h" 29 #include "xfs_inode.h" 30 #include "xfs_trans.h" 31 #include "xfs_log.h" 32 #include "xfs_log_priv.h" 33 #include "xfs_log_recover.h" 34 #include "xfs_inode_item.h" 35 #include "xfs_extfree_item.h" 36 #include "xfs_trans_priv.h" 37 #include "xfs_alloc.h" 38 #include "xfs_ialloc.h" 39 #include "xfs_quota.h" 40 #include "xfs_cksum.h" 41 #include "xfs_trace.h" 42 #include "xfs_icache.h" 43 #include "xfs_bmap_btree.h" 44 #include "xfs_error.h" 45 #include "xfs_dir2.h" 46 47 #define BLK_AVG(blk1, blk2) ((blk1+blk2) >> 1) 48 49 STATIC int 50 xlog_find_zeroed( 51 struct xlog *, 52 xfs_daddr_t *); 53 STATIC int 54 xlog_clear_stale_blocks( 55 struct xlog *, 56 xfs_lsn_t); 57 #if defined(DEBUG) 58 STATIC void 59 xlog_recover_check_summary( 60 struct xlog *); 61 #else 62 #define xlog_recover_check_summary(log) 63 #endif 64 65 /* 66 * This structure is used during recovery to record the buf log items which 67 * have been canceled and should not be replayed. 68 */ 69 struct xfs_buf_cancel { 70 xfs_daddr_t bc_blkno; 71 uint bc_len; 72 int bc_refcount; 73 struct list_head bc_list; 74 }; 75 76 /* 77 * Sector aligned buffer routines for buffer create/read/write/access 78 */ 79 80 /* 81 * Verify the given count of basic blocks is valid number of blocks 82 * to specify for an operation involving the given XFS log buffer. 83 * Returns nonzero if the count is valid, 0 otherwise. 84 */ 85 86 static inline int 87 xlog_buf_bbcount_valid( 88 struct xlog *log, 89 int bbcount) 90 { 91 return bbcount > 0 && bbcount <= log->l_logBBsize; 92 } 93 94 /* 95 * Allocate a buffer to hold log data. The buffer needs to be able 96 * to map to a range of nbblks basic blocks at any valid (basic 97 * block) offset within the log. 98 */ 99 STATIC xfs_buf_t * 100 xlog_get_bp( 101 struct xlog *log, 102 int nbblks) 103 { 104 struct xfs_buf *bp; 105 106 if (!xlog_buf_bbcount_valid(log, nbblks)) { 107 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer", 108 nbblks); 109 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp); 110 return NULL; 111 } 112 113 /* 114 * We do log I/O in units of log sectors (a power-of-2 115 * multiple of the basic block size), so we round up the 116 * requested size to accommodate the basic blocks required 117 * for complete log sectors. 118 * 119 * In addition, the buffer may be used for a non-sector- 120 * aligned block offset, in which case an I/O of the 121 * requested size could extend beyond the end of the 122 * buffer. If the requested size is only 1 basic block it 123 * will never straddle a sector boundary, so this won't be 124 * an issue. Nor will this be a problem if the log I/O is 125 * done in basic blocks (sector size 1). But otherwise we 126 * extend the buffer by one extra log sector to ensure 127 * there's space to accommodate this possibility. 128 */ 129 if (nbblks > 1 && log->l_sectBBsize > 1) 130 nbblks += log->l_sectBBsize; 131 nbblks = round_up(nbblks, log->l_sectBBsize); 132 133 bp = xfs_buf_get_uncached(log->l_mp->m_logdev_targp, nbblks, 0); 134 if (bp) 135 xfs_buf_unlock(bp); 136 return bp; 137 } 138 139 STATIC void 140 xlog_put_bp( 141 xfs_buf_t *bp) 142 { 143 xfs_buf_free(bp); 144 } 145 146 /* 147 * Return the address of the start of the given block number's data 148 * in a log buffer. The buffer covers a log sector-aligned region. 149 */ 150 STATIC char * 151 xlog_align( 152 struct xlog *log, 153 xfs_daddr_t blk_no, 154 int nbblks, 155 struct xfs_buf *bp) 156 { 157 xfs_daddr_t offset = blk_no & ((xfs_daddr_t)log->l_sectBBsize - 1); 158 159 ASSERT(offset + nbblks <= bp->b_length); 160 return bp->b_addr + BBTOB(offset); 161 } 162 163 164 /* 165 * nbblks should be uint, but oh well. Just want to catch that 32-bit length. 166 */ 167 STATIC int 168 xlog_bread_noalign( 169 struct xlog *log, 170 xfs_daddr_t blk_no, 171 int nbblks, 172 struct xfs_buf *bp) 173 { 174 int error; 175 176 if (!xlog_buf_bbcount_valid(log, nbblks)) { 177 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer", 178 nbblks); 179 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp); 180 return -EFSCORRUPTED; 181 } 182 183 blk_no = round_down(blk_no, log->l_sectBBsize); 184 nbblks = round_up(nbblks, log->l_sectBBsize); 185 186 ASSERT(nbblks > 0); 187 ASSERT(nbblks <= bp->b_length); 188 189 XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no); 190 XFS_BUF_READ(bp); 191 bp->b_io_length = nbblks; 192 bp->b_error = 0; 193 194 error = xfs_buf_submit_wait(bp); 195 if (error && !XFS_FORCED_SHUTDOWN(log->l_mp)) 196 xfs_buf_ioerror_alert(bp, __func__); 197 return error; 198 } 199 200 STATIC int 201 xlog_bread( 202 struct xlog *log, 203 xfs_daddr_t blk_no, 204 int nbblks, 205 struct xfs_buf *bp, 206 char **offset) 207 { 208 int error; 209 210 error = xlog_bread_noalign(log, blk_no, nbblks, bp); 211 if (error) 212 return error; 213 214 *offset = xlog_align(log, blk_no, nbblks, bp); 215 return 0; 216 } 217 218 /* 219 * Read at an offset into the buffer. Returns with the buffer in it's original 220 * state regardless of the result of the read. 221 */ 222 STATIC int 223 xlog_bread_offset( 224 struct xlog *log, 225 xfs_daddr_t blk_no, /* block to read from */ 226 int nbblks, /* blocks to read */ 227 struct xfs_buf *bp, 228 char *offset) 229 { 230 char *orig_offset = bp->b_addr; 231 int orig_len = BBTOB(bp->b_length); 232 int error, error2; 233 234 error = xfs_buf_associate_memory(bp, offset, BBTOB(nbblks)); 235 if (error) 236 return error; 237 238 error = xlog_bread_noalign(log, blk_no, nbblks, bp); 239 240 /* must reset buffer pointer even on error */ 241 error2 = xfs_buf_associate_memory(bp, orig_offset, orig_len); 242 if (error) 243 return error; 244 return error2; 245 } 246 247 /* 248 * Write out the buffer at the given block for the given number of blocks. 249 * The buffer is kept locked across the write and is returned locked. 250 * This can only be used for synchronous log writes. 251 */ 252 STATIC int 253 xlog_bwrite( 254 struct xlog *log, 255 xfs_daddr_t blk_no, 256 int nbblks, 257 struct xfs_buf *bp) 258 { 259 int error; 260 261 if (!xlog_buf_bbcount_valid(log, nbblks)) { 262 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer", 263 nbblks); 264 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp); 265 return -EFSCORRUPTED; 266 } 267 268 blk_no = round_down(blk_no, log->l_sectBBsize); 269 nbblks = round_up(nbblks, log->l_sectBBsize); 270 271 ASSERT(nbblks > 0); 272 ASSERT(nbblks <= bp->b_length); 273 274 XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no); 275 XFS_BUF_ZEROFLAGS(bp); 276 xfs_buf_hold(bp); 277 xfs_buf_lock(bp); 278 bp->b_io_length = nbblks; 279 bp->b_error = 0; 280 281 error = xfs_bwrite(bp); 282 if (error) 283 xfs_buf_ioerror_alert(bp, __func__); 284 xfs_buf_relse(bp); 285 return error; 286 } 287 288 #ifdef DEBUG 289 /* 290 * dump debug superblock and log record information 291 */ 292 STATIC void 293 xlog_header_check_dump( 294 xfs_mount_t *mp, 295 xlog_rec_header_t *head) 296 { 297 xfs_debug(mp, "%s: SB : uuid = %pU, fmt = %d", 298 __func__, &mp->m_sb.sb_uuid, XLOG_FMT); 299 xfs_debug(mp, " log : uuid = %pU, fmt = %d", 300 &head->h_fs_uuid, be32_to_cpu(head->h_fmt)); 301 } 302 #else 303 #define xlog_header_check_dump(mp, head) 304 #endif 305 306 /* 307 * check log record header for recovery 308 */ 309 STATIC int 310 xlog_header_check_recover( 311 xfs_mount_t *mp, 312 xlog_rec_header_t *head) 313 { 314 ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM)); 315 316 /* 317 * IRIX doesn't write the h_fmt field and leaves it zeroed 318 * (XLOG_FMT_UNKNOWN). This stops us from trying to recover 319 * a dirty log created in IRIX. 320 */ 321 if (unlikely(head->h_fmt != cpu_to_be32(XLOG_FMT))) { 322 xfs_warn(mp, 323 "dirty log written in incompatible format - can't recover"); 324 xlog_header_check_dump(mp, head); 325 XFS_ERROR_REPORT("xlog_header_check_recover(1)", 326 XFS_ERRLEVEL_HIGH, mp); 327 return -EFSCORRUPTED; 328 } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) { 329 xfs_warn(mp, 330 "dirty log entry has mismatched uuid - can't recover"); 331 xlog_header_check_dump(mp, head); 332 XFS_ERROR_REPORT("xlog_header_check_recover(2)", 333 XFS_ERRLEVEL_HIGH, mp); 334 return -EFSCORRUPTED; 335 } 336 return 0; 337 } 338 339 /* 340 * read the head block of the log and check the header 341 */ 342 STATIC int 343 xlog_header_check_mount( 344 xfs_mount_t *mp, 345 xlog_rec_header_t *head) 346 { 347 ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM)); 348 349 if (uuid_is_nil(&head->h_fs_uuid)) { 350 /* 351 * IRIX doesn't write the h_fs_uuid or h_fmt fields. If 352 * h_fs_uuid is nil, we assume this log was last mounted 353 * by IRIX and continue. 354 */ 355 xfs_warn(mp, "nil uuid in log - IRIX style log"); 356 } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) { 357 xfs_warn(mp, "log has mismatched uuid - can't recover"); 358 xlog_header_check_dump(mp, head); 359 XFS_ERROR_REPORT("xlog_header_check_mount", 360 XFS_ERRLEVEL_HIGH, mp); 361 return -EFSCORRUPTED; 362 } 363 return 0; 364 } 365 366 STATIC void 367 xlog_recover_iodone( 368 struct xfs_buf *bp) 369 { 370 if (bp->b_error) { 371 /* 372 * We're not going to bother about retrying 373 * this during recovery. One strike! 374 */ 375 if (!XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) { 376 xfs_buf_ioerror_alert(bp, __func__); 377 xfs_force_shutdown(bp->b_target->bt_mount, 378 SHUTDOWN_META_IO_ERROR); 379 } 380 } 381 bp->b_iodone = NULL; 382 xfs_buf_ioend(bp); 383 } 384 385 /* 386 * This routine finds (to an approximation) the first block in the physical 387 * log which contains the given cycle. It uses a binary search algorithm. 388 * Note that the algorithm can not be perfect because the disk will not 389 * necessarily be perfect. 390 */ 391 STATIC int 392 xlog_find_cycle_start( 393 struct xlog *log, 394 struct xfs_buf *bp, 395 xfs_daddr_t first_blk, 396 xfs_daddr_t *last_blk, 397 uint cycle) 398 { 399 char *offset; 400 xfs_daddr_t mid_blk; 401 xfs_daddr_t end_blk; 402 uint mid_cycle; 403 int error; 404 405 end_blk = *last_blk; 406 mid_blk = BLK_AVG(first_blk, end_blk); 407 while (mid_blk != first_blk && mid_blk != end_blk) { 408 error = xlog_bread(log, mid_blk, 1, bp, &offset); 409 if (error) 410 return error; 411 mid_cycle = xlog_get_cycle(offset); 412 if (mid_cycle == cycle) 413 end_blk = mid_blk; /* last_half_cycle == mid_cycle */ 414 else 415 first_blk = mid_blk; /* first_half_cycle == mid_cycle */ 416 mid_blk = BLK_AVG(first_blk, end_blk); 417 } 418 ASSERT((mid_blk == first_blk && mid_blk+1 == end_blk) || 419 (mid_blk == end_blk && mid_blk-1 == first_blk)); 420 421 *last_blk = end_blk; 422 423 return 0; 424 } 425 426 /* 427 * Check that a range of blocks does not contain stop_on_cycle_no. 428 * Fill in *new_blk with the block offset where such a block is 429 * found, or with -1 (an invalid block number) if there is no such 430 * block in the range. The scan needs to occur from front to back 431 * and the pointer into the region must be updated since a later 432 * routine will need to perform another test. 433 */ 434 STATIC int 435 xlog_find_verify_cycle( 436 struct xlog *log, 437 xfs_daddr_t start_blk, 438 int nbblks, 439 uint stop_on_cycle_no, 440 xfs_daddr_t *new_blk) 441 { 442 xfs_daddr_t i, j; 443 uint cycle; 444 xfs_buf_t *bp; 445 xfs_daddr_t bufblks; 446 char *buf = NULL; 447 int error = 0; 448 449 /* 450 * Greedily allocate a buffer big enough to handle the full 451 * range of basic blocks we'll be examining. If that fails, 452 * try a smaller size. We need to be able to read at least 453 * a log sector, or we're out of luck. 454 */ 455 bufblks = 1 << ffs(nbblks); 456 while (bufblks > log->l_logBBsize) 457 bufblks >>= 1; 458 while (!(bp = xlog_get_bp(log, bufblks))) { 459 bufblks >>= 1; 460 if (bufblks < log->l_sectBBsize) 461 return -ENOMEM; 462 } 463 464 for (i = start_blk; i < start_blk + nbblks; i += bufblks) { 465 int bcount; 466 467 bcount = min(bufblks, (start_blk + nbblks - i)); 468 469 error = xlog_bread(log, i, bcount, bp, &buf); 470 if (error) 471 goto out; 472 473 for (j = 0; j < bcount; j++) { 474 cycle = xlog_get_cycle(buf); 475 if (cycle == stop_on_cycle_no) { 476 *new_blk = i+j; 477 goto out; 478 } 479 480 buf += BBSIZE; 481 } 482 } 483 484 *new_blk = -1; 485 486 out: 487 xlog_put_bp(bp); 488 return error; 489 } 490 491 /* 492 * Potentially backup over partial log record write. 493 * 494 * In the typical case, last_blk is the number of the block directly after 495 * a good log record. Therefore, we subtract one to get the block number 496 * of the last block in the given buffer. extra_bblks contains the number 497 * of blocks we would have read on a previous read. This happens when the 498 * last log record is split over the end of the physical log. 499 * 500 * extra_bblks is the number of blocks potentially verified on a previous 501 * call to this routine. 502 */ 503 STATIC int 504 xlog_find_verify_log_record( 505 struct xlog *log, 506 xfs_daddr_t start_blk, 507 xfs_daddr_t *last_blk, 508 int extra_bblks) 509 { 510 xfs_daddr_t i; 511 xfs_buf_t *bp; 512 char *offset = NULL; 513 xlog_rec_header_t *head = NULL; 514 int error = 0; 515 int smallmem = 0; 516 int num_blks = *last_blk - start_blk; 517 int xhdrs; 518 519 ASSERT(start_blk != 0 || *last_blk != start_blk); 520 521 if (!(bp = xlog_get_bp(log, num_blks))) { 522 if (!(bp = xlog_get_bp(log, 1))) 523 return -ENOMEM; 524 smallmem = 1; 525 } else { 526 error = xlog_bread(log, start_blk, num_blks, bp, &offset); 527 if (error) 528 goto out; 529 offset += ((num_blks - 1) << BBSHIFT); 530 } 531 532 for (i = (*last_blk) - 1; i >= 0; i--) { 533 if (i < start_blk) { 534 /* valid log record not found */ 535 xfs_warn(log->l_mp, 536 "Log inconsistent (didn't find previous header)"); 537 ASSERT(0); 538 error = -EIO; 539 goto out; 540 } 541 542 if (smallmem) { 543 error = xlog_bread(log, i, 1, bp, &offset); 544 if (error) 545 goto out; 546 } 547 548 head = (xlog_rec_header_t *)offset; 549 550 if (head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) 551 break; 552 553 if (!smallmem) 554 offset -= BBSIZE; 555 } 556 557 /* 558 * We hit the beginning of the physical log & still no header. Return 559 * to caller. If caller can handle a return of -1, then this routine 560 * will be called again for the end of the physical log. 561 */ 562 if (i == -1) { 563 error = 1; 564 goto out; 565 } 566 567 /* 568 * We have the final block of the good log (the first block 569 * of the log record _before_ the head. So we check the uuid. 570 */ 571 if ((error = xlog_header_check_mount(log->l_mp, head))) 572 goto out; 573 574 /* 575 * We may have found a log record header before we expected one. 576 * last_blk will be the 1st block # with a given cycle #. We may end 577 * up reading an entire log record. In this case, we don't want to 578 * reset last_blk. Only when last_blk points in the middle of a log 579 * record do we update last_blk. 580 */ 581 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) { 582 uint h_size = be32_to_cpu(head->h_size); 583 584 xhdrs = h_size / XLOG_HEADER_CYCLE_SIZE; 585 if (h_size % XLOG_HEADER_CYCLE_SIZE) 586 xhdrs++; 587 } else { 588 xhdrs = 1; 589 } 590 591 if (*last_blk - i + extra_bblks != 592 BTOBB(be32_to_cpu(head->h_len)) + xhdrs) 593 *last_blk = i; 594 595 out: 596 xlog_put_bp(bp); 597 return error; 598 } 599 600 /* 601 * Head is defined to be the point of the log where the next log write 602 * could go. This means that incomplete LR writes at the end are 603 * eliminated when calculating the head. We aren't guaranteed that previous 604 * LR have complete transactions. We only know that a cycle number of 605 * current cycle number -1 won't be present in the log if we start writing 606 * from our current block number. 607 * 608 * last_blk contains the block number of the first block with a given 609 * cycle number. 610 * 611 * Return: zero if normal, non-zero if error. 612 */ 613 STATIC int 614 xlog_find_head( 615 struct xlog *log, 616 xfs_daddr_t *return_head_blk) 617 { 618 xfs_buf_t *bp; 619 char *offset; 620 xfs_daddr_t new_blk, first_blk, start_blk, last_blk, head_blk; 621 int num_scan_bblks; 622 uint first_half_cycle, last_half_cycle; 623 uint stop_on_cycle; 624 int error, log_bbnum = log->l_logBBsize; 625 626 /* Is the end of the log device zeroed? */ 627 error = xlog_find_zeroed(log, &first_blk); 628 if (error < 0) { 629 xfs_warn(log->l_mp, "empty log check failed"); 630 return error; 631 } 632 if (error == 1) { 633 *return_head_blk = first_blk; 634 635 /* Is the whole lot zeroed? */ 636 if (!first_blk) { 637 /* Linux XFS shouldn't generate totally zeroed logs - 638 * mkfs etc write a dummy unmount record to a fresh 639 * log so we can store the uuid in there 640 */ 641 xfs_warn(log->l_mp, "totally zeroed log"); 642 } 643 644 return 0; 645 } 646 647 first_blk = 0; /* get cycle # of 1st block */ 648 bp = xlog_get_bp(log, 1); 649 if (!bp) 650 return -ENOMEM; 651 652 error = xlog_bread(log, 0, 1, bp, &offset); 653 if (error) 654 goto bp_err; 655 656 first_half_cycle = xlog_get_cycle(offset); 657 658 last_blk = head_blk = log_bbnum - 1; /* get cycle # of last block */ 659 error = xlog_bread(log, last_blk, 1, bp, &offset); 660 if (error) 661 goto bp_err; 662 663 last_half_cycle = xlog_get_cycle(offset); 664 ASSERT(last_half_cycle != 0); 665 666 /* 667 * If the 1st half cycle number is equal to the last half cycle number, 668 * then the entire log is stamped with the same cycle number. In this 669 * case, head_blk can't be set to zero (which makes sense). The below 670 * math doesn't work out properly with head_blk equal to zero. Instead, 671 * we set it to log_bbnum which is an invalid block number, but this 672 * value makes the math correct. If head_blk doesn't changed through 673 * all the tests below, *head_blk is set to zero at the very end rather 674 * than log_bbnum. In a sense, log_bbnum and zero are the same block 675 * in a circular file. 676 */ 677 if (first_half_cycle == last_half_cycle) { 678 /* 679 * In this case we believe that the entire log should have 680 * cycle number last_half_cycle. We need to scan backwards 681 * from the end verifying that there are no holes still 682 * containing last_half_cycle - 1. If we find such a hole, 683 * then the start of that hole will be the new head. The 684 * simple case looks like 685 * x | x ... | x - 1 | x 686 * Another case that fits this picture would be 687 * x | x + 1 | x ... | x 688 * In this case the head really is somewhere at the end of the 689 * log, as one of the latest writes at the beginning was 690 * incomplete. 691 * One more case is 692 * x | x + 1 | x ... | x - 1 | x 693 * This is really the combination of the above two cases, and 694 * the head has to end up at the start of the x-1 hole at the 695 * end of the log. 696 * 697 * In the 256k log case, we will read from the beginning to the 698 * end of the log and search for cycle numbers equal to x-1. 699 * We don't worry about the x+1 blocks that we encounter, 700 * because we know that they cannot be the head since the log 701 * started with x. 702 */ 703 head_blk = log_bbnum; 704 stop_on_cycle = last_half_cycle - 1; 705 } else { 706 /* 707 * In this case we want to find the first block with cycle 708 * number matching last_half_cycle. We expect the log to be 709 * some variation on 710 * x + 1 ... | x ... | x 711 * The first block with cycle number x (last_half_cycle) will 712 * be where the new head belongs. First we do a binary search 713 * for the first occurrence of last_half_cycle. The binary 714 * search may not be totally accurate, so then we scan back 715 * from there looking for occurrences of last_half_cycle before 716 * us. If that backwards scan wraps around the beginning of 717 * the log, then we look for occurrences of last_half_cycle - 1 718 * at the end of the log. The cases we're looking for look 719 * like 720 * v binary search stopped here 721 * x + 1 ... | x | x + 1 | x ... | x 722 * ^ but we want to locate this spot 723 * or 724 * <---------> less than scan distance 725 * x + 1 ... | x ... | x - 1 | x 726 * ^ we want to locate this spot 727 */ 728 stop_on_cycle = last_half_cycle; 729 if ((error = xlog_find_cycle_start(log, bp, first_blk, 730 &head_blk, last_half_cycle))) 731 goto bp_err; 732 } 733 734 /* 735 * Now validate the answer. Scan back some number of maximum possible 736 * blocks and make sure each one has the expected cycle number. The 737 * maximum is determined by the total possible amount of buffering 738 * in the in-core log. The following number can be made tighter if 739 * we actually look at the block size of the filesystem. 740 */ 741 num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log); 742 if (head_blk >= num_scan_bblks) { 743 /* 744 * We are guaranteed that the entire check can be performed 745 * in one buffer. 746 */ 747 start_blk = head_blk - num_scan_bblks; 748 if ((error = xlog_find_verify_cycle(log, 749 start_blk, num_scan_bblks, 750 stop_on_cycle, &new_blk))) 751 goto bp_err; 752 if (new_blk != -1) 753 head_blk = new_blk; 754 } else { /* need to read 2 parts of log */ 755 /* 756 * We are going to scan backwards in the log in two parts. 757 * First we scan the physical end of the log. In this part 758 * of the log, we are looking for blocks with cycle number 759 * last_half_cycle - 1. 760 * If we find one, then we know that the log starts there, as 761 * we've found a hole that didn't get written in going around 762 * the end of the physical log. The simple case for this is 763 * x + 1 ... | x ... | x - 1 | x 764 * <---------> less than scan distance 765 * If all of the blocks at the end of the log have cycle number 766 * last_half_cycle, then we check the blocks at the start of 767 * the log looking for occurrences of last_half_cycle. If we 768 * find one, then our current estimate for the location of the 769 * first occurrence of last_half_cycle is wrong and we move 770 * back to the hole we've found. This case looks like 771 * x + 1 ... | x | x + 1 | x ... 772 * ^ binary search stopped here 773 * Another case we need to handle that only occurs in 256k 774 * logs is 775 * x + 1 ... | x ... | x+1 | x ... 776 * ^ binary search stops here 777 * In a 256k log, the scan at the end of the log will see the 778 * x + 1 blocks. We need to skip past those since that is 779 * certainly not the head of the log. By searching for 780 * last_half_cycle-1 we accomplish that. 781 */ 782 ASSERT(head_blk <= INT_MAX && 783 (xfs_daddr_t) num_scan_bblks >= head_blk); 784 start_blk = log_bbnum - (num_scan_bblks - head_blk); 785 if ((error = xlog_find_verify_cycle(log, start_blk, 786 num_scan_bblks - (int)head_blk, 787 (stop_on_cycle - 1), &new_blk))) 788 goto bp_err; 789 if (new_blk != -1) { 790 head_blk = new_blk; 791 goto validate_head; 792 } 793 794 /* 795 * Scan beginning of log now. The last part of the physical 796 * log is good. This scan needs to verify that it doesn't find 797 * the last_half_cycle. 798 */ 799 start_blk = 0; 800 ASSERT(head_blk <= INT_MAX); 801 if ((error = xlog_find_verify_cycle(log, 802 start_blk, (int)head_blk, 803 stop_on_cycle, &new_blk))) 804 goto bp_err; 805 if (new_blk != -1) 806 head_blk = new_blk; 807 } 808 809 validate_head: 810 /* 811 * Now we need to make sure head_blk is not pointing to a block in 812 * the middle of a log record. 813 */ 814 num_scan_bblks = XLOG_REC_SHIFT(log); 815 if (head_blk >= num_scan_bblks) { 816 start_blk = head_blk - num_scan_bblks; /* don't read head_blk */ 817 818 /* start ptr at last block ptr before head_blk */ 819 error = xlog_find_verify_log_record(log, start_blk, &head_blk, 0); 820 if (error == 1) 821 error = -EIO; 822 if (error) 823 goto bp_err; 824 } else { 825 start_blk = 0; 826 ASSERT(head_blk <= INT_MAX); 827 error = xlog_find_verify_log_record(log, start_blk, &head_blk, 0); 828 if (error < 0) 829 goto bp_err; 830 if (error == 1) { 831 /* We hit the beginning of the log during our search */ 832 start_blk = log_bbnum - (num_scan_bblks - head_blk); 833 new_blk = log_bbnum; 834 ASSERT(start_blk <= INT_MAX && 835 (xfs_daddr_t) log_bbnum-start_blk >= 0); 836 ASSERT(head_blk <= INT_MAX); 837 error = xlog_find_verify_log_record(log, start_blk, 838 &new_blk, (int)head_blk); 839 if (error == 1) 840 error = -EIO; 841 if (error) 842 goto bp_err; 843 if (new_blk != log_bbnum) 844 head_blk = new_blk; 845 } else if (error) 846 goto bp_err; 847 } 848 849 xlog_put_bp(bp); 850 if (head_blk == log_bbnum) 851 *return_head_blk = 0; 852 else 853 *return_head_blk = head_blk; 854 /* 855 * When returning here, we have a good block number. Bad block 856 * means that during a previous crash, we didn't have a clean break 857 * from cycle number N to cycle number N-1. In this case, we need 858 * to find the first block with cycle number N-1. 859 */ 860 return 0; 861 862 bp_err: 863 xlog_put_bp(bp); 864 865 if (error) 866 xfs_warn(log->l_mp, "failed to find log head"); 867 return error; 868 } 869 870 /* 871 * Find the sync block number or the tail of the log. 872 * 873 * This will be the block number of the last record to have its 874 * associated buffers synced to disk. Every log record header has 875 * a sync lsn embedded in it. LSNs hold block numbers, so it is easy 876 * to get a sync block number. The only concern is to figure out which 877 * log record header to believe. 878 * 879 * The following algorithm uses the log record header with the largest 880 * lsn. The entire log record does not need to be valid. We only care 881 * that the header is valid. 882 * 883 * We could speed up search by using current head_blk buffer, but it is not 884 * available. 885 */ 886 STATIC int 887 xlog_find_tail( 888 struct xlog *log, 889 xfs_daddr_t *head_blk, 890 xfs_daddr_t *tail_blk) 891 { 892 xlog_rec_header_t *rhead; 893 xlog_op_header_t *op_head; 894 char *offset = NULL; 895 xfs_buf_t *bp; 896 int error, i, found; 897 xfs_daddr_t umount_data_blk; 898 xfs_daddr_t after_umount_blk; 899 xfs_lsn_t tail_lsn; 900 int hblks; 901 902 found = 0; 903 904 /* 905 * Find previous log record 906 */ 907 if ((error = xlog_find_head(log, head_blk))) 908 return error; 909 910 bp = xlog_get_bp(log, 1); 911 if (!bp) 912 return -ENOMEM; 913 if (*head_blk == 0) { /* special case */ 914 error = xlog_bread(log, 0, 1, bp, &offset); 915 if (error) 916 goto done; 917 918 if (xlog_get_cycle(offset) == 0) { 919 *tail_blk = 0; 920 /* leave all other log inited values alone */ 921 goto done; 922 } 923 } 924 925 /* 926 * Search backwards looking for log record header block 927 */ 928 ASSERT(*head_blk < INT_MAX); 929 for (i = (int)(*head_blk) - 1; i >= 0; i--) { 930 error = xlog_bread(log, i, 1, bp, &offset); 931 if (error) 932 goto done; 933 934 if (*(__be32 *)offset == cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) { 935 found = 1; 936 break; 937 } 938 } 939 /* 940 * If we haven't found the log record header block, start looking 941 * again from the end of the physical log. XXXmiken: There should be 942 * a check here to make sure we didn't search more than N blocks in 943 * the previous code. 944 */ 945 if (!found) { 946 for (i = log->l_logBBsize - 1; i >= (int)(*head_blk); i--) { 947 error = xlog_bread(log, i, 1, bp, &offset); 948 if (error) 949 goto done; 950 951 if (*(__be32 *)offset == 952 cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) { 953 found = 2; 954 break; 955 } 956 } 957 } 958 if (!found) { 959 xfs_warn(log->l_mp, "%s: couldn't find sync record", __func__); 960 xlog_put_bp(bp); 961 ASSERT(0); 962 return -EIO; 963 } 964 965 /* find blk_no of tail of log */ 966 rhead = (xlog_rec_header_t *)offset; 967 *tail_blk = BLOCK_LSN(be64_to_cpu(rhead->h_tail_lsn)); 968 969 /* 970 * Reset log values according to the state of the log when we 971 * crashed. In the case where head_blk == 0, we bump curr_cycle 972 * one because the next write starts a new cycle rather than 973 * continuing the cycle of the last good log record. At this 974 * point we have guaranteed that all partial log records have been 975 * accounted for. Therefore, we know that the last good log record 976 * written was complete and ended exactly on the end boundary 977 * of the physical log. 978 */ 979 log->l_prev_block = i; 980 log->l_curr_block = (int)*head_blk; 981 log->l_curr_cycle = be32_to_cpu(rhead->h_cycle); 982 if (found == 2) 983 log->l_curr_cycle++; 984 atomic64_set(&log->l_tail_lsn, be64_to_cpu(rhead->h_tail_lsn)); 985 atomic64_set(&log->l_last_sync_lsn, be64_to_cpu(rhead->h_lsn)); 986 xlog_assign_grant_head(&log->l_reserve_head.grant, log->l_curr_cycle, 987 BBTOB(log->l_curr_block)); 988 xlog_assign_grant_head(&log->l_write_head.grant, log->l_curr_cycle, 989 BBTOB(log->l_curr_block)); 990 991 /* 992 * Look for unmount record. If we find it, then we know there 993 * was a clean unmount. Since 'i' could be the last block in 994 * the physical log, we convert to a log block before comparing 995 * to the head_blk. 996 * 997 * Save the current tail lsn to use to pass to 998 * xlog_clear_stale_blocks() below. We won't want to clear the 999 * unmount record if there is one, so we pass the lsn of the 1000 * unmount record rather than the block after it. 1001 */ 1002 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) { 1003 int h_size = be32_to_cpu(rhead->h_size); 1004 int h_version = be32_to_cpu(rhead->h_version); 1005 1006 if ((h_version & XLOG_VERSION_2) && 1007 (h_size > XLOG_HEADER_CYCLE_SIZE)) { 1008 hblks = h_size / XLOG_HEADER_CYCLE_SIZE; 1009 if (h_size % XLOG_HEADER_CYCLE_SIZE) 1010 hblks++; 1011 } else { 1012 hblks = 1; 1013 } 1014 } else { 1015 hblks = 1; 1016 } 1017 after_umount_blk = (i + hblks + (int) 1018 BTOBB(be32_to_cpu(rhead->h_len))) % log->l_logBBsize; 1019 tail_lsn = atomic64_read(&log->l_tail_lsn); 1020 if (*head_blk == after_umount_blk && 1021 be32_to_cpu(rhead->h_num_logops) == 1) { 1022 umount_data_blk = (i + hblks) % log->l_logBBsize; 1023 error = xlog_bread(log, umount_data_blk, 1, bp, &offset); 1024 if (error) 1025 goto done; 1026 1027 op_head = (xlog_op_header_t *)offset; 1028 if (op_head->oh_flags & XLOG_UNMOUNT_TRANS) { 1029 /* 1030 * Set tail and last sync so that newly written 1031 * log records will point recovery to after the 1032 * current unmount record. 1033 */ 1034 xlog_assign_atomic_lsn(&log->l_tail_lsn, 1035 log->l_curr_cycle, after_umount_blk); 1036 xlog_assign_atomic_lsn(&log->l_last_sync_lsn, 1037 log->l_curr_cycle, after_umount_blk); 1038 *tail_blk = after_umount_blk; 1039 1040 /* 1041 * Note that the unmount was clean. If the unmount 1042 * was not clean, we need to know this to rebuild the 1043 * superblock counters from the perag headers if we 1044 * have a filesystem using non-persistent counters. 1045 */ 1046 log->l_mp->m_flags |= XFS_MOUNT_WAS_CLEAN; 1047 } 1048 } 1049 1050 /* 1051 * Make sure that there are no blocks in front of the head 1052 * with the same cycle number as the head. This can happen 1053 * because we allow multiple outstanding log writes concurrently, 1054 * and the later writes might make it out before earlier ones. 1055 * 1056 * We use the lsn from before modifying it so that we'll never 1057 * overwrite the unmount record after a clean unmount. 1058 * 1059 * Do this only if we are going to recover the filesystem 1060 * 1061 * NOTE: This used to say "if (!readonly)" 1062 * However on Linux, we can & do recover a read-only filesystem. 1063 * We only skip recovery if NORECOVERY is specified on mount, 1064 * in which case we would not be here. 1065 * 1066 * But... if the -device- itself is readonly, just skip this. 1067 * We can't recover this device anyway, so it won't matter. 1068 */ 1069 if (!xfs_readonly_buftarg(log->l_mp->m_logdev_targp)) 1070 error = xlog_clear_stale_blocks(log, tail_lsn); 1071 1072 done: 1073 xlog_put_bp(bp); 1074 1075 if (error) 1076 xfs_warn(log->l_mp, "failed to locate log tail"); 1077 return error; 1078 } 1079 1080 /* 1081 * Is the log zeroed at all? 1082 * 1083 * The last binary search should be changed to perform an X block read 1084 * once X becomes small enough. You can then search linearly through 1085 * the X blocks. This will cut down on the number of reads we need to do. 1086 * 1087 * If the log is partially zeroed, this routine will pass back the blkno 1088 * of the first block with cycle number 0. It won't have a complete LR 1089 * preceding it. 1090 * 1091 * Return: 1092 * 0 => the log is completely written to 1093 * 1 => use *blk_no as the first block of the log 1094 * <0 => error has occurred 1095 */ 1096 STATIC int 1097 xlog_find_zeroed( 1098 struct xlog *log, 1099 xfs_daddr_t *blk_no) 1100 { 1101 xfs_buf_t *bp; 1102 char *offset; 1103 uint first_cycle, last_cycle; 1104 xfs_daddr_t new_blk, last_blk, start_blk; 1105 xfs_daddr_t num_scan_bblks; 1106 int error, log_bbnum = log->l_logBBsize; 1107 1108 *blk_no = 0; 1109 1110 /* check totally zeroed log */ 1111 bp = xlog_get_bp(log, 1); 1112 if (!bp) 1113 return -ENOMEM; 1114 error = xlog_bread(log, 0, 1, bp, &offset); 1115 if (error) 1116 goto bp_err; 1117 1118 first_cycle = xlog_get_cycle(offset); 1119 if (first_cycle == 0) { /* completely zeroed log */ 1120 *blk_no = 0; 1121 xlog_put_bp(bp); 1122 return 1; 1123 } 1124 1125 /* check partially zeroed log */ 1126 error = xlog_bread(log, log_bbnum-1, 1, bp, &offset); 1127 if (error) 1128 goto bp_err; 1129 1130 last_cycle = xlog_get_cycle(offset); 1131 if (last_cycle != 0) { /* log completely written to */ 1132 xlog_put_bp(bp); 1133 return 0; 1134 } else if (first_cycle != 1) { 1135 /* 1136 * If the cycle of the last block is zero, the cycle of 1137 * the first block must be 1. If it's not, maybe we're 1138 * not looking at a log... Bail out. 1139 */ 1140 xfs_warn(log->l_mp, 1141 "Log inconsistent or not a log (last==0, first!=1)"); 1142 error = -EINVAL; 1143 goto bp_err; 1144 } 1145 1146 /* we have a partially zeroed log */ 1147 last_blk = log_bbnum-1; 1148 if ((error = xlog_find_cycle_start(log, bp, 0, &last_blk, 0))) 1149 goto bp_err; 1150 1151 /* 1152 * Validate the answer. Because there is no way to guarantee that 1153 * the entire log is made up of log records which are the same size, 1154 * we scan over the defined maximum blocks. At this point, the maximum 1155 * is not chosen to mean anything special. XXXmiken 1156 */ 1157 num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log); 1158 ASSERT(num_scan_bblks <= INT_MAX); 1159 1160 if (last_blk < num_scan_bblks) 1161 num_scan_bblks = last_blk; 1162 start_blk = last_blk - num_scan_bblks; 1163 1164 /* 1165 * We search for any instances of cycle number 0 that occur before 1166 * our current estimate of the head. What we're trying to detect is 1167 * 1 ... | 0 | 1 | 0... 1168 * ^ binary search ends here 1169 */ 1170 if ((error = xlog_find_verify_cycle(log, start_blk, 1171 (int)num_scan_bblks, 0, &new_blk))) 1172 goto bp_err; 1173 if (new_blk != -1) 1174 last_blk = new_blk; 1175 1176 /* 1177 * Potentially backup over partial log record write. We don't need 1178 * to search the end of the log because we know it is zero. 1179 */ 1180 error = xlog_find_verify_log_record(log, start_blk, &last_blk, 0); 1181 if (error == 1) 1182 error = -EIO; 1183 if (error) 1184 goto bp_err; 1185 1186 *blk_no = last_blk; 1187 bp_err: 1188 xlog_put_bp(bp); 1189 if (error) 1190 return error; 1191 return 1; 1192 } 1193 1194 /* 1195 * These are simple subroutines used by xlog_clear_stale_blocks() below 1196 * to initialize a buffer full of empty log record headers and write 1197 * them into the log. 1198 */ 1199 STATIC void 1200 xlog_add_record( 1201 struct xlog *log, 1202 char *buf, 1203 int cycle, 1204 int block, 1205 int tail_cycle, 1206 int tail_block) 1207 { 1208 xlog_rec_header_t *recp = (xlog_rec_header_t *)buf; 1209 1210 memset(buf, 0, BBSIZE); 1211 recp->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM); 1212 recp->h_cycle = cpu_to_be32(cycle); 1213 recp->h_version = cpu_to_be32( 1214 xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1); 1215 recp->h_lsn = cpu_to_be64(xlog_assign_lsn(cycle, block)); 1216 recp->h_tail_lsn = cpu_to_be64(xlog_assign_lsn(tail_cycle, tail_block)); 1217 recp->h_fmt = cpu_to_be32(XLOG_FMT); 1218 memcpy(&recp->h_fs_uuid, &log->l_mp->m_sb.sb_uuid, sizeof(uuid_t)); 1219 } 1220 1221 STATIC int 1222 xlog_write_log_records( 1223 struct xlog *log, 1224 int cycle, 1225 int start_block, 1226 int blocks, 1227 int tail_cycle, 1228 int tail_block) 1229 { 1230 char *offset; 1231 xfs_buf_t *bp; 1232 int balign, ealign; 1233 int sectbb = log->l_sectBBsize; 1234 int end_block = start_block + blocks; 1235 int bufblks; 1236 int error = 0; 1237 int i, j = 0; 1238 1239 /* 1240 * Greedily allocate a buffer big enough to handle the full 1241 * range of basic blocks to be written. If that fails, try 1242 * a smaller size. We need to be able to write at least a 1243 * log sector, or we're out of luck. 1244 */ 1245 bufblks = 1 << ffs(blocks); 1246 while (bufblks > log->l_logBBsize) 1247 bufblks >>= 1; 1248 while (!(bp = xlog_get_bp(log, bufblks))) { 1249 bufblks >>= 1; 1250 if (bufblks < sectbb) 1251 return -ENOMEM; 1252 } 1253 1254 /* We may need to do a read at the start to fill in part of 1255 * the buffer in the starting sector not covered by the first 1256 * write below. 1257 */ 1258 balign = round_down(start_block, sectbb); 1259 if (balign != start_block) { 1260 error = xlog_bread_noalign(log, start_block, 1, bp); 1261 if (error) 1262 goto out_put_bp; 1263 1264 j = start_block - balign; 1265 } 1266 1267 for (i = start_block; i < end_block; i += bufblks) { 1268 int bcount, endcount; 1269 1270 bcount = min(bufblks, end_block - start_block); 1271 endcount = bcount - j; 1272 1273 /* We may need to do a read at the end to fill in part of 1274 * the buffer in the final sector not covered by the write. 1275 * If this is the same sector as the above read, skip it. 1276 */ 1277 ealign = round_down(end_block, sectbb); 1278 if (j == 0 && (start_block + endcount > ealign)) { 1279 offset = bp->b_addr + BBTOB(ealign - start_block); 1280 error = xlog_bread_offset(log, ealign, sectbb, 1281 bp, offset); 1282 if (error) 1283 break; 1284 1285 } 1286 1287 offset = xlog_align(log, start_block, endcount, bp); 1288 for (; j < endcount; j++) { 1289 xlog_add_record(log, offset, cycle, i+j, 1290 tail_cycle, tail_block); 1291 offset += BBSIZE; 1292 } 1293 error = xlog_bwrite(log, start_block, endcount, bp); 1294 if (error) 1295 break; 1296 start_block += endcount; 1297 j = 0; 1298 } 1299 1300 out_put_bp: 1301 xlog_put_bp(bp); 1302 return error; 1303 } 1304 1305 /* 1306 * This routine is called to blow away any incomplete log writes out 1307 * in front of the log head. We do this so that we won't become confused 1308 * if we come up, write only a little bit more, and then crash again. 1309 * If we leave the partial log records out there, this situation could 1310 * cause us to think those partial writes are valid blocks since they 1311 * have the current cycle number. We get rid of them by overwriting them 1312 * with empty log records with the old cycle number rather than the 1313 * current one. 1314 * 1315 * The tail lsn is passed in rather than taken from 1316 * the log so that we will not write over the unmount record after a 1317 * clean unmount in a 512 block log. Doing so would leave the log without 1318 * any valid log records in it until a new one was written. If we crashed 1319 * during that time we would not be able to recover. 1320 */ 1321 STATIC int 1322 xlog_clear_stale_blocks( 1323 struct xlog *log, 1324 xfs_lsn_t tail_lsn) 1325 { 1326 int tail_cycle, head_cycle; 1327 int tail_block, head_block; 1328 int tail_distance, max_distance; 1329 int distance; 1330 int error; 1331 1332 tail_cycle = CYCLE_LSN(tail_lsn); 1333 tail_block = BLOCK_LSN(tail_lsn); 1334 head_cycle = log->l_curr_cycle; 1335 head_block = log->l_curr_block; 1336 1337 /* 1338 * Figure out the distance between the new head of the log 1339 * and the tail. We want to write over any blocks beyond the 1340 * head that we may have written just before the crash, but 1341 * we don't want to overwrite the tail of the log. 1342 */ 1343 if (head_cycle == tail_cycle) { 1344 /* 1345 * The tail is behind the head in the physical log, 1346 * so the distance from the head to the tail is the 1347 * distance from the head to the end of the log plus 1348 * the distance from the beginning of the log to the 1349 * tail. 1350 */ 1351 if (unlikely(head_block < tail_block || head_block >= log->l_logBBsize)) { 1352 XFS_ERROR_REPORT("xlog_clear_stale_blocks(1)", 1353 XFS_ERRLEVEL_LOW, log->l_mp); 1354 return -EFSCORRUPTED; 1355 } 1356 tail_distance = tail_block + (log->l_logBBsize - head_block); 1357 } else { 1358 /* 1359 * The head is behind the tail in the physical log, 1360 * so the distance from the head to the tail is just 1361 * the tail block minus the head block. 1362 */ 1363 if (unlikely(head_block >= tail_block || head_cycle != (tail_cycle + 1))){ 1364 XFS_ERROR_REPORT("xlog_clear_stale_blocks(2)", 1365 XFS_ERRLEVEL_LOW, log->l_mp); 1366 return -EFSCORRUPTED; 1367 } 1368 tail_distance = tail_block - head_block; 1369 } 1370 1371 /* 1372 * If the head is right up against the tail, we can't clear 1373 * anything. 1374 */ 1375 if (tail_distance <= 0) { 1376 ASSERT(tail_distance == 0); 1377 return 0; 1378 } 1379 1380 max_distance = XLOG_TOTAL_REC_SHIFT(log); 1381 /* 1382 * Take the smaller of the maximum amount of outstanding I/O 1383 * we could have and the distance to the tail to clear out. 1384 * We take the smaller so that we don't overwrite the tail and 1385 * we don't waste all day writing from the head to the tail 1386 * for no reason. 1387 */ 1388 max_distance = MIN(max_distance, tail_distance); 1389 1390 if ((head_block + max_distance) <= log->l_logBBsize) { 1391 /* 1392 * We can stomp all the blocks we need to without 1393 * wrapping around the end of the log. Just do it 1394 * in a single write. Use the cycle number of the 1395 * current cycle minus one so that the log will look like: 1396 * n ... | n - 1 ... 1397 */ 1398 error = xlog_write_log_records(log, (head_cycle - 1), 1399 head_block, max_distance, tail_cycle, 1400 tail_block); 1401 if (error) 1402 return error; 1403 } else { 1404 /* 1405 * We need to wrap around the end of the physical log in 1406 * order to clear all the blocks. Do it in two separate 1407 * I/Os. The first write should be from the head to the 1408 * end of the physical log, and it should use the current 1409 * cycle number minus one just like above. 1410 */ 1411 distance = log->l_logBBsize - head_block; 1412 error = xlog_write_log_records(log, (head_cycle - 1), 1413 head_block, distance, tail_cycle, 1414 tail_block); 1415 1416 if (error) 1417 return error; 1418 1419 /* 1420 * Now write the blocks at the start of the physical log. 1421 * This writes the remainder of the blocks we want to clear. 1422 * It uses the current cycle number since we're now on the 1423 * same cycle as the head so that we get: 1424 * n ... n ... | n - 1 ... 1425 * ^^^^^ blocks we're writing 1426 */ 1427 distance = max_distance - (log->l_logBBsize - head_block); 1428 error = xlog_write_log_records(log, head_cycle, 0, distance, 1429 tail_cycle, tail_block); 1430 if (error) 1431 return error; 1432 } 1433 1434 return 0; 1435 } 1436 1437 /****************************************************************************** 1438 * 1439 * Log recover routines 1440 * 1441 ****************************************************************************** 1442 */ 1443 1444 /* 1445 * Sort the log items in the transaction. 1446 * 1447 * The ordering constraints are defined by the inode allocation and unlink 1448 * behaviour. The rules are: 1449 * 1450 * 1. Every item is only logged once in a given transaction. Hence it 1451 * represents the last logged state of the item. Hence ordering is 1452 * dependent on the order in which operations need to be performed so 1453 * required initial conditions are always met. 1454 * 1455 * 2. Cancelled buffers are recorded in pass 1 in a separate table and 1456 * there's nothing to replay from them so we can simply cull them 1457 * from the transaction. However, we can't do that until after we've 1458 * replayed all the other items because they may be dependent on the 1459 * cancelled buffer and replaying the cancelled buffer can remove it 1460 * form the cancelled buffer table. Hence they have tobe done last. 1461 * 1462 * 3. Inode allocation buffers must be replayed before inode items that 1463 * read the buffer and replay changes into it. For filesystems using the 1464 * ICREATE transactions, this means XFS_LI_ICREATE objects need to get 1465 * treated the same as inode allocation buffers as they create and 1466 * initialise the buffers directly. 1467 * 1468 * 4. Inode unlink buffers must be replayed after inode items are replayed. 1469 * This ensures that inodes are completely flushed to the inode buffer 1470 * in a "free" state before we remove the unlinked inode list pointer. 1471 * 1472 * Hence the ordering needs to be inode allocation buffers first, inode items 1473 * second, inode unlink buffers third and cancelled buffers last. 1474 * 1475 * But there's a problem with that - we can't tell an inode allocation buffer 1476 * apart from a regular buffer, so we can't separate them. We can, however, 1477 * tell an inode unlink buffer from the others, and so we can separate them out 1478 * from all the other buffers and move them to last. 1479 * 1480 * Hence, 4 lists, in order from head to tail: 1481 * - buffer_list for all buffers except cancelled/inode unlink buffers 1482 * - item_list for all non-buffer items 1483 * - inode_buffer_list for inode unlink buffers 1484 * - cancel_list for the cancelled buffers 1485 * 1486 * Note that we add objects to the tail of the lists so that first-to-last 1487 * ordering is preserved within the lists. Adding objects to the head of the 1488 * list means when we traverse from the head we walk them in last-to-first 1489 * order. For cancelled buffers and inode unlink buffers this doesn't matter, 1490 * but for all other items there may be specific ordering that we need to 1491 * preserve. 1492 */ 1493 STATIC int 1494 xlog_recover_reorder_trans( 1495 struct xlog *log, 1496 struct xlog_recover *trans, 1497 int pass) 1498 { 1499 xlog_recover_item_t *item, *n; 1500 int error = 0; 1501 LIST_HEAD(sort_list); 1502 LIST_HEAD(cancel_list); 1503 LIST_HEAD(buffer_list); 1504 LIST_HEAD(inode_buffer_list); 1505 LIST_HEAD(inode_list); 1506 1507 list_splice_init(&trans->r_itemq, &sort_list); 1508 list_for_each_entry_safe(item, n, &sort_list, ri_list) { 1509 xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr; 1510 1511 switch (ITEM_TYPE(item)) { 1512 case XFS_LI_ICREATE: 1513 list_move_tail(&item->ri_list, &buffer_list); 1514 break; 1515 case XFS_LI_BUF: 1516 if (buf_f->blf_flags & XFS_BLF_CANCEL) { 1517 trace_xfs_log_recover_item_reorder_head(log, 1518 trans, item, pass); 1519 list_move(&item->ri_list, &cancel_list); 1520 break; 1521 } 1522 if (buf_f->blf_flags & XFS_BLF_INODE_BUF) { 1523 list_move(&item->ri_list, &inode_buffer_list); 1524 break; 1525 } 1526 list_move_tail(&item->ri_list, &buffer_list); 1527 break; 1528 case XFS_LI_INODE: 1529 case XFS_LI_DQUOT: 1530 case XFS_LI_QUOTAOFF: 1531 case XFS_LI_EFD: 1532 case XFS_LI_EFI: 1533 trace_xfs_log_recover_item_reorder_tail(log, 1534 trans, item, pass); 1535 list_move_tail(&item->ri_list, &inode_list); 1536 break; 1537 default: 1538 xfs_warn(log->l_mp, 1539 "%s: unrecognized type of log operation", 1540 __func__); 1541 ASSERT(0); 1542 /* 1543 * return the remaining items back to the transaction 1544 * item list so they can be freed in caller. 1545 */ 1546 if (!list_empty(&sort_list)) 1547 list_splice_init(&sort_list, &trans->r_itemq); 1548 error = -EIO; 1549 goto out; 1550 } 1551 } 1552 out: 1553 ASSERT(list_empty(&sort_list)); 1554 if (!list_empty(&buffer_list)) 1555 list_splice(&buffer_list, &trans->r_itemq); 1556 if (!list_empty(&inode_list)) 1557 list_splice_tail(&inode_list, &trans->r_itemq); 1558 if (!list_empty(&inode_buffer_list)) 1559 list_splice_tail(&inode_buffer_list, &trans->r_itemq); 1560 if (!list_empty(&cancel_list)) 1561 list_splice_tail(&cancel_list, &trans->r_itemq); 1562 return error; 1563 } 1564 1565 /* 1566 * Build up the table of buf cancel records so that we don't replay 1567 * cancelled data in the second pass. For buffer records that are 1568 * not cancel records, there is nothing to do here so we just return. 1569 * 1570 * If we get a cancel record which is already in the table, this indicates 1571 * that the buffer was cancelled multiple times. In order to ensure 1572 * that during pass 2 we keep the record in the table until we reach its 1573 * last occurrence in the log, we keep a reference count in the cancel 1574 * record in the table to tell us how many times we expect to see this 1575 * record during the second pass. 1576 */ 1577 STATIC int 1578 xlog_recover_buffer_pass1( 1579 struct xlog *log, 1580 struct xlog_recover_item *item) 1581 { 1582 xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr; 1583 struct list_head *bucket; 1584 struct xfs_buf_cancel *bcp; 1585 1586 /* 1587 * If this isn't a cancel buffer item, then just return. 1588 */ 1589 if (!(buf_f->blf_flags & XFS_BLF_CANCEL)) { 1590 trace_xfs_log_recover_buf_not_cancel(log, buf_f); 1591 return 0; 1592 } 1593 1594 /* 1595 * Insert an xfs_buf_cancel record into the hash table of them. 1596 * If there is already an identical record, bump its reference count. 1597 */ 1598 bucket = XLOG_BUF_CANCEL_BUCKET(log, buf_f->blf_blkno); 1599 list_for_each_entry(bcp, bucket, bc_list) { 1600 if (bcp->bc_blkno == buf_f->blf_blkno && 1601 bcp->bc_len == buf_f->blf_len) { 1602 bcp->bc_refcount++; 1603 trace_xfs_log_recover_buf_cancel_ref_inc(log, buf_f); 1604 return 0; 1605 } 1606 } 1607 1608 bcp = kmem_alloc(sizeof(struct xfs_buf_cancel), KM_SLEEP); 1609 bcp->bc_blkno = buf_f->blf_blkno; 1610 bcp->bc_len = buf_f->blf_len; 1611 bcp->bc_refcount = 1; 1612 list_add_tail(&bcp->bc_list, bucket); 1613 1614 trace_xfs_log_recover_buf_cancel_add(log, buf_f); 1615 return 0; 1616 } 1617 1618 /* 1619 * Check to see whether the buffer being recovered has a corresponding 1620 * entry in the buffer cancel record table. If it is, return the cancel 1621 * buffer structure to the caller. 1622 */ 1623 STATIC struct xfs_buf_cancel * 1624 xlog_peek_buffer_cancelled( 1625 struct xlog *log, 1626 xfs_daddr_t blkno, 1627 uint len, 1628 ushort flags) 1629 { 1630 struct list_head *bucket; 1631 struct xfs_buf_cancel *bcp; 1632 1633 if (!log->l_buf_cancel_table) { 1634 /* empty table means no cancelled buffers in the log */ 1635 ASSERT(!(flags & XFS_BLF_CANCEL)); 1636 return NULL; 1637 } 1638 1639 bucket = XLOG_BUF_CANCEL_BUCKET(log, blkno); 1640 list_for_each_entry(bcp, bucket, bc_list) { 1641 if (bcp->bc_blkno == blkno && bcp->bc_len == len) 1642 return bcp; 1643 } 1644 1645 /* 1646 * We didn't find a corresponding entry in the table, so return 0 so 1647 * that the buffer is NOT cancelled. 1648 */ 1649 ASSERT(!(flags & XFS_BLF_CANCEL)); 1650 return NULL; 1651 } 1652 1653 /* 1654 * If the buffer is being cancelled then return 1 so that it will be cancelled, 1655 * otherwise return 0. If the buffer is actually a buffer cancel item 1656 * (XFS_BLF_CANCEL is set), then decrement the refcount on the entry in the 1657 * table and remove it from the table if this is the last reference. 1658 * 1659 * We remove the cancel record from the table when we encounter its last 1660 * occurrence in the log so that if the same buffer is re-used again after its 1661 * last cancellation we actually replay the changes made at that point. 1662 */ 1663 STATIC int 1664 xlog_check_buffer_cancelled( 1665 struct xlog *log, 1666 xfs_daddr_t blkno, 1667 uint len, 1668 ushort flags) 1669 { 1670 struct xfs_buf_cancel *bcp; 1671 1672 bcp = xlog_peek_buffer_cancelled(log, blkno, len, flags); 1673 if (!bcp) 1674 return 0; 1675 1676 /* 1677 * We've go a match, so return 1 so that the recovery of this buffer 1678 * is cancelled. If this buffer is actually a buffer cancel log 1679 * item, then decrement the refcount on the one in the table and 1680 * remove it if this is the last reference. 1681 */ 1682 if (flags & XFS_BLF_CANCEL) { 1683 if (--bcp->bc_refcount == 0) { 1684 list_del(&bcp->bc_list); 1685 kmem_free(bcp); 1686 } 1687 } 1688 return 1; 1689 } 1690 1691 /* 1692 * Perform recovery for a buffer full of inodes. In these buffers, the only 1693 * data which should be recovered is that which corresponds to the 1694 * di_next_unlinked pointers in the on disk inode structures. The rest of the 1695 * data for the inodes is always logged through the inodes themselves rather 1696 * than the inode buffer and is recovered in xlog_recover_inode_pass2(). 1697 * 1698 * The only time when buffers full of inodes are fully recovered is when the 1699 * buffer is full of newly allocated inodes. In this case the buffer will 1700 * not be marked as an inode buffer and so will be sent to 1701 * xlog_recover_do_reg_buffer() below during recovery. 1702 */ 1703 STATIC int 1704 xlog_recover_do_inode_buffer( 1705 struct xfs_mount *mp, 1706 xlog_recover_item_t *item, 1707 struct xfs_buf *bp, 1708 xfs_buf_log_format_t *buf_f) 1709 { 1710 int i; 1711 int item_index = 0; 1712 int bit = 0; 1713 int nbits = 0; 1714 int reg_buf_offset = 0; 1715 int reg_buf_bytes = 0; 1716 int next_unlinked_offset; 1717 int inodes_per_buf; 1718 xfs_agino_t *logged_nextp; 1719 xfs_agino_t *buffer_nextp; 1720 1721 trace_xfs_log_recover_buf_inode_buf(mp->m_log, buf_f); 1722 1723 /* 1724 * Post recovery validation only works properly on CRC enabled 1725 * filesystems. 1726 */ 1727 if (xfs_sb_version_hascrc(&mp->m_sb)) 1728 bp->b_ops = &xfs_inode_buf_ops; 1729 1730 inodes_per_buf = BBTOB(bp->b_io_length) >> mp->m_sb.sb_inodelog; 1731 for (i = 0; i < inodes_per_buf; i++) { 1732 next_unlinked_offset = (i * mp->m_sb.sb_inodesize) + 1733 offsetof(xfs_dinode_t, di_next_unlinked); 1734 1735 while (next_unlinked_offset >= 1736 (reg_buf_offset + reg_buf_bytes)) { 1737 /* 1738 * The next di_next_unlinked field is beyond 1739 * the current logged region. Find the next 1740 * logged region that contains or is beyond 1741 * the current di_next_unlinked field. 1742 */ 1743 bit += nbits; 1744 bit = xfs_next_bit(buf_f->blf_data_map, 1745 buf_f->blf_map_size, bit); 1746 1747 /* 1748 * If there are no more logged regions in the 1749 * buffer, then we're done. 1750 */ 1751 if (bit == -1) 1752 return 0; 1753 1754 nbits = xfs_contig_bits(buf_f->blf_data_map, 1755 buf_f->blf_map_size, bit); 1756 ASSERT(nbits > 0); 1757 reg_buf_offset = bit << XFS_BLF_SHIFT; 1758 reg_buf_bytes = nbits << XFS_BLF_SHIFT; 1759 item_index++; 1760 } 1761 1762 /* 1763 * If the current logged region starts after the current 1764 * di_next_unlinked field, then move on to the next 1765 * di_next_unlinked field. 1766 */ 1767 if (next_unlinked_offset < reg_buf_offset) 1768 continue; 1769 1770 ASSERT(item->ri_buf[item_index].i_addr != NULL); 1771 ASSERT((item->ri_buf[item_index].i_len % XFS_BLF_CHUNK) == 0); 1772 ASSERT((reg_buf_offset + reg_buf_bytes) <= 1773 BBTOB(bp->b_io_length)); 1774 1775 /* 1776 * The current logged region contains a copy of the 1777 * current di_next_unlinked field. Extract its value 1778 * and copy it to the buffer copy. 1779 */ 1780 logged_nextp = item->ri_buf[item_index].i_addr + 1781 next_unlinked_offset - reg_buf_offset; 1782 if (unlikely(*logged_nextp == 0)) { 1783 xfs_alert(mp, 1784 "Bad inode buffer log record (ptr = 0x%p, bp = 0x%p). " 1785 "Trying to replay bad (0) inode di_next_unlinked field.", 1786 item, bp); 1787 XFS_ERROR_REPORT("xlog_recover_do_inode_buf", 1788 XFS_ERRLEVEL_LOW, mp); 1789 return -EFSCORRUPTED; 1790 } 1791 1792 buffer_nextp = xfs_buf_offset(bp, next_unlinked_offset); 1793 *buffer_nextp = *logged_nextp; 1794 1795 /* 1796 * If necessary, recalculate the CRC in the on-disk inode. We 1797 * have to leave the inode in a consistent state for whoever 1798 * reads it next.... 1799 */ 1800 xfs_dinode_calc_crc(mp, 1801 xfs_buf_offset(bp, i * mp->m_sb.sb_inodesize)); 1802 1803 } 1804 1805 return 0; 1806 } 1807 1808 /* 1809 * V5 filesystems know the age of the buffer on disk being recovered. We can 1810 * have newer objects on disk than we are replaying, and so for these cases we 1811 * don't want to replay the current change as that will make the buffer contents 1812 * temporarily invalid on disk. 1813 * 1814 * The magic number might not match the buffer type we are going to recover 1815 * (e.g. reallocated blocks), so we ignore the xfs_buf_log_format flags. Hence 1816 * extract the LSN of the existing object in the buffer based on it's current 1817 * magic number. If we don't recognise the magic number in the buffer, then 1818 * return a LSN of -1 so that the caller knows it was an unrecognised block and 1819 * so can recover the buffer. 1820 * 1821 * Note: we cannot rely solely on magic number matches to determine that the 1822 * buffer has a valid LSN - we also need to verify that it belongs to this 1823 * filesystem, so we need to extract the object's LSN and compare it to that 1824 * which we read from the superblock. If the UUIDs don't match, then we've got a 1825 * stale metadata block from an old filesystem instance that we need to recover 1826 * over the top of. 1827 */ 1828 static xfs_lsn_t 1829 xlog_recover_get_buf_lsn( 1830 struct xfs_mount *mp, 1831 struct xfs_buf *bp) 1832 { 1833 __uint32_t magic32; 1834 __uint16_t magic16; 1835 __uint16_t magicda; 1836 void *blk = bp->b_addr; 1837 uuid_t *uuid; 1838 xfs_lsn_t lsn = -1; 1839 1840 /* v4 filesystems always recover immediately */ 1841 if (!xfs_sb_version_hascrc(&mp->m_sb)) 1842 goto recover_immediately; 1843 1844 magic32 = be32_to_cpu(*(__be32 *)blk); 1845 switch (magic32) { 1846 case XFS_ABTB_CRC_MAGIC: 1847 case XFS_ABTC_CRC_MAGIC: 1848 case XFS_ABTB_MAGIC: 1849 case XFS_ABTC_MAGIC: 1850 case XFS_IBT_CRC_MAGIC: 1851 case XFS_IBT_MAGIC: { 1852 struct xfs_btree_block *btb = blk; 1853 1854 lsn = be64_to_cpu(btb->bb_u.s.bb_lsn); 1855 uuid = &btb->bb_u.s.bb_uuid; 1856 break; 1857 } 1858 case XFS_BMAP_CRC_MAGIC: 1859 case XFS_BMAP_MAGIC: { 1860 struct xfs_btree_block *btb = blk; 1861 1862 lsn = be64_to_cpu(btb->bb_u.l.bb_lsn); 1863 uuid = &btb->bb_u.l.bb_uuid; 1864 break; 1865 } 1866 case XFS_AGF_MAGIC: 1867 lsn = be64_to_cpu(((struct xfs_agf *)blk)->agf_lsn); 1868 uuid = &((struct xfs_agf *)blk)->agf_uuid; 1869 break; 1870 case XFS_AGFL_MAGIC: 1871 lsn = be64_to_cpu(((struct xfs_agfl *)blk)->agfl_lsn); 1872 uuid = &((struct xfs_agfl *)blk)->agfl_uuid; 1873 break; 1874 case XFS_AGI_MAGIC: 1875 lsn = be64_to_cpu(((struct xfs_agi *)blk)->agi_lsn); 1876 uuid = &((struct xfs_agi *)blk)->agi_uuid; 1877 break; 1878 case XFS_SYMLINK_MAGIC: 1879 lsn = be64_to_cpu(((struct xfs_dsymlink_hdr *)blk)->sl_lsn); 1880 uuid = &((struct xfs_dsymlink_hdr *)blk)->sl_uuid; 1881 break; 1882 case XFS_DIR3_BLOCK_MAGIC: 1883 case XFS_DIR3_DATA_MAGIC: 1884 case XFS_DIR3_FREE_MAGIC: 1885 lsn = be64_to_cpu(((struct xfs_dir3_blk_hdr *)blk)->lsn); 1886 uuid = &((struct xfs_dir3_blk_hdr *)blk)->uuid; 1887 break; 1888 case XFS_ATTR3_RMT_MAGIC: 1889 /* 1890 * Remote attr blocks are written synchronously, rather than 1891 * being logged. That means they do not contain a valid LSN 1892 * (i.e. transactionally ordered) in them, and hence any time we 1893 * see a buffer to replay over the top of a remote attribute 1894 * block we should simply do so. 1895 */ 1896 goto recover_immediately; 1897 case XFS_SB_MAGIC: 1898 lsn = be64_to_cpu(((struct xfs_dsb *)blk)->sb_lsn); 1899 uuid = &((struct xfs_dsb *)blk)->sb_uuid; 1900 break; 1901 default: 1902 break; 1903 } 1904 1905 if (lsn != (xfs_lsn_t)-1) { 1906 if (!uuid_equal(&mp->m_sb.sb_uuid, uuid)) 1907 goto recover_immediately; 1908 return lsn; 1909 } 1910 1911 magicda = be16_to_cpu(((struct xfs_da_blkinfo *)blk)->magic); 1912 switch (magicda) { 1913 case XFS_DIR3_LEAF1_MAGIC: 1914 case XFS_DIR3_LEAFN_MAGIC: 1915 case XFS_DA3_NODE_MAGIC: 1916 lsn = be64_to_cpu(((struct xfs_da3_blkinfo *)blk)->lsn); 1917 uuid = &((struct xfs_da3_blkinfo *)blk)->uuid; 1918 break; 1919 default: 1920 break; 1921 } 1922 1923 if (lsn != (xfs_lsn_t)-1) { 1924 if (!uuid_equal(&mp->m_sb.sb_uuid, uuid)) 1925 goto recover_immediately; 1926 return lsn; 1927 } 1928 1929 /* 1930 * We do individual object checks on dquot and inode buffers as they 1931 * have their own individual LSN records. Also, we could have a stale 1932 * buffer here, so we have to at least recognise these buffer types. 1933 * 1934 * A notd complexity here is inode unlinked list processing - it logs 1935 * the inode directly in the buffer, but we don't know which inodes have 1936 * been modified, and there is no global buffer LSN. Hence we need to 1937 * recover all inode buffer types immediately. This problem will be 1938 * fixed by logical logging of the unlinked list modifications. 1939 */ 1940 magic16 = be16_to_cpu(*(__be16 *)blk); 1941 switch (magic16) { 1942 case XFS_DQUOT_MAGIC: 1943 case XFS_DINODE_MAGIC: 1944 goto recover_immediately; 1945 default: 1946 break; 1947 } 1948 1949 /* unknown buffer contents, recover immediately */ 1950 1951 recover_immediately: 1952 return (xfs_lsn_t)-1; 1953 1954 } 1955 1956 /* 1957 * Validate the recovered buffer is of the correct type and attach the 1958 * appropriate buffer operations to them for writeback. Magic numbers are in a 1959 * few places: 1960 * the first 16 bits of the buffer (inode buffer, dquot buffer), 1961 * the first 32 bits of the buffer (most blocks), 1962 * inside a struct xfs_da_blkinfo at the start of the buffer. 1963 */ 1964 static void 1965 xlog_recover_validate_buf_type( 1966 struct xfs_mount *mp, 1967 struct xfs_buf *bp, 1968 xfs_buf_log_format_t *buf_f) 1969 { 1970 struct xfs_da_blkinfo *info = bp->b_addr; 1971 __uint32_t magic32; 1972 __uint16_t magic16; 1973 __uint16_t magicda; 1974 1975 /* 1976 * We can only do post recovery validation on items on CRC enabled 1977 * fielsystems as we need to know when the buffer was written to be able 1978 * to determine if we should have replayed the item. If we replay old 1979 * metadata over a newer buffer, then it will enter a temporarily 1980 * inconsistent state resulting in verification failures. Hence for now 1981 * just avoid the verification stage for non-crc filesystems 1982 */ 1983 if (!xfs_sb_version_hascrc(&mp->m_sb)) 1984 return; 1985 1986 magic32 = be32_to_cpu(*(__be32 *)bp->b_addr); 1987 magic16 = be16_to_cpu(*(__be16*)bp->b_addr); 1988 magicda = be16_to_cpu(info->magic); 1989 switch (xfs_blft_from_flags(buf_f)) { 1990 case XFS_BLFT_BTREE_BUF: 1991 switch (magic32) { 1992 case XFS_ABTB_CRC_MAGIC: 1993 case XFS_ABTC_CRC_MAGIC: 1994 case XFS_ABTB_MAGIC: 1995 case XFS_ABTC_MAGIC: 1996 bp->b_ops = &xfs_allocbt_buf_ops; 1997 break; 1998 case XFS_IBT_CRC_MAGIC: 1999 case XFS_FIBT_CRC_MAGIC: 2000 case XFS_IBT_MAGIC: 2001 case XFS_FIBT_MAGIC: 2002 bp->b_ops = &xfs_inobt_buf_ops; 2003 break; 2004 case XFS_BMAP_CRC_MAGIC: 2005 case XFS_BMAP_MAGIC: 2006 bp->b_ops = &xfs_bmbt_buf_ops; 2007 break; 2008 default: 2009 xfs_warn(mp, "Bad btree block magic!"); 2010 ASSERT(0); 2011 break; 2012 } 2013 break; 2014 case XFS_BLFT_AGF_BUF: 2015 if (magic32 != XFS_AGF_MAGIC) { 2016 xfs_warn(mp, "Bad AGF block magic!"); 2017 ASSERT(0); 2018 break; 2019 } 2020 bp->b_ops = &xfs_agf_buf_ops; 2021 break; 2022 case XFS_BLFT_AGFL_BUF: 2023 if (magic32 != XFS_AGFL_MAGIC) { 2024 xfs_warn(mp, "Bad AGFL block magic!"); 2025 ASSERT(0); 2026 break; 2027 } 2028 bp->b_ops = &xfs_agfl_buf_ops; 2029 break; 2030 case XFS_BLFT_AGI_BUF: 2031 if (magic32 != XFS_AGI_MAGIC) { 2032 xfs_warn(mp, "Bad AGI block magic!"); 2033 ASSERT(0); 2034 break; 2035 } 2036 bp->b_ops = &xfs_agi_buf_ops; 2037 break; 2038 case XFS_BLFT_UDQUOT_BUF: 2039 case XFS_BLFT_PDQUOT_BUF: 2040 case XFS_BLFT_GDQUOT_BUF: 2041 #ifdef CONFIG_XFS_QUOTA 2042 if (magic16 != XFS_DQUOT_MAGIC) { 2043 xfs_warn(mp, "Bad DQUOT block magic!"); 2044 ASSERT(0); 2045 break; 2046 } 2047 bp->b_ops = &xfs_dquot_buf_ops; 2048 #else 2049 xfs_alert(mp, 2050 "Trying to recover dquots without QUOTA support built in!"); 2051 ASSERT(0); 2052 #endif 2053 break; 2054 case XFS_BLFT_DINO_BUF: 2055 if (magic16 != XFS_DINODE_MAGIC) { 2056 xfs_warn(mp, "Bad INODE block magic!"); 2057 ASSERT(0); 2058 break; 2059 } 2060 bp->b_ops = &xfs_inode_buf_ops; 2061 break; 2062 case XFS_BLFT_SYMLINK_BUF: 2063 if (magic32 != XFS_SYMLINK_MAGIC) { 2064 xfs_warn(mp, "Bad symlink block magic!"); 2065 ASSERT(0); 2066 break; 2067 } 2068 bp->b_ops = &xfs_symlink_buf_ops; 2069 break; 2070 case XFS_BLFT_DIR_BLOCK_BUF: 2071 if (magic32 != XFS_DIR2_BLOCK_MAGIC && 2072 magic32 != XFS_DIR3_BLOCK_MAGIC) { 2073 xfs_warn(mp, "Bad dir block magic!"); 2074 ASSERT(0); 2075 break; 2076 } 2077 bp->b_ops = &xfs_dir3_block_buf_ops; 2078 break; 2079 case XFS_BLFT_DIR_DATA_BUF: 2080 if (magic32 != XFS_DIR2_DATA_MAGIC && 2081 magic32 != XFS_DIR3_DATA_MAGIC) { 2082 xfs_warn(mp, "Bad dir data magic!"); 2083 ASSERT(0); 2084 break; 2085 } 2086 bp->b_ops = &xfs_dir3_data_buf_ops; 2087 break; 2088 case XFS_BLFT_DIR_FREE_BUF: 2089 if (magic32 != XFS_DIR2_FREE_MAGIC && 2090 magic32 != XFS_DIR3_FREE_MAGIC) { 2091 xfs_warn(mp, "Bad dir3 free magic!"); 2092 ASSERT(0); 2093 break; 2094 } 2095 bp->b_ops = &xfs_dir3_free_buf_ops; 2096 break; 2097 case XFS_BLFT_DIR_LEAF1_BUF: 2098 if (magicda != XFS_DIR2_LEAF1_MAGIC && 2099 magicda != XFS_DIR3_LEAF1_MAGIC) { 2100 xfs_warn(mp, "Bad dir leaf1 magic!"); 2101 ASSERT(0); 2102 break; 2103 } 2104 bp->b_ops = &xfs_dir3_leaf1_buf_ops; 2105 break; 2106 case XFS_BLFT_DIR_LEAFN_BUF: 2107 if (magicda != XFS_DIR2_LEAFN_MAGIC && 2108 magicda != XFS_DIR3_LEAFN_MAGIC) { 2109 xfs_warn(mp, "Bad dir leafn magic!"); 2110 ASSERT(0); 2111 break; 2112 } 2113 bp->b_ops = &xfs_dir3_leafn_buf_ops; 2114 break; 2115 case XFS_BLFT_DA_NODE_BUF: 2116 if (magicda != XFS_DA_NODE_MAGIC && 2117 magicda != XFS_DA3_NODE_MAGIC) { 2118 xfs_warn(mp, "Bad da node magic!"); 2119 ASSERT(0); 2120 break; 2121 } 2122 bp->b_ops = &xfs_da3_node_buf_ops; 2123 break; 2124 case XFS_BLFT_ATTR_LEAF_BUF: 2125 if (magicda != XFS_ATTR_LEAF_MAGIC && 2126 magicda != XFS_ATTR3_LEAF_MAGIC) { 2127 xfs_warn(mp, "Bad attr leaf magic!"); 2128 ASSERT(0); 2129 break; 2130 } 2131 bp->b_ops = &xfs_attr3_leaf_buf_ops; 2132 break; 2133 case XFS_BLFT_ATTR_RMT_BUF: 2134 if (magic32 != XFS_ATTR3_RMT_MAGIC) { 2135 xfs_warn(mp, "Bad attr remote magic!"); 2136 ASSERT(0); 2137 break; 2138 } 2139 bp->b_ops = &xfs_attr3_rmt_buf_ops; 2140 break; 2141 case XFS_BLFT_SB_BUF: 2142 if (magic32 != XFS_SB_MAGIC) { 2143 xfs_warn(mp, "Bad SB block magic!"); 2144 ASSERT(0); 2145 break; 2146 } 2147 bp->b_ops = &xfs_sb_buf_ops; 2148 break; 2149 default: 2150 xfs_warn(mp, "Unknown buffer type %d!", 2151 xfs_blft_from_flags(buf_f)); 2152 break; 2153 } 2154 } 2155 2156 /* 2157 * Perform a 'normal' buffer recovery. Each logged region of the 2158 * buffer should be copied over the corresponding region in the 2159 * given buffer. The bitmap in the buf log format structure indicates 2160 * where to place the logged data. 2161 */ 2162 STATIC void 2163 xlog_recover_do_reg_buffer( 2164 struct xfs_mount *mp, 2165 xlog_recover_item_t *item, 2166 struct xfs_buf *bp, 2167 xfs_buf_log_format_t *buf_f) 2168 { 2169 int i; 2170 int bit; 2171 int nbits; 2172 int error; 2173 2174 trace_xfs_log_recover_buf_reg_buf(mp->m_log, buf_f); 2175 2176 bit = 0; 2177 i = 1; /* 0 is the buf format structure */ 2178 while (1) { 2179 bit = xfs_next_bit(buf_f->blf_data_map, 2180 buf_f->blf_map_size, bit); 2181 if (bit == -1) 2182 break; 2183 nbits = xfs_contig_bits(buf_f->blf_data_map, 2184 buf_f->blf_map_size, bit); 2185 ASSERT(nbits > 0); 2186 ASSERT(item->ri_buf[i].i_addr != NULL); 2187 ASSERT(item->ri_buf[i].i_len % XFS_BLF_CHUNK == 0); 2188 ASSERT(BBTOB(bp->b_io_length) >= 2189 ((uint)bit << XFS_BLF_SHIFT) + (nbits << XFS_BLF_SHIFT)); 2190 2191 /* 2192 * The dirty regions logged in the buffer, even though 2193 * contiguous, may span multiple chunks. This is because the 2194 * dirty region may span a physical page boundary in a buffer 2195 * and hence be split into two separate vectors for writing into 2196 * the log. Hence we need to trim nbits back to the length of 2197 * the current region being copied out of the log. 2198 */ 2199 if (item->ri_buf[i].i_len < (nbits << XFS_BLF_SHIFT)) 2200 nbits = item->ri_buf[i].i_len >> XFS_BLF_SHIFT; 2201 2202 /* 2203 * Do a sanity check if this is a dquot buffer. Just checking 2204 * the first dquot in the buffer should do. XXXThis is 2205 * probably a good thing to do for other buf types also. 2206 */ 2207 error = 0; 2208 if (buf_f->blf_flags & 2209 (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) { 2210 if (item->ri_buf[i].i_addr == NULL) { 2211 xfs_alert(mp, 2212 "XFS: NULL dquot in %s.", __func__); 2213 goto next; 2214 } 2215 if (item->ri_buf[i].i_len < sizeof(xfs_disk_dquot_t)) { 2216 xfs_alert(mp, 2217 "XFS: dquot too small (%d) in %s.", 2218 item->ri_buf[i].i_len, __func__); 2219 goto next; 2220 } 2221 error = xfs_dqcheck(mp, item->ri_buf[i].i_addr, 2222 -1, 0, XFS_QMOPT_DOWARN, 2223 "dquot_buf_recover"); 2224 if (error) 2225 goto next; 2226 } 2227 2228 memcpy(xfs_buf_offset(bp, 2229 (uint)bit << XFS_BLF_SHIFT), /* dest */ 2230 item->ri_buf[i].i_addr, /* source */ 2231 nbits<<XFS_BLF_SHIFT); /* length */ 2232 next: 2233 i++; 2234 bit += nbits; 2235 } 2236 2237 /* Shouldn't be any more regions */ 2238 ASSERT(i == item->ri_total); 2239 2240 xlog_recover_validate_buf_type(mp, bp, buf_f); 2241 } 2242 2243 /* 2244 * Perform a dquot buffer recovery. 2245 * Simple algorithm: if we have found a QUOTAOFF log item of the same type 2246 * (ie. USR or GRP), then just toss this buffer away; don't recover it. 2247 * Else, treat it as a regular buffer and do recovery. 2248 * 2249 * Return false if the buffer was tossed and true if we recovered the buffer to 2250 * indicate to the caller if the buffer needs writing. 2251 */ 2252 STATIC bool 2253 xlog_recover_do_dquot_buffer( 2254 struct xfs_mount *mp, 2255 struct xlog *log, 2256 struct xlog_recover_item *item, 2257 struct xfs_buf *bp, 2258 struct xfs_buf_log_format *buf_f) 2259 { 2260 uint type; 2261 2262 trace_xfs_log_recover_buf_dquot_buf(log, buf_f); 2263 2264 /* 2265 * Filesystems are required to send in quota flags at mount time. 2266 */ 2267 if (!mp->m_qflags) 2268 return false; 2269 2270 type = 0; 2271 if (buf_f->blf_flags & XFS_BLF_UDQUOT_BUF) 2272 type |= XFS_DQ_USER; 2273 if (buf_f->blf_flags & XFS_BLF_PDQUOT_BUF) 2274 type |= XFS_DQ_PROJ; 2275 if (buf_f->blf_flags & XFS_BLF_GDQUOT_BUF) 2276 type |= XFS_DQ_GROUP; 2277 /* 2278 * This type of quotas was turned off, so ignore this buffer 2279 */ 2280 if (log->l_quotaoffs_flag & type) 2281 return false; 2282 2283 xlog_recover_do_reg_buffer(mp, item, bp, buf_f); 2284 return true; 2285 } 2286 2287 /* 2288 * This routine replays a modification made to a buffer at runtime. 2289 * There are actually two types of buffer, regular and inode, which 2290 * are handled differently. Inode buffers are handled differently 2291 * in that we only recover a specific set of data from them, namely 2292 * the inode di_next_unlinked fields. This is because all other inode 2293 * data is actually logged via inode records and any data we replay 2294 * here which overlaps that may be stale. 2295 * 2296 * When meta-data buffers are freed at run time we log a buffer item 2297 * with the XFS_BLF_CANCEL bit set to indicate that previous copies 2298 * of the buffer in the log should not be replayed at recovery time. 2299 * This is so that if the blocks covered by the buffer are reused for 2300 * file data before we crash we don't end up replaying old, freed 2301 * meta-data into a user's file. 2302 * 2303 * To handle the cancellation of buffer log items, we make two passes 2304 * over the log during recovery. During the first we build a table of 2305 * those buffers which have been cancelled, and during the second we 2306 * only replay those buffers which do not have corresponding cancel 2307 * records in the table. See xlog_recover_buffer_pass[1,2] above 2308 * for more details on the implementation of the table of cancel records. 2309 */ 2310 STATIC int 2311 xlog_recover_buffer_pass2( 2312 struct xlog *log, 2313 struct list_head *buffer_list, 2314 struct xlog_recover_item *item, 2315 xfs_lsn_t current_lsn) 2316 { 2317 xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr; 2318 xfs_mount_t *mp = log->l_mp; 2319 xfs_buf_t *bp; 2320 int error; 2321 uint buf_flags; 2322 xfs_lsn_t lsn; 2323 2324 /* 2325 * In this pass we only want to recover all the buffers which have 2326 * not been cancelled and are not cancellation buffers themselves. 2327 */ 2328 if (xlog_check_buffer_cancelled(log, buf_f->blf_blkno, 2329 buf_f->blf_len, buf_f->blf_flags)) { 2330 trace_xfs_log_recover_buf_cancel(log, buf_f); 2331 return 0; 2332 } 2333 2334 trace_xfs_log_recover_buf_recover(log, buf_f); 2335 2336 buf_flags = 0; 2337 if (buf_f->blf_flags & XFS_BLF_INODE_BUF) 2338 buf_flags |= XBF_UNMAPPED; 2339 2340 bp = xfs_buf_read(mp->m_ddev_targp, buf_f->blf_blkno, buf_f->blf_len, 2341 buf_flags, NULL); 2342 if (!bp) 2343 return -ENOMEM; 2344 error = bp->b_error; 2345 if (error) { 2346 xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#1)"); 2347 goto out_release; 2348 } 2349 2350 /* 2351 * Recover the buffer only if we get an LSN from it and it's less than 2352 * the lsn of the transaction we are replaying. 2353 * 2354 * Note that we have to be extremely careful of readahead here. 2355 * Readahead does not attach verfiers to the buffers so if we don't 2356 * actually do any replay after readahead because of the LSN we found 2357 * in the buffer if more recent than that current transaction then we 2358 * need to attach the verifier directly. Failure to do so can lead to 2359 * future recovery actions (e.g. EFI and unlinked list recovery) can 2360 * operate on the buffers and they won't get the verifier attached. This 2361 * can lead to blocks on disk having the correct content but a stale 2362 * CRC. 2363 * 2364 * It is safe to assume these clean buffers are currently up to date. 2365 * If the buffer is dirtied by a later transaction being replayed, then 2366 * the verifier will be reset to match whatever recover turns that 2367 * buffer into. 2368 */ 2369 lsn = xlog_recover_get_buf_lsn(mp, bp); 2370 if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0) { 2371 xlog_recover_validate_buf_type(mp, bp, buf_f); 2372 goto out_release; 2373 } 2374 2375 if (buf_f->blf_flags & XFS_BLF_INODE_BUF) { 2376 error = xlog_recover_do_inode_buffer(mp, item, bp, buf_f); 2377 if (error) 2378 goto out_release; 2379 } else if (buf_f->blf_flags & 2380 (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) { 2381 bool dirty; 2382 2383 dirty = xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f); 2384 if (!dirty) 2385 goto out_release; 2386 } else { 2387 xlog_recover_do_reg_buffer(mp, item, bp, buf_f); 2388 } 2389 2390 /* 2391 * Perform delayed write on the buffer. Asynchronous writes will be 2392 * slower when taking into account all the buffers to be flushed. 2393 * 2394 * Also make sure that only inode buffers with good sizes stay in 2395 * the buffer cache. The kernel moves inodes in buffers of 1 block 2396 * or mp->m_inode_cluster_size bytes, whichever is bigger. The inode 2397 * buffers in the log can be a different size if the log was generated 2398 * by an older kernel using unclustered inode buffers or a newer kernel 2399 * running with a different inode cluster size. Regardless, if the 2400 * the inode buffer size isn't MAX(blocksize, mp->m_inode_cluster_size) 2401 * for *our* value of mp->m_inode_cluster_size, then we need to keep 2402 * the buffer out of the buffer cache so that the buffer won't 2403 * overlap with future reads of those inodes. 2404 */ 2405 if (XFS_DINODE_MAGIC == 2406 be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) && 2407 (BBTOB(bp->b_io_length) != MAX(log->l_mp->m_sb.sb_blocksize, 2408 (__uint32_t)log->l_mp->m_inode_cluster_size))) { 2409 xfs_buf_stale(bp); 2410 error = xfs_bwrite(bp); 2411 } else { 2412 ASSERT(bp->b_target->bt_mount == mp); 2413 bp->b_iodone = xlog_recover_iodone; 2414 xfs_buf_delwri_queue(bp, buffer_list); 2415 } 2416 2417 out_release: 2418 xfs_buf_relse(bp); 2419 return error; 2420 } 2421 2422 /* 2423 * Inode fork owner changes 2424 * 2425 * If we have been told that we have to reparent the inode fork, it's because an 2426 * extent swap operation on a CRC enabled filesystem has been done and we are 2427 * replaying it. We need to walk the BMBT of the appropriate fork and change the 2428 * owners of it. 2429 * 2430 * The complexity here is that we don't have an inode context to work with, so 2431 * after we've replayed the inode we need to instantiate one. This is where the 2432 * fun begins. 2433 * 2434 * We are in the middle of log recovery, so we can't run transactions. That 2435 * means we cannot use cache coherent inode instantiation via xfs_iget(), as 2436 * that will result in the corresponding iput() running the inode through 2437 * xfs_inactive(). If we've just replayed an inode core that changes the link 2438 * count to zero (i.e. it's been unlinked), then xfs_inactive() will run 2439 * transactions (bad!). 2440 * 2441 * So, to avoid this, we instantiate an inode directly from the inode core we've 2442 * just recovered. We have the buffer still locked, and all we really need to 2443 * instantiate is the inode core and the forks being modified. We can do this 2444 * manually, then run the inode btree owner change, and then tear down the 2445 * xfs_inode without having to run any transactions at all. 2446 * 2447 * Also, because we don't have a transaction context available here but need to 2448 * gather all the buffers we modify for writeback so we pass the buffer_list 2449 * instead for the operation to use. 2450 */ 2451 2452 STATIC int 2453 xfs_recover_inode_owner_change( 2454 struct xfs_mount *mp, 2455 struct xfs_dinode *dip, 2456 struct xfs_inode_log_format *in_f, 2457 struct list_head *buffer_list) 2458 { 2459 struct xfs_inode *ip; 2460 int error; 2461 2462 ASSERT(in_f->ilf_fields & (XFS_ILOG_DOWNER|XFS_ILOG_AOWNER)); 2463 2464 ip = xfs_inode_alloc(mp, in_f->ilf_ino); 2465 if (!ip) 2466 return -ENOMEM; 2467 2468 /* instantiate the inode */ 2469 xfs_dinode_from_disk(&ip->i_d, dip); 2470 ASSERT(ip->i_d.di_version >= 3); 2471 2472 error = xfs_iformat_fork(ip, dip); 2473 if (error) 2474 goto out_free_ip; 2475 2476 2477 if (in_f->ilf_fields & XFS_ILOG_DOWNER) { 2478 ASSERT(in_f->ilf_fields & XFS_ILOG_DBROOT); 2479 error = xfs_bmbt_change_owner(NULL, ip, XFS_DATA_FORK, 2480 ip->i_ino, buffer_list); 2481 if (error) 2482 goto out_free_ip; 2483 } 2484 2485 if (in_f->ilf_fields & XFS_ILOG_AOWNER) { 2486 ASSERT(in_f->ilf_fields & XFS_ILOG_ABROOT); 2487 error = xfs_bmbt_change_owner(NULL, ip, XFS_ATTR_FORK, 2488 ip->i_ino, buffer_list); 2489 if (error) 2490 goto out_free_ip; 2491 } 2492 2493 out_free_ip: 2494 xfs_inode_free(ip); 2495 return error; 2496 } 2497 2498 STATIC int 2499 xlog_recover_inode_pass2( 2500 struct xlog *log, 2501 struct list_head *buffer_list, 2502 struct xlog_recover_item *item, 2503 xfs_lsn_t current_lsn) 2504 { 2505 xfs_inode_log_format_t *in_f; 2506 xfs_mount_t *mp = log->l_mp; 2507 xfs_buf_t *bp; 2508 xfs_dinode_t *dip; 2509 int len; 2510 char *src; 2511 char *dest; 2512 int error; 2513 int attr_index; 2514 uint fields; 2515 xfs_icdinode_t *dicp; 2516 uint isize; 2517 int need_free = 0; 2518 2519 if (item->ri_buf[0].i_len == sizeof(xfs_inode_log_format_t)) { 2520 in_f = item->ri_buf[0].i_addr; 2521 } else { 2522 in_f = kmem_alloc(sizeof(xfs_inode_log_format_t), KM_SLEEP); 2523 need_free = 1; 2524 error = xfs_inode_item_format_convert(&item->ri_buf[0], in_f); 2525 if (error) 2526 goto error; 2527 } 2528 2529 /* 2530 * Inode buffers can be freed, look out for it, 2531 * and do not replay the inode. 2532 */ 2533 if (xlog_check_buffer_cancelled(log, in_f->ilf_blkno, 2534 in_f->ilf_len, 0)) { 2535 error = 0; 2536 trace_xfs_log_recover_inode_cancel(log, in_f); 2537 goto error; 2538 } 2539 trace_xfs_log_recover_inode_recover(log, in_f); 2540 2541 bp = xfs_buf_read(mp->m_ddev_targp, in_f->ilf_blkno, in_f->ilf_len, 0, 2542 &xfs_inode_buf_ops); 2543 if (!bp) { 2544 error = -ENOMEM; 2545 goto error; 2546 } 2547 error = bp->b_error; 2548 if (error) { 2549 xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#2)"); 2550 goto out_release; 2551 } 2552 ASSERT(in_f->ilf_fields & XFS_ILOG_CORE); 2553 dip = xfs_buf_offset(bp, in_f->ilf_boffset); 2554 2555 /* 2556 * Make sure the place we're flushing out to really looks 2557 * like an inode! 2558 */ 2559 if (unlikely(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC))) { 2560 xfs_alert(mp, 2561 "%s: Bad inode magic number, dip = 0x%p, dino bp = 0x%p, ino = %Ld", 2562 __func__, dip, bp, in_f->ilf_ino); 2563 XFS_ERROR_REPORT("xlog_recover_inode_pass2(1)", 2564 XFS_ERRLEVEL_LOW, mp); 2565 error = -EFSCORRUPTED; 2566 goto out_release; 2567 } 2568 dicp = item->ri_buf[1].i_addr; 2569 if (unlikely(dicp->di_magic != XFS_DINODE_MAGIC)) { 2570 xfs_alert(mp, 2571 "%s: Bad inode log record, rec ptr 0x%p, ino %Ld", 2572 __func__, item, in_f->ilf_ino); 2573 XFS_ERROR_REPORT("xlog_recover_inode_pass2(2)", 2574 XFS_ERRLEVEL_LOW, mp); 2575 error = -EFSCORRUPTED; 2576 goto out_release; 2577 } 2578 2579 /* 2580 * If the inode has an LSN in it, recover the inode only if it's less 2581 * than the lsn of the transaction we are replaying. Note: we still 2582 * need to replay an owner change even though the inode is more recent 2583 * than the transaction as there is no guarantee that all the btree 2584 * blocks are more recent than this transaction, too. 2585 */ 2586 if (dip->di_version >= 3) { 2587 xfs_lsn_t lsn = be64_to_cpu(dip->di_lsn); 2588 2589 if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0) { 2590 trace_xfs_log_recover_inode_skip(log, in_f); 2591 error = 0; 2592 goto out_owner_change; 2593 } 2594 } 2595 2596 /* 2597 * di_flushiter is only valid for v1/2 inodes. All changes for v3 inodes 2598 * are transactional and if ordering is necessary we can determine that 2599 * more accurately by the LSN field in the V3 inode core. Don't trust 2600 * the inode versions we might be changing them here - use the 2601 * superblock flag to determine whether we need to look at di_flushiter 2602 * to skip replay when the on disk inode is newer than the log one 2603 */ 2604 if (!xfs_sb_version_hascrc(&mp->m_sb) && 2605 dicp->di_flushiter < be16_to_cpu(dip->di_flushiter)) { 2606 /* 2607 * Deal with the wrap case, DI_MAX_FLUSH is less 2608 * than smaller numbers 2609 */ 2610 if (be16_to_cpu(dip->di_flushiter) == DI_MAX_FLUSH && 2611 dicp->di_flushiter < (DI_MAX_FLUSH >> 1)) { 2612 /* do nothing */ 2613 } else { 2614 trace_xfs_log_recover_inode_skip(log, in_f); 2615 error = 0; 2616 goto out_release; 2617 } 2618 } 2619 2620 /* Take the opportunity to reset the flush iteration count */ 2621 dicp->di_flushiter = 0; 2622 2623 if (unlikely(S_ISREG(dicp->di_mode))) { 2624 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) && 2625 (dicp->di_format != XFS_DINODE_FMT_BTREE)) { 2626 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(3)", 2627 XFS_ERRLEVEL_LOW, mp, dicp); 2628 xfs_alert(mp, 2629 "%s: Bad regular inode log record, rec ptr 0x%p, " 2630 "ino ptr = 0x%p, ino bp = 0x%p, ino %Ld", 2631 __func__, item, dip, bp, in_f->ilf_ino); 2632 error = -EFSCORRUPTED; 2633 goto out_release; 2634 } 2635 } else if (unlikely(S_ISDIR(dicp->di_mode))) { 2636 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) && 2637 (dicp->di_format != XFS_DINODE_FMT_BTREE) && 2638 (dicp->di_format != XFS_DINODE_FMT_LOCAL)) { 2639 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(4)", 2640 XFS_ERRLEVEL_LOW, mp, dicp); 2641 xfs_alert(mp, 2642 "%s: Bad dir inode log record, rec ptr 0x%p, " 2643 "ino ptr = 0x%p, ino bp = 0x%p, ino %Ld", 2644 __func__, item, dip, bp, in_f->ilf_ino); 2645 error = -EFSCORRUPTED; 2646 goto out_release; 2647 } 2648 } 2649 if (unlikely(dicp->di_nextents + dicp->di_anextents > dicp->di_nblocks)){ 2650 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(5)", 2651 XFS_ERRLEVEL_LOW, mp, dicp); 2652 xfs_alert(mp, 2653 "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, " 2654 "dino bp 0x%p, ino %Ld, total extents = %d, nblocks = %Ld", 2655 __func__, item, dip, bp, in_f->ilf_ino, 2656 dicp->di_nextents + dicp->di_anextents, 2657 dicp->di_nblocks); 2658 error = -EFSCORRUPTED; 2659 goto out_release; 2660 } 2661 if (unlikely(dicp->di_forkoff > mp->m_sb.sb_inodesize)) { 2662 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(6)", 2663 XFS_ERRLEVEL_LOW, mp, dicp); 2664 xfs_alert(mp, 2665 "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, " 2666 "dino bp 0x%p, ino %Ld, forkoff 0x%x", __func__, 2667 item, dip, bp, in_f->ilf_ino, dicp->di_forkoff); 2668 error = -EFSCORRUPTED; 2669 goto out_release; 2670 } 2671 isize = xfs_icdinode_size(dicp->di_version); 2672 if (unlikely(item->ri_buf[1].i_len > isize)) { 2673 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(7)", 2674 XFS_ERRLEVEL_LOW, mp, dicp); 2675 xfs_alert(mp, 2676 "%s: Bad inode log record length %d, rec ptr 0x%p", 2677 __func__, item->ri_buf[1].i_len, item); 2678 error = -EFSCORRUPTED; 2679 goto out_release; 2680 } 2681 2682 /* The core is in in-core format */ 2683 xfs_dinode_to_disk(dip, dicp); 2684 2685 /* the rest is in on-disk format */ 2686 if (item->ri_buf[1].i_len > isize) { 2687 memcpy((char *)dip + isize, 2688 item->ri_buf[1].i_addr + isize, 2689 item->ri_buf[1].i_len - isize); 2690 } 2691 2692 fields = in_f->ilf_fields; 2693 switch (fields & (XFS_ILOG_DEV | XFS_ILOG_UUID)) { 2694 case XFS_ILOG_DEV: 2695 xfs_dinode_put_rdev(dip, in_f->ilf_u.ilfu_rdev); 2696 break; 2697 case XFS_ILOG_UUID: 2698 memcpy(XFS_DFORK_DPTR(dip), 2699 &in_f->ilf_u.ilfu_uuid, 2700 sizeof(uuid_t)); 2701 break; 2702 } 2703 2704 if (in_f->ilf_size == 2) 2705 goto out_owner_change; 2706 len = item->ri_buf[2].i_len; 2707 src = item->ri_buf[2].i_addr; 2708 ASSERT(in_f->ilf_size <= 4); 2709 ASSERT((in_f->ilf_size == 3) || (fields & XFS_ILOG_AFORK)); 2710 ASSERT(!(fields & XFS_ILOG_DFORK) || 2711 (len == in_f->ilf_dsize)); 2712 2713 switch (fields & XFS_ILOG_DFORK) { 2714 case XFS_ILOG_DDATA: 2715 case XFS_ILOG_DEXT: 2716 memcpy(XFS_DFORK_DPTR(dip), src, len); 2717 break; 2718 2719 case XFS_ILOG_DBROOT: 2720 xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src, len, 2721 (xfs_bmdr_block_t *)XFS_DFORK_DPTR(dip), 2722 XFS_DFORK_DSIZE(dip, mp)); 2723 break; 2724 2725 default: 2726 /* 2727 * There are no data fork flags set. 2728 */ 2729 ASSERT((fields & XFS_ILOG_DFORK) == 0); 2730 break; 2731 } 2732 2733 /* 2734 * If we logged any attribute data, recover it. There may or 2735 * may not have been any other non-core data logged in this 2736 * transaction. 2737 */ 2738 if (in_f->ilf_fields & XFS_ILOG_AFORK) { 2739 if (in_f->ilf_fields & XFS_ILOG_DFORK) { 2740 attr_index = 3; 2741 } else { 2742 attr_index = 2; 2743 } 2744 len = item->ri_buf[attr_index].i_len; 2745 src = item->ri_buf[attr_index].i_addr; 2746 ASSERT(len == in_f->ilf_asize); 2747 2748 switch (in_f->ilf_fields & XFS_ILOG_AFORK) { 2749 case XFS_ILOG_ADATA: 2750 case XFS_ILOG_AEXT: 2751 dest = XFS_DFORK_APTR(dip); 2752 ASSERT(len <= XFS_DFORK_ASIZE(dip, mp)); 2753 memcpy(dest, src, len); 2754 break; 2755 2756 case XFS_ILOG_ABROOT: 2757 dest = XFS_DFORK_APTR(dip); 2758 xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src, 2759 len, (xfs_bmdr_block_t*)dest, 2760 XFS_DFORK_ASIZE(dip, mp)); 2761 break; 2762 2763 default: 2764 xfs_warn(log->l_mp, "%s: Invalid flag", __func__); 2765 ASSERT(0); 2766 error = -EIO; 2767 goto out_release; 2768 } 2769 } 2770 2771 out_owner_change: 2772 if (in_f->ilf_fields & (XFS_ILOG_DOWNER|XFS_ILOG_AOWNER)) 2773 error = xfs_recover_inode_owner_change(mp, dip, in_f, 2774 buffer_list); 2775 /* re-generate the checksum. */ 2776 xfs_dinode_calc_crc(log->l_mp, dip); 2777 2778 ASSERT(bp->b_target->bt_mount == mp); 2779 bp->b_iodone = xlog_recover_iodone; 2780 xfs_buf_delwri_queue(bp, buffer_list); 2781 2782 out_release: 2783 xfs_buf_relse(bp); 2784 error: 2785 if (need_free) 2786 kmem_free(in_f); 2787 return error; 2788 } 2789 2790 /* 2791 * Recover QUOTAOFF records. We simply make a note of it in the xlog 2792 * structure, so that we know not to do any dquot item or dquot buffer recovery, 2793 * of that type. 2794 */ 2795 STATIC int 2796 xlog_recover_quotaoff_pass1( 2797 struct xlog *log, 2798 struct xlog_recover_item *item) 2799 { 2800 xfs_qoff_logformat_t *qoff_f = item->ri_buf[0].i_addr; 2801 ASSERT(qoff_f); 2802 2803 /* 2804 * The logitem format's flag tells us if this was user quotaoff, 2805 * group/project quotaoff or both. 2806 */ 2807 if (qoff_f->qf_flags & XFS_UQUOTA_ACCT) 2808 log->l_quotaoffs_flag |= XFS_DQ_USER; 2809 if (qoff_f->qf_flags & XFS_PQUOTA_ACCT) 2810 log->l_quotaoffs_flag |= XFS_DQ_PROJ; 2811 if (qoff_f->qf_flags & XFS_GQUOTA_ACCT) 2812 log->l_quotaoffs_flag |= XFS_DQ_GROUP; 2813 2814 return 0; 2815 } 2816 2817 /* 2818 * Recover a dquot record 2819 */ 2820 STATIC int 2821 xlog_recover_dquot_pass2( 2822 struct xlog *log, 2823 struct list_head *buffer_list, 2824 struct xlog_recover_item *item, 2825 xfs_lsn_t current_lsn) 2826 { 2827 xfs_mount_t *mp = log->l_mp; 2828 xfs_buf_t *bp; 2829 struct xfs_disk_dquot *ddq, *recddq; 2830 int error; 2831 xfs_dq_logformat_t *dq_f; 2832 uint type; 2833 2834 2835 /* 2836 * Filesystems are required to send in quota flags at mount time. 2837 */ 2838 if (mp->m_qflags == 0) 2839 return 0; 2840 2841 recddq = item->ri_buf[1].i_addr; 2842 if (recddq == NULL) { 2843 xfs_alert(log->l_mp, "NULL dquot in %s.", __func__); 2844 return -EIO; 2845 } 2846 if (item->ri_buf[1].i_len < sizeof(xfs_disk_dquot_t)) { 2847 xfs_alert(log->l_mp, "dquot too small (%d) in %s.", 2848 item->ri_buf[1].i_len, __func__); 2849 return -EIO; 2850 } 2851 2852 /* 2853 * This type of quotas was turned off, so ignore this record. 2854 */ 2855 type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP); 2856 ASSERT(type); 2857 if (log->l_quotaoffs_flag & type) 2858 return 0; 2859 2860 /* 2861 * At this point we know that quota was _not_ turned off. 2862 * Since the mount flags are not indicating to us otherwise, this 2863 * must mean that quota is on, and the dquot needs to be replayed. 2864 * Remember that we may not have fully recovered the superblock yet, 2865 * so we can't do the usual trick of looking at the SB quota bits. 2866 * 2867 * The other possibility, of course, is that the quota subsystem was 2868 * removed since the last mount - ENOSYS. 2869 */ 2870 dq_f = item->ri_buf[0].i_addr; 2871 ASSERT(dq_f); 2872 error = xfs_dqcheck(mp, recddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN, 2873 "xlog_recover_dquot_pass2 (log copy)"); 2874 if (error) 2875 return -EIO; 2876 ASSERT(dq_f->qlf_len == 1); 2877 2878 /* 2879 * At this point we are assuming that the dquots have been allocated 2880 * and hence the buffer has valid dquots stamped in it. It should, 2881 * therefore, pass verifier validation. If the dquot is bad, then the 2882 * we'll return an error here, so we don't need to specifically check 2883 * the dquot in the buffer after the verifier has run. 2884 */ 2885 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dq_f->qlf_blkno, 2886 XFS_FSB_TO_BB(mp, dq_f->qlf_len), 0, &bp, 2887 &xfs_dquot_buf_ops); 2888 if (error) 2889 return error; 2890 2891 ASSERT(bp); 2892 ddq = xfs_buf_offset(bp, dq_f->qlf_boffset); 2893 2894 /* 2895 * If the dquot has an LSN in it, recover the dquot only if it's less 2896 * than the lsn of the transaction we are replaying. 2897 */ 2898 if (xfs_sb_version_hascrc(&mp->m_sb)) { 2899 struct xfs_dqblk *dqb = (struct xfs_dqblk *)ddq; 2900 xfs_lsn_t lsn = be64_to_cpu(dqb->dd_lsn); 2901 2902 if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0) { 2903 goto out_release; 2904 } 2905 } 2906 2907 memcpy(ddq, recddq, item->ri_buf[1].i_len); 2908 if (xfs_sb_version_hascrc(&mp->m_sb)) { 2909 xfs_update_cksum((char *)ddq, sizeof(struct xfs_dqblk), 2910 XFS_DQUOT_CRC_OFF); 2911 } 2912 2913 ASSERT(dq_f->qlf_size == 2); 2914 ASSERT(bp->b_target->bt_mount == mp); 2915 bp->b_iodone = xlog_recover_iodone; 2916 xfs_buf_delwri_queue(bp, buffer_list); 2917 2918 out_release: 2919 xfs_buf_relse(bp); 2920 return 0; 2921 } 2922 2923 /* 2924 * This routine is called to create an in-core extent free intent 2925 * item from the efi format structure which was logged on disk. 2926 * It allocates an in-core efi, copies the extents from the format 2927 * structure into it, and adds the efi to the AIL with the given 2928 * LSN. 2929 */ 2930 STATIC int 2931 xlog_recover_efi_pass2( 2932 struct xlog *log, 2933 struct xlog_recover_item *item, 2934 xfs_lsn_t lsn) 2935 { 2936 int error; 2937 xfs_mount_t *mp = log->l_mp; 2938 xfs_efi_log_item_t *efip; 2939 xfs_efi_log_format_t *efi_formatp; 2940 2941 efi_formatp = item->ri_buf[0].i_addr; 2942 2943 efip = xfs_efi_init(mp, efi_formatp->efi_nextents); 2944 if ((error = xfs_efi_copy_format(&(item->ri_buf[0]), 2945 &(efip->efi_format)))) { 2946 xfs_efi_item_free(efip); 2947 return error; 2948 } 2949 atomic_set(&efip->efi_next_extent, efi_formatp->efi_nextents); 2950 2951 spin_lock(&log->l_ailp->xa_lock); 2952 /* 2953 * xfs_trans_ail_update() drops the AIL lock. 2954 */ 2955 xfs_trans_ail_update(log->l_ailp, &efip->efi_item, lsn); 2956 return 0; 2957 } 2958 2959 2960 /* 2961 * This routine is called when an efd format structure is found in 2962 * a committed transaction in the log. It's purpose is to cancel 2963 * the corresponding efi if it was still in the log. To do this 2964 * it searches the AIL for the efi with an id equal to that in the 2965 * efd format structure. If we find it, we remove the efi from the 2966 * AIL and free it. 2967 */ 2968 STATIC int 2969 xlog_recover_efd_pass2( 2970 struct xlog *log, 2971 struct xlog_recover_item *item) 2972 { 2973 xfs_efd_log_format_t *efd_formatp; 2974 xfs_efi_log_item_t *efip = NULL; 2975 xfs_log_item_t *lip; 2976 __uint64_t efi_id; 2977 struct xfs_ail_cursor cur; 2978 struct xfs_ail *ailp = log->l_ailp; 2979 2980 efd_formatp = item->ri_buf[0].i_addr; 2981 ASSERT((item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_32_t) + 2982 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_32_t)))) || 2983 (item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_64_t) + 2984 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_64_t))))); 2985 efi_id = efd_formatp->efd_efi_id; 2986 2987 /* 2988 * Search for the efi with the id in the efd format structure 2989 * in the AIL. 2990 */ 2991 spin_lock(&ailp->xa_lock); 2992 lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); 2993 while (lip != NULL) { 2994 if (lip->li_type == XFS_LI_EFI) { 2995 efip = (xfs_efi_log_item_t *)lip; 2996 if (efip->efi_format.efi_id == efi_id) { 2997 /* 2998 * xfs_trans_ail_delete() drops the 2999 * AIL lock. 3000 */ 3001 xfs_trans_ail_delete(ailp, lip, 3002 SHUTDOWN_CORRUPT_INCORE); 3003 xfs_efi_item_free(efip); 3004 spin_lock(&ailp->xa_lock); 3005 break; 3006 } 3007 } 3008 lip = xfs_trans_ail_cursor_next(ailp, &cur); 3009 } 3010 xfs_trans_ail_cursor_done(&cur); 3011 spin_unlock(&ailp->xa_lock); 3012 3013 return 0; 3014 } 3015 3016 /* 3017 * This routine is called when an inode create format structure is found in a 3018 * committed transaction in the log. It's purpose is to initialise the inodes 3019 * being allocated on disk. This requires us to get inode cluster buffers that 3020 * match the range to be intialised, stamped with inode templates and written 3021 * by delayed write so that subsequent modifications will hit the cached buffer 3022 * and only need writing out at the end of recovery. 3023 */ 3024 STATIC int 3025 xlog_recover_do_icreate_pass2( 3026 struct xlog *log, 3027 struct list_head *buffer_list, 3028 xlog_recover_item_t *item) 3029 { 3030 struct xfs_mount *mp = log->l_mp; 3031 struct xfs_icreate_log *icl; 3032 xfs_agnumber_t agno; 3033 xfs_agblock_t agbno; 3034 unsigned int count; 3035 unsigned int isize; 3036 xfs_agblock_t length; 3037 3038 icl = (struct xfs_icreate_log *)item->ri_buf[0].i_addr; 3039 if (icl->icl_type != XFS_LI_ICREATE) { 3040 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad type"); 3041 return -EINVAL; 3042 } 3043 3044 if (icl->icl_size != 1) { 3045 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad icl size"); 3046 return -EINVAL; 3047 } 3048 3049 agno = be32_to_cpu(icl->icl_ag); 3050 if (agno >= mp->m_sb.sb_agcount) { 3051 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agno"); 3052 return -EINVAL; 3053 } 3054 agbno = be32_to_cpu(icl->icl_agbno); 3055 if (!agbno || agbno == NULLAGBLOCK || agbno >= mp->m_sb.sb_agblocks) { 3056 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agbno"); 3057 return -EINVAL; 3058 } 3059 isize = be32_to_cpu(icl->icl_isize); 3060 if (isize != mp->m_sb.sb_inodesize) { 3061 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad isize"); 3062 return -EINVAL; 3063 } 3064 count = be32_to_cpu(icl->icl_count); 3065 if (!count) { 3066 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad count"); 3067 return -EINVAL; 3068 } 3069 length = be32_to_cpu(icl->icl_length); 3070 if (!length || length >= mp->m_sb.sb_agblocks) { 3071 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad length"); 3072 return -EINVAL; 3073 } 3074 3075 /* 3076 * The inode chunk is either full or sparse and we only support 3077 * m_ialloc_min_blks sized sparse allocations at this time. 3078 */ 3079 if (length != mp->m_ialloc_blks && 3080 length != mp->m_ialloc_min_blks) { 3081 xfs_warn(log->l_mp, 3082 "%s: unsupported chunk length", __FUNCTION__); 3083 return -EINVAL; 3084 } 3085 3086 /* verify inode count is consistent with extent length */ 3087 if ((count >> mp->m_sb.sb_inopblog) != length) { 3088 xfs_warn(log->l_mp, 3089 "%s: inconsistent inode count and chunk length", 3090 __FUNCTION__); 3091 return -EINVAL; 3092 } 3093 3094 /* 3095 * Inode buffers can be freed. Do not replay the inode initialisation as 3096 * we could be overwriting something written after this inode buffer was 3097 * cancelled. 3098 * 3099 * XXX: we need to iterate all buffers and only init those that are not 3100 * cancelled. I think that a more fine grained factoring of 3101 * xfs_ialloc_inode_init may be appropriate here to enable this to be 3102 * done easily. 3103 */ 3104 if (xlog_check_buffer_cancelled(log, 3105 XFS_AGB_TO_DADDR(mp, agno, agbno), length, 0)) 3106 return 0; 3107 3108 xfs_ialloc_inode_init(mp, NULL, buffer_list, count, agno, agbno, length, 3109 be32_to_cpu(icl->icl_gen)); 3110 return 0; 3111 } 3112 3113 STATIC void 3114 xlog_recover_buffer_ra_pass2( 3115 struct xlog *log, 3116 struct xlog_recover_item *item) 3117 { 3118 struct xfs_buf_log_format *buf_f = item->ri_buf[0].i_addr; 3119 struct xfs_mount *mp = log->l_mp; 3120 3121 if (xlog_peek_buffer_cancelled(log, buf_f->blf_blkno, 3122 buf_f->blf_len, buf_f->blf_flags)) { 3123 return; 3124 } 3125 3126 xfs_buf_readahead(mp->m_ddev_targp, buf_f->blf_blkno, 3127 buf_f->blf_len, NULL); 3128 } 3129 3130 STATIC void 3131 xlog_recover_inode_ra_pass2( 3132 struct xlog *log, 3133 struct xlog_recover_item *item) 3134 { 3135 struct xfs_inode_log_format ilf_buf; 3136 struct xfs_inode_log_format *ilfp; 3137 struct xfs_mount *mp = log->l_mp; 3138 int error; 3139 3140 if (item->ri_buf[0].i_len == sizeof(struct xfs_inode_log_format)) { 3141 ilfp = item->ri_buf[0].i_addr; 3142 } else { 3143 ilfp = &ilf_buf; 3144 memset(ilfp, 0, sizeof(*ilfp)); 3145 error = xfs_inode_item_format_convert(&item->ri_buf[0], ilfp); 3146 if (error) 3147 return; 3148 } 3149 3150 if (xlog_peek_buffer_cancelled(log, ilfp->ilf_blkno, ilfp->ilf_len, 0)) 3151 return; 3152 3153 xfs_buf_readahead(mp->m_ddev_targp, ilfp->ilf_blkno, 3154 ilfp->ilf_len, &xfs_inode_buf_ra_ops); 3155 } 3156 3157 STATIC void 3158 xlog_recover_dquot_ra_pass2( 3159 struct xlog *log, 3160 struct xlog_recover_item *item) 3161 { 3162 struct xfs_mount *mp = log->l_mp; 3163 struct xfs_disk_dquot *recddq; 3164 struct xfs_dq_logformat *dq_f; 3165 uint type; 3166 3167 3168 if (mp->m_qflags == 0) 3169 return; 3170 3171 recddq = item->ri_buf[1].i_addr; 3172 if (recddq == NULL) 3173 return; 3174 if (item->ri_buf[1].i_len < sizeof(struct xfs_disk_dquot)) 3175 return; 3176 3177 type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP); 3178 ASSERT(type); 3179 if (log->l_quotaoffs_flag & type) 3180 return; 3181 3182 dq_f = item->ri_buf[0].i_addr; 3183 ASSERT(dq_f); 3184 ASSERT(dq_f->qlf_len == 1); 3185 3186 xfs_buf_readahead(mp->m_ddev_targp, dq_f->qlf_blkno, 3187 XFS_FSB_TO_BB(mp, dq_f->qlf_len), NULL); 3188 } 3189 3190 STATIC void 3191 xlog_recover_ra_pass2( 3192 struct xlog *log, 3193 struct xlog_recover_item *item) 3194 { 3195 switch (ITEM_TYPE(item)) { 3196 case XFS_LI_BUF: 3197 xlog_recover_buffer_ra_pass2(log, item); 3198 break; 3199 case XFS_LI_INODE: 3200 xlog_recover_inode_ra_pass2(log, item); 3201 break; 3202 case XFS_LI_DQUOT: 3203 xlog_recover_dquot_ra_pass2(log, item); 3204 break; 3205 case XFS_LI_EFI: 3206 case XFS_LI_EFD: 3207 case XFS_LI_QUOTAOFF: 3208 default: 3209 break; 3210 } 3211 } 3212 3213 STATIC int 3214 xlog_recover_commit_pass1( 3215 struct xlog *log, 3216 struct xlog_recover *trans, 3217 struct xlog_recover_item *item) 3218 { 3219 trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS1); 3220 3221 switch (ITEM_TYPE(item)) { 3222 case XFS_LI_BUF: 3223 return xlog_recover_buffer_pass1(log, item); 3224 case XFS_LI_QUOTAOFF: 3225 return xlog_recover_quotaoff_pass1(log, item); 3226 case XFS_LI_INODE: 3227 case XFS_LI_EFI: 3228 case XFS_LI_EFD: 3229 case XFS_LI_DQUOT: 3230 case XFS_LI_ICREATE: 3231 /* nothing to do in pass 1 */ 3232 return 0; 3233 default: 3234 xfs_warn(log->l_mp, "%s: invalid item type (%d)", 3235 __func__, ITEM_TYPE(item)); 3236 ASSERT(0); 3237 return -EIO; 3238 } 3239 } 3240 3241 STATIC int 3242 xlog_recover_commit_pass2( 3243 struct xlog *log, 3244 struct xlog_recover *trans, 3245 struct list_head *buffer_list, 3246 struct xlog_recover_item *item) 3247 { 3248 trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS2); 3249 3250 switch (ITEM_TYPE(item)) { 3251 case XFS_LI_BUF: 3252 return xlog_recover_buffer_pass2(log, buffer_list, item, 3253 trans->r_lsn); 3254 case XFS_LI_INODE: 3255 return xlog_recover_inode_pass2(log, buffer_list, item, 3256 trans->r_lsn); 3257 case XFS_LI_EFI: 3258 return xlog_recover_efi_pass2(log, item, trans->r_lsn); 3259 case XFS_LI_EFD: 3260 return xlog_recover_efd_pass2(log, item); 3261 case XFS_LI_DQUOT: 3262 return xlog_recover_dquot_pass2(log, buffer_list, item, 3263 trans->r_lsn); 3264 case XFS_LI_ICREATE: 3265 return xlog_recover_do_icreate_pass2(log, buffer_list, item); 3266 case XFS_LI_QUOTAOFF: 3267 /* nothing to do in pass2 */ 3268 return 0; 3269 default: 3270 xfs_warn(log->l_mp, "%s: invalid item type (%d)", 3271 __func__, ITEM_TYPE(item)); 3272 ASSERT(0); 3273 return -EIO; 3274 } 3275 } 3276 3277 STATIC int 3278 xlog_recover_items_pass2( 3279 struct xlog *log, 3280 struct xlog_recover *trans, 3281 struct list_head *buffer_list, 3282 struct list_head *item_list) 3283 { 3284 struct xlog_recover_item *item; 3285 int error = 0; 3286 3287 list_for_each_entry(item, item_list, ri_list) { 3288 error = xlog_recover_commit_pass2(log, trans, 3289 buffer_list, item); 3290 if (error) 3291 return error; 3292 } 3293 3294 return error; 3295 } 3296 3297 /* 3298 * Perform the transaction. 3299 * 3300 * If the transaction modifies a buffer or inode, do it now. Otherwise, 3301 * EFIs and EFDs get queued up by adding entries into the AIL for them. 3302 */ 3303 STATIC int 3304 xlog_recover_commit_trans( 3305 struct xlog *log, 3306 struct xlog_recover *trans, 3307 int pass) 3308 { 3309 int error = 0; 3310 int error2; 3311 int items_queued = 0; 3312 struct xlog_recover_item *item; 3313 struct xlog_recover_item *next; 3314 LIST_HEAD (buffer_list); 3315 LIST_HEAD (ra_list); 3316 LIST_HEAD (done_list); 3317 3318 #define XLOG_RECOVER_COMMIT_QUEUE_MAX 100 3319 3320 hlist_del(&trans->r_list); 3321 3322 error = xlog_recover_reorder_trans(log, trans, pass); 3323 if (error) 3324 return error; 3325 3326 list_for_each_entry_safe(item, next, &trans->r_itemq, ri_list) { 3327 switch (pass) { 3328 case XLOG_RECOVER_PASS1: 3329 error = xlog_recover_commit_pass1(log, trans, item); 3330 break; 3331 case XLOG_RECOVER_PASS2: 3332 xlog_recover_ra_pass2(log, item); 3333 list_move_tail(&item->ri_list, &ra_list); 3334 items_queued++; 3335 if (items_queued >= XLOG_RECOVER_COMMIT_QUEUE_MAX) { 3336 error = xlog_recover_items_pass2(log, trans, 3337 &buffer_list, &ra_list); 3338 list_splice_tail_init(&ra_list, &done_list); 3339 items_queued = 0; 3340 } 3341 3342 break; 3343 default: 3344 ASSERT(0); 3345 } 3346 3347 if (error) 3348 goto out; 3349 } 3350 3351 out: 3352 if (!list_empty(&ra_list)) { 3353 if (!error) 3354 error = xlog_recover_items_pass2(log, trans, 3355 &buffer_list, &ra_list); 3356 list_splice_tail_init(&ra_list, &done_list); 3357 } 3358 3359 if (!list_empty(&done_list)) 3360 list_splice_init(&done_list, &trans->r_itemq); 3361 3362 error2 = xfs_buf_delwri_submit(&buffer_list); 3363 return error ? error : error2; 3364 } 3365 3366 STATIC void 3367 xlog_recover_add_item( 3368 struct list_head *head) 3369 { 3370 xlog_recover_item_t *item; 3371 3372 item = kmem_zalloc(sizeof(xlog_recover_item_t), KM_SLEEP); 3373 INIT_LIST_HEAD(&item->ri_list); 3374 list_add_tail(&item->ri_list, head); 3375 } 3376 3377 STATIC int 3378 xlog_recover_add_to_cont_trans( 3379 struct xlog *log, 3380 struct xlog_recover *trans, 3381 char *dp, 3382 int len) 3383 { 3384 xlog_recover_item_t *item; 3385 char *ptr, *old_ptr; 3386 int old_len; 3387 3388 if (list_empty(&trans->r_itemq)) { 3389 /* finish copying rest of trans header */ 3390 xlog_recover_add_item(&trans->r_itemq); 3391 ptr = (char *)&trans->r_theader + 3392 sizeof(xfs_trans_header_t) - len; 3393 memcpy(ptr, dp, len); 3394 return 0; 3395 } 3396 /* take the tail entry */ 3397 item = list_entry(trans->r_itemq.prev, xlog_recover_item_t, ri_list); 3398 3399 old_ptr = item->ri_buf[item->ri_cnt-1].i_addr; 3400 old_len = item->ri_buf[item->ri_cnt-1].i_len; 3401 3402 ptr = kmem_realloc(old_ptr, len+old_len, old_len, KM_SLEEP); 3403 memcpy(&ptr[old_len], dp, len); 3404 item->ri_buf[item->ri_cnt-1].i_len += len; 3405 item->ri_buf[item->ri_cnt-1].i_addr = ptr; 3406 trace_xfs_log_recover_item_add_cont(log, trans, item, 0); 3407 return 0; 3408 } 3409 3410 /* 3411 * The next region to add is the start of a new region. It could be 3412 * a whole region or it could be the first part of a new region. Because 3413 * of this, the assumption here is that the type and size fields of all 3414 * format structures fit into the first 32 bits of the structure. 3415 * 3416 * This works because all regions must be 32 bit aligned. Therefore, we 3417 * either have both fields or we have neither field. In the case we have 3418 * neither field, the data part of the region is zero length. We only have 3419 * a log_op_header and can throw away the header since a new one will appear 3420 * later. If we have at least 4 bytes, then we can determine how many regions 3421 * will appear in the current log item. 3422 */ 3423 STATIC int 3424 xlog_recover_add_to_trans( 3425 struct xlog *log, 3426 struct xlog_recover *trans, 3427 char *dp, 3428 int len) 3429 { 3430 xfs_inode_log_format_t *in_f; /* any will do */ 3431 xlog_recover_item_t *item; 3432 char *ptr; 3433 3434 if (!len) 3435 return 0; 3436 if (list_empty(&trans->r_itemq)) { 3437 /* we need to catch log corruptions here */ 3438 if (*(uint *)dp != XFS_TRANS_HEADER_MAGIC) { 3439 xfs_warn(log->l_mp, "%s: bad header magic number", 3440 __func__); 3441 ASSERT(0); 3442 return -EIO; 3443 } 3444 if (len == sizeof(xfs_trans_header_t)) 3445 xlog_recover_add_item(&trans->r_itemq); 3446 memcpy(&trans->r_theader, dp, len); 3447 return 0; 3448 } 3449 3450 ptr = kmem_alloc(len, KM_SLEEP); 3451 memcpy(ptr, dp, len); 3452 in_f = (xfs_inode_log_format_t *)ptr; 3453 3454 /* take the tail entry */ 3455 item = list_entry(trans->r_itemq.prev, xlog_recover_item_t, ri_list); 3456 if (item->ri_total != 0 && 3457 item->ri_total == item->ri_cnt) { 3458 /* tail item is in use, get a new one */ 3459 xlog_recover_add_item(&trans->r_itemq); 3460 item = list_entry(trans->r_itemq.prev, 3461 xlog_recover_item_t, ri_list); 3462 } 3463 3464 if (item->ri_total == 0) { /* first region to be added */ 3465 if (in_f->ilf_size == 0 || 3466 in_f->ilf_size > XLOG_MAX_REGIONS_IN_ITEM) { 3467 xfs_warn(log->l_mp, 3468 "bad number of regions (%d) in inode log format", 3469 in_f->ilf_size); 3470 ASSERT(0); 3471 kmem_free(ptr); 3472 return -EIO; 3473 } 3474 3475 item->ri_total = in_f->ilf_size; 3476 item->ri_buf = 3477 kmem_zalloc(item->ri_total * sizeof(xfs_log_iovec_t), 3478 KM_SLEEP); 3479 } 3480 ASSERT(item->ri_total > item->ri_cnt); 3481 /* Description region is ri_buf[0] */ 3482 item->ri_buf[item->ri_cnt].i_addr = ptr; 3483 item->ri_buf[item->ri_cnt].i_len = len; 3484 item->ri_cnt++; 3485 trace_xfs_log_recover_item_add(log, trans, item, 0); 3486 return 0; 3487 } 3488 3489 /* 3490 * Free up any resources allocated by the transaction 3491 * 3492 * Remember that EFIs, EFDs, and IUNLINKs are handled later. 3493 */ 3494 STATIC void 3495 xlog_recover_free_trans( 3496 struct xlog_recover *trans) 3497 { 3498 xlog_recover_item_t *item, *n; 3499 int i; 3500 3501 list_for_each_entry_safe(item, n, &trans->r_itemq, ri_list) { 3502 /* Free the regions in the item. */ 3503 list_del(&item->ri_list); 3504 for (i = 0; i < item->ri_cnt; i++) 3505 kmem_free(item->ri_buf[i].i_addr); 3506 /* Free the item itself */ 3507 kmem_free(item->ri_buf); 3508 kmem_free(item); 3509 } 3510 /* Free the transaction recover structure */ 3511 kmem_free(trans); 3512 } 3513 3514 /* 3515 * On error or completion, trans is freed. 3516 */ 3517 STATIC int 3518 xlog_recovery_process_trans( 3519 struct xlog *log, 3520 struct xlog_recover *trans, 3521 char *dp, 3522 unsigned int len, 3523 unsigned int flags, 3524 int pass) 3525 { 3526 int error = 0; 3527 bool freeit = false; 3528 3529 /* mask off ophdr transaction container flags */ 3530 flags &= ~XLOG_END_TRANS; 3531 if (flags & XLOG_WAS_CONT_TRANS) 3532 flags &= ~XLOG_CONTINUE_TRANS; 3533 3534 /* 3535 * Callees must not free the trans structure. We'll decide if we need to 3536 * free it or not based on the operation being done and it's result. 3537 */ 3538 switch (flags) { 3539 /* expected flag values */ 3540 case 0: 3541 case XLOG_CONTINUE_TRANS: 3542 error = xlog_recover_add_to_trans(log, trans, dp, len); 3543 break; 3544 case XLOG_WAS_CONT_TRANS: 3545 error = xlog_recover_add_to_cont_trans(log, trans, dp, len); 3546 break; 3547 case XLOG_COMMIT_TRANS: 3548 error = xlog_recover_commit_trans(log, trans, pass); 3549 /* success or fail, we are now done with this transaction. */ 3550 freeit = true; 3551 break; 3552 3553 /* unexpected flag values */ 3554 case XLOG_UNMOUNT_TRANS: 3555 /* just skip trans */ 3556 xfs_warn(log->l_mp, "%s: Unmount LR", __func__); 3557 freeit = true; 3558 break; 3559 case XLOG_START_TRANS: 3560 default: 3561 xfs_warn(log->l_mp, "%s: bad flag 0x%x", __func__, flags); 3562 ASSERT(0); 3563 error = -EIO; 3564 break; 3565 } 3566 if (error || freeit) 3567 xlog_recover_free_trans(trans); 3568 return error; 3569 } 3570 3571 /* 3572 * Lookup the transaction recovery structure associated with the ID in the 3573 * current ophdr. If the transaction doesn't exist and the start flag is set in 3574 * the ophdr, then allocate a new transaction for future ID matches to find. 3575 * Either way, return what we found during the lookup - an existing transaction 3576 * or nothing. 3577 */ 3578 STATIC struct xlog_recover * 3579 xlog_recover_ophdr_to_trans( 3580 struct hlist_head rhash[], 3581 struct xlog_rec_header *rhead, 3582 struct xlog_op_header *ohead) 3583 { 3584 struct xlog_recover *trans; 3585 xlog_tid_t tid; 3586 struct hlist_head *rhp; 3587 3588 tid = be32_to_cpu(ohead->oh_tid); 3589 rhp = &rhash[XLOG_RHASH(tid)]; 3590 hlist_for_each_entry(trans, rhp, r_list) { 3591 if (trans->r_log_tid == tid) 3592 return trans; 3593 } 3594 3595 /* 3596 * skip over non-start transaction headers - we could be 3597 * processing slack space before the next transaction starts 3598 */ 3599 if (!(ohead->oh_flags & XLOG_START_TRANS)) 3600 return NULL; 3601 3602 ASSERT(be32_to_cpu(ohead->oh_len) == 0); 3603 3604 /* 3605 * This is a new transaction so allocate a new recovery container to 3606 * hold the recovery ops that will follow. 3607 */ 3608 trans = kmem_zalloc(sizeof(struct xlog_recover), KM_SLEEP); 3609 trans->r_log_tid = tid; 3610 trans->r_lsn = be64_to_cpu(rhead->h_lsn); 3611 INIT_LIST_HEAD(&trans->r_itemq); 3612 INIT_HLIST_NODE(&trans->r_list); 3613 hlist_add_head(&trans->r_list, rhp); 3614 3615 /* 3616 * Nothing more to do for this ophdr. Items to be added to this new 3617 * transaction will be in subsequent ophdr containers. 3618 */ 3619 return NULL; 3620 } 3621 3622 STATIC int 3623 xlog_recover_process_ophdr( 3624 struct xlog *log, 3625 struct hlist_head rhash[], 3626 struct xlog_rec_header *rhead, 3627 struct xlog_op_header *ohead, 3628 char *dp, 3629 char *end, 3630 int pass) 3631 { 3632 struct xlog_recover *trans; 3633 unsigned int len; 3634 3635 /* Do we understand who wrote this op? */ 3636 if (ohead->oh_clientid != XFS_TRANSACTION && 3637 ohead->oh_clientid != XFS_LOG) { 3638 xfs_warn(log->l_mp, "%s: bad clientid 0x%x", 3639 __func__, ohead->oh_clientid); 3640 ASSERT(0); 3641 return -EIO; 3642 } 3643 3644 /* 3645 * Check the ophdr contains all the data it is supposed to contain. 3646 */ 3647 len = be32_to_cpu(ohead->oh_len); 3648 if (dp + len > end) { 3649 xfs_warn(log->l_mp, "%s: bad length 0x%x", __func__, len); 3650 WARN_ON(1); 3651 return -EIO; 3652 } 3653 3654 trans = xlog_recover_ophdr_to_trans(rhash, rhead, ohead); 3655 if (!trans) { 3656 /* nothing to do, so skip over this ophdr */ 3657 return 0; 3658 } 3659 3660 return xlog_recovery_process_trans(log, trans, dp, len, 3661 ohead->oh_flags, pass); 3662 } 3663 3664 /* 3665 * There are two valid states of the r_state field. 0 indicates that the 3666 * transaction structure is in a normal state. We have either seen the 3667 * start of the transaction or the last operation we added was not a partial 3668 * operation. If the last operation we added to the transaction was a 3669 * partial operation, we need to mark r_state with XLOG_WAS_CONT_TRANS. 3670 * 3671 * NOTE: skip LRs with 0 data length. 3672 */ 3673 STATIC int 3674 xlog_recover_process_data( 3675 struct xlog *log, 3676 struct hlist_head rhash[], 3677 struct xlog_rec_header *rhead, 3678 char *dp, 3679 int pass) 3680 { 3681 struct xlog_op_header *ohead; 3682 char *end; 3683 int num_logops; 3684 int error; 3685 3686 end = dp + be32_to_cpu(rhead->h_len); 3687 num_logops = be32_to_cpu(rhead->h_num_logops); 3688 3689 /* check the log format matches our own - else we can't recover */ 3690 if (xlog_header_check_recover(log->l_mp, rhead)) 3691 return -EIO; 3692 3693 while ((dp < end) && num_logops) { 3694 3695 ohead = (struct xlog_op_header *)dp; 3696 dp += sizeof(*ohead); 3697 ASSERT(dp <= end); 3698 3699 /* errors will abort recovery */ 3700 error = xlog_recover_process_ophdr(log, rhash, rhead, ohead, 3701 dp, end, pass); 3702 if (error) 3703 return error; 3704 3705 dp += be32_to_cpu(ohead->oh_len); 3706 num_logops--; 3707 } 3708 return 0; 3709 } 3710 3711 /* 3712 * Process an extent free intent item that was recovered from 3713 * the log. We need to free the extents that it describes. 3714 */ 3715 STATIC int 3716 xlog_recover_process_efi( 3717 xfs_mount_t *mp, 3718 xfs_efi_log_item_t *efip) 3719 { 3720 xfs_efd_log_item_t *efdp; 3721 xfs_trans_t *tp; 3722 int i; 3723 int error = 0; 3724 xfs_extent_t *extp; 3725 xfs_fsblock_t startblock_fsb; 3726 3727 ASSERT(!test_bit(XFS_EFI_RECOVERED, &efip->efi_flags)); 3728 3729 /* 3730 * First check the validity of the extents described by the 3731 * EFI. If any are bad, then assume that all are bad and 3732 * just toss the EFI. 3733 */ 3734 for (i = 0; i < efip->efi_format.efi_nextents; i++) { 3735 extp = &(efip->efi_format.efi_extents[i]); 3736 startblock_fsb = XFS_BB_TO_FSB(mp, 3737 XFS_FSB_TO_DADDR(mp, extp->ext_start)); 3738 if ((startblock_fsb == 0) || 3739 (extp->ext_len == 0) || 3740 (startblock_fsb >= mp->m_sb.sb_dblocks) || 3741 (extp->ext_len >= mp->m_sb.sb_agblocks)) { 3742 /* 3743 * This will pull the EFI from the AIL and 3744 * free the memory associated with it. 3745 */ 3746 set_bit(XFS_EFI_RECOVERED, &efip->efi_flags); 3747 xfs_efi_release(efip, efip->efi_format.efi_nextents); 3748 return -EIO; 3749 } 3750 } 3751 3752 tp = xfs_trans_alloc(mp, 0); 3753 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0); 3754 if (error) 3755 goto abort_error; 3756 efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents); 3757 3758 for (i = 0; i < efip->efi_format.efi_nextents; i++) { 3759 extp = &(efip->efi_format.efi_extents[i]); 3760 error = xfs_free_extent(tp, extp->ext_start, extp->ext_len); 3761 if (error) 3762 goto abort_error; 3763 xfs_trans_log_efd_extent(tp, efdp, extp->ext_start, 3764 extp->ext_len); 3765 } 3766 3767 set_bit(XFS_EFI_RECOVERED, &efip->efi_flags); 3768 error = xfs_trans_commit(tp); 3769 return error; 3770 3771 abort_error: 3772 xfs_trans_cancel(tp); 3773 return error; 3774 } 3775 3776 /* 3777 * When this is called, all of the EFIs which did not have 3778 * corresponding EFDs should be in the AIL. What we do now 3779 * is free the extents associated with each one. 3780 * 3781 * Since we process the EFIs in normal transactions, they 3782 * will be removed at some point after the commit. This prevents 3783 * us from just walking down the list processing each one. 3784 * We'll use a flag in the EFI to skip those that we've already 3785 * processed and use the AIL iteration mechanism's generation 3786 * count to try to speed this up at least a bit. 3787 * 3788 * When we start, we know that the EFIs are the only things in 3789 * the AIL. As we process them, however, other items are added 3790 * to the AIL. Since everything added to the AIL must come after 3791 * everything already in the AIL, we stop processing as soon as 3792 * we see something other than an EFI in the AIL. 3793 */ 3794 STATIC int 3795 xlog_recover_process_efis( 3796 struct xlog *log) 3797 { 3798 xfs_log_item_t *lip; 3799 xfs_efi_log_item_t *efip; 3800 int error = 0; 3801 struct xfs_ail_cursor cur; 3802 struct xfs_ail *ailp; 3803 3804 ailp = log->l_ailp; 3805 spin_lock(&ailp->xa_lock); 3806 lip = xfs_trans_ail_cursor_first(ailp, &cur, 0); 3807 while (lip != NULL) { 3808 /* 3809 * We're done when we see something other than an EFI. 3810 * There should be no EFIs left in the AIL now. 3811 */ 3812 if (lip->li_type != XFS_LI_EFI) { 3813 #ifdef DEBUG 3814 for (; lip; lip = xfs_trans_ail_cursor_next(ailp, &cur)) 3815 ASSERT(lip->li_type != XFS_LI_EFI); 3816 #endif 3817 break; 3818 } 3819 3820 /* 3821 * Skip EFIs that we've already processed. 3822 */ 3823 efip = (xfs_efi_log_item_t *)lip; 3824 if (test_bit(XFS_EFI_RECOVERED, &efip->efi_flags)) { 3825 lip = xfs_trans_ail_cursor_next(ailp, &cur); 3826 continue; 3827 } 3828 3829 spin_unlock(&ailp->xa_lock); 3830 error = xlog_recover_process_efi(log->l_mp, efip); 3831 spin_lock(&ailp->xa_lock); 3832 if (error) 3833 goto out; 3834 lip = xfs_trans_ail_cursor_next(ailp, &cur); 3835 } 3836 out: 3837 xfs_trans_ail_cursor_done(&cur); 3838 spin_unlock(&ailp->xa_lock); 3839 return error; 3840 } 3841 3842 /* 3843 * This routine performs a transaction to null out a bad inode pointer 3844 * in an agi unlinked inode hash bucket. 3845 */ 3846 STATIC void 3847 xlog_recover_clear_agi_bucket( 3848 xfs_mount_t *mp, 3849 xfs_agnumber_t agno, 3850 int bucket) 3851 { 3852 xfs_trans_t *tp; 3853 xfs_agi_t *agi; 3854 xfs_buf_t *agibp; 3855 int offset; 3856 int error; 3857 3858 tp = xfs_trans_alloc(mp, XFS_TRANS_CLEAR_AGI_BUCKET); 3859 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_clearagi, 0, 0); 3860 if (error) 3861 goto out_abort; 3862 3863 error = xfs_read_agi(mp, tp, agno, &agibp); 3864 if (error) 3865 goto out_abort; 3866 3867 agi = XFS_BUF_TO_AGI(agibp); 3868 agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO); 3869 offset = offsetof(xfs_agi_t, agi_unlinked) + 3870 (sizeof(xfs_agino_t) * bucket); 3871 xfs_trans_log_buf(tp, agibp, offset, 3872 (offset + sizeof(xfs_agino_t) - 1)); 3873 3874 error = xfs_trans_commit(tp); 3875 if (error) 3876 goto out_error; 3877 return; 3878 3879 out_abort: 3880 xfs_trans_cancel(tp); 3881 out_error: 3882 xfs_warn(mp, "%s: failed to clear agi %d. Continuing.", __func__, agno); 3883 return; 3884 } 3885 3886 STATIC xfs_agino_t 3887 xlog_recover_process_one_iunlink( 3888 struct xfs_mount *mp, 3889 xfs_agnumber_t agno, 3890 xfs_agino_t agino, 3891 int bucket) 3892 { 3893 struct xfs_buf *ibp; 3894 struct xfs_dinode *dip; 3895 struct xfs_inode *ip; 3896 xfs_ino_t ino; 3897 int error; 3898 3899 ino = XFS_AGINO_TO_INO(mp, agno, agino); 3900 error = xfs_iget(mp, NULL, ino, 0, 0, &ip); 3901 if (error) 3902 goto fail; 3903 3904 /* 3905 * Get the on disk inode to find the next inode in the bucket. 3906 */ 3907 error = xfs_imap_to_bp(mp, NULL, &ip->i_imap, &dip, &ibp, 0, 0); 3908 if (error) 3909 goto fail_iput; 3910 3911 ASSERT(ip->i_d.di_nlink == 0); 3912 ASSERT(ip->i_d.di_mode != 0); 3913 3914 /* setup for the next pass */ 3915 agino = be32_to_cpu(dip->di_next_unlinked); 3916 xfs_buf_relse(ibp); 3917 3918 /* 3919 * Prevent any DMAPI event from being sent when the reference on 3920 * the inode is dropped. 3921 */ 3922 ip->i_d.di_dmevmask = 0; 3923 3924 IRELE(ip); 3925 return agino; 3926 3927 fail_iput: 3928 IRELE(ip); 3929 fail: 3930 /* 3931 * We can't read in the inode this bucket points to, or this inode 3932 * is messed up. Just ditch this bucket of inodes. We will lose 3933 * some inodes and space, but at least we won't hang. 3934 * 3935 * Call xlog_recover_clear_agi_bucket() to perform a transaction to 3936 * clear the inode pointer in the bucket. 3937 */ 3938 xlog_recover_clear_agi_bucket(mp, agno, bucket); 3939 return NULLAGINO; 3940 } 3941 3942 /* 3943 * xlog_iunlink_recover 3944 * 3945 * This is called during recovery to process any inodes which 3946 * we unlinked but not freed when the system crashed. These 3947 * inodes will be on the lists in the AGI blocks. What we do 3948 * here is scan all the AGIs and fully truncate and free any 3949 * inodes found on the lists. Each inode is removed from the 3950 * lists when it has been fully truncated and is freed. The 3951 * freeing of the inode and its removal from the list must be 3952 * atomic. 3953 */ 3954 STATIC void 3955 xlog_recover_process_iunlinks( 3956 struct xlog *log) 3957 { 3958 xfs_mount_t *mp; 3959 xfs_agnumber_t agno; 3960 xfs_agi_t *agi; 3961 xfs_buf_t *agibp; 3962 xfs_agino_t agino; 3963 int bucket; 3964 int error; 3965 uint mp_dmevmask; 3966 3967 mp = log->l_mp; 3968 3969 /* 3970 * Prevent any DMAPI event from being sent while in this function. 3971 */ 3972 mp_dmevmask = mp->m_dmevmask; 3973 mp->m_dmevmask = 0; 3974 3975 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) { 3976 /* 3977 * Find the agi for this ag. 3978 */ 3979 error = xfs_read_agi(mp, NULL, agno, &agibp); 3980 if (error) { 3981 /* 3982 * AGI is b0rked. Don't process it. 3983 * 3984 * We should probably mark the filesystem as corrupt 3985 * after we've recovered all the ag's we can.... 3986 */ 3987 continue; 3988 } 3989 /* 3990 * Unlock the buffer so that it can be acquired in the normal 3991 * course of the transaction to truncate and free each inode. 3992 * Because we are not racing with anyone else here for the AGI 3993 * buffer, we don't even need to hold it locked to read the 3994 * initial unlinked bucket entries out of the buffer. We keep 3995 * buffer reference though, so that it stays pinned in memory 3996 * while we need the buffer. 3997 */ 3998 agi = XFS_BUF_TO_AGI(agibp); 3999 xfs_buf_unlock(agibp); 4000 4001 for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++) { 4002 agino = be32_to_cpu(agi->agi_unlinked[bucket]); 4003 while (agino != NULLAGINO) { 4004 agino = xlog_recover_process_one_iunlink(mp, 4005 agno, agino, bucket); 4006 } 4007 } 4008 xfs_buf_rele(agibp); 4009 } 4010 4011 mp->m_dmevmask = mp_dmevmask; 4012 } 4013 4014 /* 4015 * Upack the log buffer data and crc check it. If the check fails, issue a 4016 * warning if and only if the CRC in the header is non-zero. This makes the 4017 * check an advisory warning, and the zero CRC check will prevent failure 4018 * warnings from being emitted when upgrading the kernel from one that does not 4019 * add CRCs by default. 4020 * 4021 * When filesystems are CRC enabled, this CRC mismatch becomes a fatal log 4022 * corruption failure 4023 */ 4024 STATIC int 4025 xlog_unpack_data_crc( 4026 struct xlog_rec_header *rhead, 4027 char *dp, 4028 struct xlog *log) 4029 { 4030 __le32 crc; 4031 4032 crc = xlog_cksum(log, rhead, dp, be32_to_cpu(rhead->h_len)); 4033 if (crc != rhead->h_crc) { 4034 if (rhead->h_crc || xfs_sb_version_hascrc(&log->l_mp->m_sb)) { 4035 xfs_alert(log->l_mp, 4036 "log record CRC mismatch: found 0x%x, expected 0x%x.", 4037 le32_to_cpu(rhead->h_crc), 4038 le32_to_cpu(crc)); 4039 xfs_hex_dump(dp, 32); 4040 } 4041 4042 /* 4043 * If we've detected a log record corruption, then we can't 4044 * recover past this point. Abort recovery if we are enforcing 4045 * CRC protection by punting an error back up the stack. 4046 */ 4047 if (xfs_sb_version_hascrc(&log->l_mp->m_sb)) 4048 return -EFSCORRUPTED; 4049 } 4050 4051 return 0; 4052 } 4053 4054 STATIC int 4055 xlog_unpack_data( 4056 struct xlog_rec_header *rhead, 4057 char *dp, 4058 struct xlog *log) 4059 { 4060 int i, j, k; 4061 int error; 4062 4063 error = xlog_unpack_data_crc(rhead, dp, log); 4064 if (error) 4065 return error; 4066 4067 for (i = 0; i < BTOBB(be32_to_cpu(rhead->h_len)) && 4068 i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) { 4069 *(__be32 *)dp = *(__be32 *)&rhead->h_cycle_data[i]; 4070 dp += BBSIZE; 4071 } 4072 4073 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) { 4074 xlog_in_core_2_t *xhdr = (xlog_in_core_2_t *)rhead; 4075 for ( ; i < BTOBB(be32_to_cpu(rhead->h_len)); i++) { 4076 j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE); 4077 k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE); 4078 *(__be32 *)dp = xhdr[j].hic_xheader.xh_cycle_data[k]; 4079 dp += BBSIZE; 4080 } 4081 } 4082 4083 return 0; 4084 } 4085 4086 STATIC int 4087 xlog_valid_rec_header( 4088 struct xlog *log, 4089 struct xlog_rec_header *rhead, 4090 xfs_daddr_t blkno) 4091 { 4092 int hlen; 4093 4094 if (unlikely(rhead->h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))) { 4095 XFS_ERROR_REPORT("xlog_valid_rec_header(1)", 4096 XFS_ERRLEVEL_LOW, log->l_mp); 4097 return -EFSCORRUPTED; 4098 } 4099 if (unlikely( 4100 (!rhead->h_version || 4101 (be32_to_cpu(rhead->h_version) & (~XLOG_VERSION_OKBITS))))) { 4102 xfs_warn(log->l_mp, "%s: unrecognised log version (%d).", 4103 __func__, be32_to_cpu(rhead->h_version)); 4104 return -EIO; 4105 } 4106 4107 /* LR body must have data or it wouldn't have been written */ 4108 hlen = be32_to_cpu(rhead->h_len); 4109 if (unlikely( hlen <= 0 || hlen > INT_MAX )) { 4110 XFS_ERROR_REPORT("xlog_valid_rec_header(2)", 4111 XFS_ERRLEVEL_LOW, log->l_mp); 4112 return -EFSCORRUPTED; 4113 } 4114 if (unlikely( blkno > log->l_logBBsize || blkno > INT_MAX )) { 4115 XFS_ERROR_REPORT("xlog_valid_rec_header(3)", 4116 XFS_ERRLEVEL_LOW, log->l_mp); 4117 return -EFSCORRUPTED; 4118 } 4119 return 0; 4120 } 4121 4122 /* 4123 * Read the log from tail to head and process the log records found. 4124 * Handle the two cases where the tail and head are in the same cycle 4125 * and where the active portion of the log wraps around the end of 4126 * the physical log separately. The pass parameter is passed through 4127 * to the routines called to process the data and is not looked at 4128 * here. 4129 */ 4130 STATIC int 4131 xlog_do_recovery_pass( 4132 struct xlog *log, 4133 xfs_daddr_t head_blk, 4134 xfs_daddr_t tail_blk, 4135 int pass) 4136 { 4137 xlog_rec_header_t *rhead; 4138 xfs_daddr_t blk_no; 4139 char *offset; 4140 xfs_buf_t *hbp, *dbp; 4141 int error = 0, h_size; 4142 int bblks, split_bblks; 4143 int hblks, split_hblks, wrapped_hblks; 4144 struct hlist_head rhash[XLOG_RHASH_SIZE]; 4145 4146 ASSERT(head_blk != tail_blk); 4147 4148 /* 4149 * Read the header of the tail block and get the iclog buffer size from 4150 * h_size. Use this to tell how many sectors make up the log header. 4151 */ 4152 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) { 4153 /* 4154 * When using variable length iclogs, read first sector of 4155 * iclog header and extract the header size from it. Get a 4156 * new hbp that is the correct size. 4157 */ 4158 hbp = xlog_get_bp(log, 1); 4159 if (!hbp) 4160 return -ENOMEM; 4161 4162 error = xlog_bread(log, tail_blk, 1, hbp, &offset); 4163 if (error) 4164 goto bread_err1; 4165 4166 rhead = (xlog_rec_header_t *)offset; 4167 error = xlog_valid_rec_header(log, rhead, tail_blk); 4168 if (error) 4169 goto bread_err1; 4170 h_size = be32_to_cpu(rhead->h_size); 4171 if ((be32_to_cpu(rhead->h_version) & XLOG_VERSION_2) && 4172 (h_size > XLOG_HEADER_CYCLE_SIZE)) { 4173 hblks = h_size / XLOG_HEADER_CYCLE_SIZE; 4174 if (h_size % XLOG_HEADER_CYCLE_SIZE) 4175 hblks++; 4176 xlog_put_bp(hbp); 4177 hbp = xlog_get_bp(log, hblks); 4178 } else { 4179 hblks = 1; 4180 } 4181 } else { 4182 ASSERT(log->l_sectBBsize == 1); 4183 hblks = 1; 4184 hbp = xlog_get_bp(log, 1); 4185 h_size = XLOG_BIG_RECORD_BSIZE; 4186 } 4187 4188 if (!hbp) 4189 return -ENOMEM; 4190 dbp = xlog_get_bp(log, BTOBB(h_size)); 4191 if (!dbp) { 4192 xlog_put_bp(hbp); 4193 return -ENOMEM; 4194 } 4195 4196 memset(rhash, 0, sizeof(rhash)); 4197 blk_no = tail_blk; 4198 if (tail_blk > head_blk) { 4199 /* 4200 * Perform recovery around the end of the physical log. 4201 * When the head is not on the same cycle number as the tail, 4202 * we can't do a sequential recovery. 4203 */ 4204 while (blk_no < log->l_logBBsize) { 4205 /* 4206 * Check for header wrapping around physical end-of-log 4207 */ 4208 offset = hbp->b_addr; 4209 split_hblks = 0; 4210 wrapped_hblks = 0; 4211 if (blk_no + hblks <= log->l_logBBsize) { 4212 /* Read header in one read */ 4213 error = xlog_bread(log, blk_no, hblks, hbp, 4214 &offset); 4215 if (error) 4216 goto bread_err2; 4217 } else { 4218 /* This LR is split across physical log end */ 4219 if (blk_no != log->l_logBBsize) { 4220 /* some data before physical log end */ 4221 ASSERT(blk_no <= INT_MAX); 4222 split_hblks = log->l_logBBsize - (int)blk_no; 4223 ASSERT(split_hblks > 0); 4224 error = xlog_bread(log, blk_no, 4225 split_hblks, hbp, 4226 &offset); 4227 if (error) 4228 goto bread_err2; 4229 } 4230 4231 /* 4232 * Note: this black magic still works with 4233 * large sector sizes (non-512) only because: 4234 * - we increased the buffer size originally 4235 * by 1 sector giving us enough extra space 4236 * for the second read; 4237 * - the log start is guaranteed to be sector 4238 * aligned; 4239 * - we read the log end (LR header start) 4240 * _first_, then the log start (LR header end) 4241 * - order is important. 4242 */ 4243 wrapped_hblks = hblks - split_hblks; 4244 error = xlog_bread_offset(log, 0, 4245 wrapped_hblks, hbp, 4246 offset + BBTOB(split_hblks)); 4247 if (error) 4248 goto bread_err2; 4249 } 4250 rhead = (xlog_rec_header_t *)offset; 4251 error = xlog_valid_rec_header(log, rhead, 4252 split_hblks ? blk_no : 0); 4253 if (error) 4254 goto bread_err2; 4255 4256 bblks = (int)BTOBB(be32_to_cpu(rhead->h_len)); 4257 blk_no += hblks; 4258 4259 /* Read in data for log record */ 4260 if (blk_no + bblks <= log->l_logBBsize) { 4261 error = xlog_bread(log, blk_no, bblks, dbp, 4262 &offset); 4263 if (error) 4264 goto bread_err2; 4265 } else { 4266 /* This log record is split across the 4267 * physical end of log */ 4268 offset = dbp->b_addr; 4269 split_bblks = 0; 4270 if (blk_no != log->l_logBBsize) { 4271 /* some data is before the physical 4272 * end of log */ 4273 ASSERT(!wrapped_hblks); 4274 ASSERT(blk_no <= INT_MAX); 4275 split_bblks = 4276 log->l_logBBsize - (int)blk_no; 4277 ASSERT(split_bblks > 0); 4278 error = xlog_bread(log, blk_no, 4279 split_bblks, dbp, 4280 &offset); 4281 if (error) 4282 goto bread_err2; 4283 } 4284 4285 /* 4286 * Note: this black magic still works with 4287 * large sector sizes (non-512) only because: 4288 * - we increased the buffer size originally 4289 * by 1 sector giving us enough extra space 4290 * for the second read; 4291 * - the log start is guaranteed to be sector 4292 * aligned; 4293 * - we read the log end (LR header start) 4294 * _first_, then the log start (LR header end) 4295 * - order is important. 4296 */ 4297 error = xlog_bread_offset(log, 0, 4298 bblks - split_bblks, dbp, 4299 offset + BBTOB(split_bblks)); 4300 if (error) 4301 goto bread_err2; 4302 } 4303 4304 error = xlog_unpack_data(rhead, offset, log); 4305 if (error) 4306 goto bread_err2; 4307 4308 error = xlog_recover_process_data(log, rhash, 4309 rhead, offset, pass); 4310 if (error) 4311 goto bread_err2; 4312 blk_no += bblks; 4313 } 4314 4315 ASSERT(blk_no >= log->l_logBBsize); 4316 blk_no -= log->l_logBBsize; 4317 } 4318 4319 /* read first part of physical log */ 4320 while (blk_no < head_blk) { 4321 error = xlog_bread(log, blk_no, hblks, hbp, &offset); 4322 if (error) 4323 goto bread_err2; 4324 4325 rhead = (xlog_rec_header_t *)offset; 4326 error = xlog_valid_rec_header(log, rhead, blk_no); 4327 if (error) 4328 goto bread_err2; 4329 4330 /* blocks in data section */ 4331 bblks = (int)BTOBB(be32_to_cpu(rhead->h_len)); 4332 error = xlog_bread(log, blk_no+hblks, bblks, dbp, 4333 &offset); 4334 if (error) 4335 goto bread_err2; 4336 4337 error = xlog_unpack_data(rhead, offset, log); 4338 if (error) 4339 goto bread_err2; 4340 4341 error = xlog_recover_process_data(log, rhash, 4342 rhead, offset, pass); 4343 if (error) 4344 goto bread_err2; 4345 blk_no += bblks + hblks; 4346 } 4347 4348 bread_err2: 4349 xlog_put_bp(dbp); 4350 bread_err1: 4351 xlog_put_bp(hbp); 4352 return error; 4353 } 4354 4355 /* 4356 * Do the recovery of the log. We actually do this in two phases. 4357 * The two passes are necessary in order to implement the function 4358 * of cancelling a record written into the log. The first pass 4359 * determines those things which have been cancelled, and the 4360 * second pass replays log items normally except for those which 4361 * have been cancelled. The handling of the replay and cancellations 4362 * takes place in the log item type specific routines. 4363 * 4364 * The table of items which have cancel records in the log is allocated 4365 * and freed at this level, since only here do we know when all of 4366 * the log recovery has been completed. 4367 */ 4368 STATIC int 4369 xlog_do_log_recovery( 4370 struct xlog *log, 4371 xfs_daddr_t head_blk, 4372 xfs_daddr_t tail_blk) 4373 { 4374 int error, i; 4375 4376 ASSERT(head_blk != tail_blk); 4377 4378 /* 4379 * First do a pass to find all of the cancelled buf log items. 4380 * Store them in the buf_cancel_table for use in the second pass. 4381 */ 4382 log->l_buf_cancel_table = kmem_zalloc(XLOG_BC_TABLE_SIZE * 4383 sizeof(struct list_head), 4384 KM_SLEEP); 4385 for (i = 0; i < XLOG_BC_TABLE_SIZE; i++) 4386 INIT_LIST_HEAD(&log->l_buf_cancel_table[i]); 4387 4388 error = xlog_do_recovery_pass(log, head_blk, tail_blk, 4389 XLOG_RECOVER_PASS1); 4390 if (error != 0) { 4391 kmem_free(log->l_buf_cancel_table); 4392 log->l_buf_cancel_table = NULL; 4393 return error; 4394 } 4395 /* 4396 * Then do a second pass to actually recover the items in the log. 4397 * When it is complete free the table of buf cancel items. 4398 */ 4399 error = xlog_do_recovery_pass(log, head_blk, tail_blk, 4400 XLOG_RECOVER_PASS2); 4401 #ifdef DEBUG 4402 if (!error) { 4403 int i; 4404 4405 for (i = 0; i < XLOG_BC_TABLE_SIZE; i++) 4406 ASSERT(list_empty(&log->l_buf_cancel_table[i])); 4407 } 4408 #endif /* DEBUG */ 4409 4410 kmem_free(log->l_buf_cancel_table); 4411 log->l_buf_cancel_table = NULL; 4412 4413 return error; 4414 } 4415 4416 /* 4417 * Do the actual recovery 4418 */ 4419 STATIC int 4420 xlog_do_recover( 4421 struct xlog *log, 4422 xfs_daddr_t head_blk, 4423 xfs_daddr_t tail_blk) 4424 { 4425 int error; 4426 xfs_buf_t *bp; 4427 xfs_sb_t *sbp; 4428 4429 /* 4430 * First replay the images in the log. 4431 */ 4432 error = xlog_do_log_recovery(log, head_blk, tail_blk); 4433 if (error) 4434 return error; 4435 4436 /* 4437 * If IO errors happened during recovery, bail out. 4438 */ 4439 if (XFS_FORCED_SHUTDOWN(log->l_mp)) { 4440 return -EIO; 4441 } 4442 4443 /* 4444 * We now update the tail_lsn since much of the recovery has completed 4445 * and there may be space available to use. If there were no extent 4446 * or iunlinks, we can free up the entire log and set the tail_lsn to 4447 * be the last_sync_lsn. This was set in xlog_find_tail to be the 4448 * lsn of the last known good LR on disk. If there are extent frees 4449 * or iunlinks they will have some entries in the AIL; so we look at 4450 * the AIL to determine how to set the tail_lsn. 4451 */ 4452 xlog_assign_tail_lsn(log->l_mp); 4453 4454 /* 4455 * Now that we've finished replaying all buffer and inode 4456 * updates, re-read in the superblock and reverify it. 4457 */ 4458 bp = xfs_getsb(log->l_mp, 0); 4459 XFS_BUF_UNDONE(bp); 4460 ASSERT(!(XFS_BUF_ISWRITE(bp))); 4461 XFS_BUF_READ(bp); 4462 XFS_BUF_UNASYNC(bp); 4463 bp->b_ops = &xfs_sb_buf_ops; 4464 4465 error = xfs_buf_submit_wait(bp); 4466 if (error) { 4467 if (!XFS_FORCED_SHUTDOWN(log->l_mp)) { 4468 xfs_buf_ioerror_alert(bp, __func__); 4469 ASSERT(0); 4470 } 4471 xfs_buf_relse(bp); 4472 return error; 4473 } 4474 4475 /* Convert superblock from on-disk format */ 4476 sbp = &log->l_mp->m_sb; 4477 xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp)); 4478 ASSERT(sbp->sb_magicnum == XFS_SB_MAGIC); 4479 ASSERT(xfs_sb_good_version(sbp)); 4480 xfs_reinit_percpu_counters(log->l_mp); 4481 4482 xfs_buf_relse(bp); 4483 4484 4485 xlog_recover_check_summary(log); 4486 4487 /* Normal transactions can now occur */ 4488 log->l_flags &= ~XLOG_ACTIVE_RECOVERY; 4489 return 0; 4490 } 4491 4492 /* 4493 * Perform recovery and re-initialize some log variables in xlog_find_tail. 4494 * 4495 * Return error or zero. 4496 */ 4497 int 4498 xlog_recover( 4499 struct xlog *log) 4500 { 4501 xfs_daddr_t head_blk, tail_blk; 4502 int error; 4503 4504 /* find the tail of the log */ 4505 if ((error = xlog_find_tail(log, &head_blk, &tail_blk))) 4506 return error; 4507 4508 if (tail_blk != head_blk) { 4509 /* There used to be a comment here: 4510 * 4511 * disallow recovery on read-only mounts. note -- mount 4512 * checks for ENOSPC and turns it into an intelligent 4513 * error message. 4514 * ...but this is no longer true. Now, unless you specify 4515 * NORECOVERY (in which case this function would never be 4516 * called), we just go ahead and recover. We do this all 4517 * under the vfs layer, so we can get away with it unless 4518 * the device itself is read-only, in which case we fail. 4519 */ 4520 if ((error = xfs_dev_is_read_only(log->l_mp, "recovery"))) { 4521 return error; 4522 } 4523 4524 /* 4525 * Version 5 superblock log feature mask validation. We know the 4526 * log is dirty so check if there are any unknown log features 4527 * in what we need to recover. If there are unknown features 4528 * (e.g. unsupported transactions, then simply reject the 4529 * attempt at recovery before touching anything. 4530 */ 4531 if (XFS_SB_VERSION_NUM(&log->l_mp->m_sb) == XFS_SB_VERSION_5 && 4532 xfs_sb_has_incompat_log_feature(&log->l_mp->m_sb, 4533 XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN)) { 4534 xfs_warn(log->l_mp, 4535 "Superblock has unknown incompatible log features (0x%x) enabled.\n" 4536 "The log can not be fully and/or safely recovered by this kernel.\n" 4537 "Please recover the log on a kernel that supports the unknown features.", 4538 (log->l_mp->m_sb.sb_features_log_incompat & 4539 XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN)); 4540 return -EINVAL; 4541 } 4542 4543 /* 4544 * Delay log recovery if the debug hook is set. This is debug 4545 * instrumention to coordinate simulation of I/O failures with 4546 * log recovery. 4547 */ 4548 if (xfs_globals.log_recovery_delay) { 4549 xfs_notice(log->l_mp, 4550 "Delaying log recovery for %d seconds.", 4551 xfs_globals.log_recovery_delay); 4552 msleep(xfs_globals.log_recovery_delay * 1000); 4553 } 4554 4555 xfs_notice(log->l_mp, "Starting recovery (logdev: %s)", 4556 log->l_mp->m_logname ? log->l_mp->m_logname 4557 : "internal"); 4558 4559 error = xlog_do_recover(log, head_blk, tail_blk); 4560 log->l_flags |= XLOG_RECOVERY_NEEDED; 4561 } 4562 return error; 4563 } 4564 4565 /* 4566 * In the first part of recovery we replay inodes and buffers and build 4567 * up the list of extent free items which need to be processed. Here 4568 * we process the extent free items and clean up the on disk unlinked 4569 * inode lists. This is separated from the first part of recovery so 4570 * that the root and real-time bitmap inodes can be read in from disk in 4571 * between the two stages. This is necessary so that we can free space 4572 * in the real-time portion of the file system. 4573 */ 4574 int 4575 xlog_recover_finish( 4576 struct xlog *log) 4577 { 4578 /* 4579 * Now we're ready to do the transactions needed for the 4580 * rest of recovery. Start with completing all the extent 4581 * free intent records and then process the unlinked inode 4582 * lists. At this point, we essentially run in normal mode 4583 * except that we're still performing recovery actions 4584 * rather than accepting new requests. 4585 */ 4586 if (log->l_flags & XLOG_RECOVERY_NEEDED) { 4587 int error; 4588 error = xlog_recover_process_efis(log); 4589 if (error) { 4590 xfs_alert(log->l_mp, "Failed to recover EFIs"); 4591 return error; 4592 } 4593 /* 4594 * Sync the log to get all the EFIs out of the AIL. 4595 * This isn't absolutely necessary, but it helps in 4596 * case the unlink transactions would have problems 4597 * pushing the EFIs out of the way. 4598 */ 4599 xfs_log_force(log->l_mp, XFS_LOG_SYNC); 4600 4601 xlog_recover_process_iunlinks(log); 4602 4603 xlog_recover_check_summary(log); 4604 4605 xfs_notice(log->l_mp, "Ending recovery (logdev: %s)", 4606 log->l_mp->m_logname ? log->l_mp->m_logname 4607 : "internal"); 4608 log->l_flags &= ~XLOG_RECOVERY_NEEDED; 4609 } else { 4610 xfs_info(log->l_mp, "Ending clean mount"); 4611 } 4612 return 0; 4613 } 4614 4615 4616 #if defined(DEBUG) 4617 /* 4618 * Read all of the agf and agi counters and check that they 4619 * are consistent with the superblock counters. 4620 */ 4621 void 4622 xlog_recover_check_summary( 4623 struct xlog *log) 4624 { 4625 xfs_mount_t *mp; 4626 xfs_agf_t *agfp; 4627 xfs_buf_t *agfbp; 4628 xfs_buf_t *agibp; 4629 xfs_agnumber_t agno; 4630 __uint64_t freeblks; 4631 __uint64_t itotal; 4632 __uint64_t ifree; 4633 int error; 4634 4635 mp = log->l_mp; 4636 4637 freeblks = 0LL; 4638 itotal = 0LL; 4639 ifree = 0LL; 4640 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) { 4641 error = xfs_read_agf(mp, NULL, agno, 0, &agfbp); 4642 if (error) { 4643 xfs_alert(mp, "%s agf read failed agno %d error %d", 4644 __func__, agno, error); 4645 } else { 4646 agfp = XFS_BUF_TO_AGF(agfbp); 4647 freeblks += be32_to_cpu(agfp->agf_freeblks) + 4648 be32_to_cpu(agfp->agf_flcount); 4649 xfs_buf_relse(agfbp); 4650 } 4651 4652 error = xfs_read_agi(mp, NULL, agno, &agibp); 4653 if (error) { 4654 xfs_alert(mp, "%s agi read failed agno %d error %d", 4655 __func__, agno, error); 4656 } else { 4657 struct xfs_agi *agi = XFS_BUF_TO_AGI(agibp); 4658 4659 itotal += be32_to_cpu(agi->agi_count); 4660 ifree += be32_to_cpu(agi->agi_freecount); 4661 xfs_buf_relse(agibp); 4662 } 4663 } 4664 } 4665 #endif /* DEBUG */ 4666