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