Hi Fengnan, Thank you for the patch! Perhaps something to improve: [auto build test WARNING on tytso-fscrypt/master] [cannot apply to ext4/dev linus/master v5.9 next-20201012] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch] url: https://github.com/0day-ci/linux/commits/Fengnan-Chang/jbd2-avoid-transac... base: https://git.kernel.org/pub/scm/linux/kernel/git/tytso/fscrypt.git master config: sparc64-randconfig-s032-20201012 (attached as .config) compiler: sparc64-linux-gcc (GCC) 9.3.0 reproduce: wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # apt-get install sparse # sparse version: v0.6.3-rc1-dirty # https://github.com/0day-ci/linux/commit/fa9e125afb86200f923868b057a3e77ec... git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Fengnan-Chang/jbd2-avoid-transaction-reuse-after-reformatting/20201012-215959 git checkout fa9e125afb86200f923868b057a3e77ec7dcb215 # save the attached .config to linux build tree COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' ARCH=sparc64 If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot <lkp(a)intel.com&gt; "sparse warnings: (new ones prefixed by >>)" fs/jbd2/recovery.c:708:45: sparse: expected restricted __be64 [usertype] commit_time fs/jbd2/recovery.c:708:45: sparse: got unsigned long long [usertype] fs/jbd2/recovery.c:717:45: sparse: sparse: restricted __be64 degrades to integer fs/jbd2/recovery.c:718:49: sparse: sparse: restricted __be64 degrades to integer fs/jbd2/recovery.c:781:45: sparse: sparse: restricted __be64 degrades to integer fs/jbd2/recovery.c:782:49: sparse: sparse: restricted __be64 degrades to integer fs/jbd2/recovery.c:802:37: sparse: sparse: restricted __be64 degrades to integer fs/jbd2/recovery.c:802:51: sparse: sparse: restricted __be64 degrades to integer vim +708 fs/jbd2/recovery.c 415 416 static int do_one_pass(journal_t *journal, 417 struct recovery_info *info, enum passtype pass) 418 { 419 unsigned int first_commit_ID, next_commit_ID; 420 unsigned long next_log_block; 421 int err, success = 0; 422 journal_superblock_t * sb; 423 journal_header_t * tmp; 424 struct buffer_head * bh; 425 unsigned int sequence; 426 int blocktype; 427 int tag_bytes = journal_tag_bytes(journal); 428 __u32 crc32_sum = ~0; /* Transactional Checksums */ 429 int descr_csum_size = 0; 430 int block_error = 0; 431 bool need_check_commit_time = false; 432 __be64 last_trans_commit_time = 0, commit_time = 0; 433 434 /* 435 * First thing is to establish what we expect to find in the log 436 * (in terms of transaction IDs), and where (in terms of log 437 * block offsets): query the superblock. 438 */ 439 440 sb = journal->j_superblock; 441 next_commit_ID = be32_to_cpu(sb->s_sequence); 442 next_log_block = be32_to_cpu(sb->s_start); 443 444 first_commit_ID = next_commit_ID; 445 if (pass == PASS_SCAN) 446 info->start_transaction = first_commit_ID; 447 448 jbd_debug(1, "Starting recovery pass %d\n", pass); 449 450 /* 451 * Now we walk through the log, transaction by transaction, 452 * making sure that each transaction has a commit block in the 453 * expected place. Each complete transaction gets replayed back 454 * into the main filesystem. 455 */ 456 457 while (1) { 458 int flags; 459 char * tagp; 460 journal_block_tag_t * tag; 461 struct buffer_head * obh; 462 struct buffer_head * nbh; 463 464 cond_resched(); 465 466 /* If we already know where to stop the log traversal, 467 * check right now that we haven't gone past the end of 468 * the log. */ 469 470 if (pass != PASS_SCAN) 471 if (tid_geq(next_commit_ID, info->end_transaction)) 472 break; 473 474 jbd_debug(2, "Scanning for sequence ID %u at %lu/%lu\n", 475 next_commit_ID, next_log_block, journal->j_last); 476 477 /* Skip over each chunk of the transaction looking 478 * either the next descriptor block or the final commit 479 * record. */ 480 481 jbd_debug(3, "JBD2: checking block %ld\n", next_log_block); 482 err = jread(&bh, journal, next_log_block); 483 if (err) 484 goto failed; 485 486 next_log_block++; 487 wrap(journal, next_log_block); 488 489 /* What kind of buffer is it? 490 * 491 * If it is a descriptor block, check that it has the 492 * expected sequence number. Otherwise, we're all done 493 * here. */ 494 495 tmp = (journal_header_t *)bh->b_data; 496 497 if (tmp->h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER)) { 498 brelse(bh); 499 break; 500 } 501 502 blocktype = be32_to_cpu(tmp->h_blocktype); 503 sequence = be32_to_cpu(tmp->h_sequence); 504 jbd_debug(3, "Found magic %d, sequence %d\n", 505 blocktype, sequence); 506 507 if (sequence != next_commit_ID) { 508 brelse(bh); 509 break; 510 } 511 512 /* OK, we have a valid descriptor block which matches 513 * all of the sequence number checks. What are we going 514 * to do with it? That depends on the pass... */ 515 516 switch(blocktype) { 517 case JBD2_DESCRIPTOR_BLOCK: 518 /* Verify checksum first */ 519 if (jbd2_journal_has_csum_v2or3(journal)) 520 descr_csum_size = 521 sizeof(struct jbd2_journal_block_tail); 522 if (descr_csum_size > 0 && 523 !jbd2_descriptor_block_csum_verify(journal, 524 bh->b_data)) { 525 /* 526 * PASS_SCAN can see stale blocks due to lazy 527 * journal init. Don't error out on those yet. 528 */ 529 if (pass != PASS_SCAN) { 530 pr_err("JBD2: Invalid checksum recovering block %lu in log\n", 531 next_log_block); 532 err = -EFSBADCRC; 533 brelse(bh); 534 goto failed; 535 } 536 need_check_commit_time = true; 537 jbd_debug(1, 538 "invalid descriptor block found in %lu\n", 539 next_log_block); 540 } 541 542 /* If it is a valid descriptor block, replay it 543 * in pass REPLAY; if journal_checksums enabled, then 544 * calculate checksums in PASS_SCAN, otherwise, 545 * just skip over the blocks it describes. */ 546 if (pass != PASS_REPLAY) { 547 if (pass == PASS_SCAN && 548 jbd2_has_feature_checksum(journal) && 549 !need_check_commit_time && 550 !info->end_transaction) { 551 if (calc_chksums(journal, bh, 552 &next_log_block, 553 &crc32_sum)) { 554 put_bh(bh); 555 break; 556 } 557 put_bh(bh); 558 continue; 559 } 560 next_log_block += count_tags(journal, bh); 561 wrap(journal, next_log_block); 562 put_bh(bh); 563 continue; 564 } 565 566 /* A descriptor block: we can now write all of 567 * the data blocks. Yay, useful work is finally 568 * getting done here! */ 569 570 tagp = &bh->b_data[sizeof(journal_header_t)]; 571 while ((tagp - bh->b_data + tag_bytes) 572 <= journal->j_blocksize - descr_csum_size) { 573 unsigned long io_block; 574 575 tag = (journal_block_tag_t *) tagp; 576 flags = be16_to_cpu(tag->t_flags); 577 578 io_block = next_log_block++; 579 wrap(journal, next_log_block); 580 err = jread(&obh, journal, io_block); 581 if (err) { 582 /* Recover what we can, but 583 * report failure at the end. */ 584 success = err; 585 printk(KERN_ERR 586 "JBD2: IO error %d recovering " 587 "block %ld in log\n", 588 err, io_block); 589 } else { 590 unsigned long long blocknr; 591 592 J_ASSERT(obh != NULL); 593 blocknr = read_tag_block(journal, 594 tag); 595 596 /* If the block has been 597 * revoked, then we're all done 598 * here. */ 599 if (jbd2_journal_test_revoke 600 (journal, blocknr, 601 next_commit_ID)) { 602 brelse(obh); 603 ++info->nr_revoke_hits; 604 goto skip_write; 605 } 606 607 /* Look for block corruption */ 608 if (!jbd2_block_tag_csum_verify( 609 journal, tag, obh->b_data, 610 be32_to_cpu(tmp->h_sequence))) { 611 brelse(obh); 612 success = -EFSBADCRC; 613 printk(KERN_ERR "JBD2: Invalid " 614 "checksum recovering " 615 "data block %llu in " 616 "log\n", blocknr); 617 block_error = 1; 618 goto skip_write; 619 } 620 621 /* Find a buffer for the new 622 * data being restored */ 623 nbh = __getblk(journal->j_fs_dev, 624 blocknr, 625 journal->j_blocksize); 626 if (nbh == NULL) { 627 printk(KERN_ERR 628 "JBD2: Out of memory " 629 "during recovery.\n"); 630 err = -ENOMEM; 631 brelse(bh); 632 brelse(obh); 633 goto failed; 634 } 635 636 lock_buffer(nbh); 637 memcpy(nbh->b_data, obh->b_data, 638 journal->j_blocksize); 639 if (flags & JBD2_FLAG_ESCAPE) { 640 *((__be32 *)nbh->b_data) = 641 cpu_to_be32(JBD2_MAGIC_NUMBER); 642 } 643 644 BUFFER_TRACE(nbh, "marking dirty"); 645 set_buffer_uptodate(nbh); 646 mark_buffer_dirty(nbh); 647 BUFFER_TRACE(nbh, "marking uptodate"); 648 ++info->nr_replays; 649 /* ll_rw_block(WRITE, 1, &nbh); */ 650 unlock_buffer(nbh); 651 brelse(obh); 652 brelse(nbh); 653 } 654 655 skip_write: 656 tagp += tag_bytes; 657 if (!(flags & JBD2_FLAG_SAME_UUID)) 658 tagp += 16; 659 660 if (flags & JBD2_FLAG_LAST_TAG) 661 break; 662 } 663 664 brelse(bh); 665 continue; 666 667 case JBD2_COMMIT_BLOCK: 668 /* How to differentiate between interrupted commit 669 * and journal corruption ? 670 * 671 * {nth transaction} 672 * Checksum Verification Failed 673 * | 674 * ____________________ 675 * | | 676 * async_commit sync_commit 677 * | | 678 * | GO TO NEXT "Journal Corruption" 679 * | TRANSACTION 680 * | 681 * {(n+1)th transanction} 682 * | 683 * _______|______________ 684 * | | 685 * Commit block found Commit block not found 686 * | | 687 * "Journal Corruption" | 688 * _____________|_________ 689 * | | 690 * nth trans corrupt OR nth trans 691 * and (n+1)th interrupted interrupted 692 * before commit block 693 * could reach the disk. 694 * (Cannot find the difference in above 695 * mentioned conditions. Hence assume 696 * "Interrupted Commit".) 697 */ 698 /* 699 * If need_check_commit_time is set, it means 700 * csum verify failed before, if commit_time is 701 * increasing, it's same journal, otherwise it 702 * is stale journal block, just end this 703 * recovery. 704 */ 705 if (pass == PASS_SCAN) { 706 struct commit_header *cbh = 707 (struct commit_header *)bh->b_data; 709 be64_to_cpu(cbh->h_commit_sec); 710 /* 711 * When need check commit time, it means csum 712 * verify failed before, if commit time is 713 * increasing, it's same journal, otherwise 714 * not same journal, just end this recovery. 715 */ 716 if (need_check_commit_time) { 717 if (commit_time >= 718 last_trans_commit_time) { 719 pr_err("JBD2: Invalid checksum found in transaction %u\n", 720 next_commit_ID); 721 err = -EFSBADCRC; 722 brelse(bh); 723 goto failed; 724 } 725 /* 726 * It likely does not belong to same 727 * journal, just end this recovery with 728 * success. 729 */ 730 jbd_debug(1, "JBD2: Invalid checksum ignored in transaction %u, likely stale data\n", 731 next_commit_ID); 732 err = 0; 733 brelse(bh); 734 goto done; 735 } 736 } 737 /* Found an expected commit block: if checksums 738 * are present verify them in PASS_SCAN; else not 739 * much to do other than move on to the next sequence 740 * number. 741 */ 742 if (pass == PASS_SCAN && 743 jbd2_has_feature_checksum(journal)) { 744 int chksum_err, chksum_seen; 745 struct commit_header *cbh = 746 (struct commit_header *)bh->b_data; 747 unsigned found_chksum = 748 be32_to_cpu(cbh->h_chksum[0]); 749 750 chksum_err = chksum_seen = 0; 751 752 if (info->end_transaction) { 753 journal->j_failed_commit = 754 info->end_transaction; 755 brelse(bh); 756 break; 757 } 758 759 if (crc32_sum == found_chksum && 760 cbh->h_chksum_type == JBD2_CRC32_CHKSUM && 761 cbh->h_chksum_size == 762 JBD2_CRC32_CHKSUM_SIZE) 763 chksum_seen = 1; 764 else if (!(cbh->h_chksum_type == 0 && 765 cbh->h_chksum_size == 0 && 766 found_chksum == 0 && 767 !chksum_seen)) 768 /* 769 * If fs is mounted using an old kernel and then 770 * kernel with journal_chksum is used then we 771 * get a situation where the journal flag has 772 * checksum flag set but checksums are not 773 * present i.e chksum = 0, in the individual 774 * commit blocks. 775 * Hence to avoid checksum failures, in this 776 * situation, this extra check is added. 777 */ 778 chksum_err = 1; 779 780 if (chksum_err) { 781 if (commit_time < 782 last_trans_commit_time) { 783 jbd_debug(1, "JBD2: Invalid commit checksum ignored in transaction %u, likely stale data\n", 784 next_log_block); 785 brelse(bh); 786 goto done; 787 } 788 info->end_transaction = next_commit_ID; 789 790 if (!jbd2_has_feature_async_commit(journal)) { 791 journal->j_failed_commit = 792 next_commit_ID; 793 brelse(bh); 794 break; 795 } 796 } 797 crc32_sum = ~0; 798 } 799 if (pass == PASS_SCAN && 800 !jbd2_commit_block_csum_verify(journal, 801 bh->b_data)) { 802 if (commit_time < last_trans_commit_time) { 803 jbd_debug(1, "JBD2: Invalid commit checksum ignored in transaction %u, likely stale data\n", 804 next_log_block); 805 brelse(bh); 806 goto done; 807 } 808 info->end_transaction = next_commit_ID; 809 810 if (!jbd2_has_feature_async_commit(journal)) { 811 journal->j_failed_commit = 812 next_commit_ID; 813 brelse(bh); 814 break; 815 } 816 } 817 if (pass == PASS_SCAN) 818 last_trans_commit_time = commit_time; 819 brelse(bh); 820 next_commit_ID++; 821 continue; 822 823 case JBD2_REVOKE_BLOCK: 824 /* 825 * Check revoke block crc in pass_scan, if csum verify 826 * failed, check commit block time later. 827 */ 828 if (pass == PASS_SCAN) { 829 if (!jbd2_descriptor_block_csum_verify(journal, 830 bh->b_data)) { 831 jbd_debug(1, "invalid revoke block found in %lu\n", 832 next_log_block); 833 need_check_commit_time = true; 834 } 835 } 836 /* If we aren't in the REVOKE pass, then we can 837 * just skip over this block. */ 838 if (pass != PASS_REVOKE) { 839 brelse(bh); 840 continue; 841 } 842 843 err = scan_revoke_records(journal, bh, 844 next_commit_ID, info); 845 brelse(bh); 846 if (err) 847 goto failed; 848 continue; 849 850 default: 851 jbd_debug(3, "Unrecognised magic %d, end of scan.\n", 852 blocktype); 853 brelse(bh); 854 goto done; 855 } 856 } 857 858 done: 859 /* 860 * We broke out of the log scan loop: either we came to the 861 * known end of the log or we found an unexpected block in the 862 * log. If the latter happened, then we know that the "current" 863 * transaction marks the end of the valid log. 864 */ 865 866 if (pass == PASS_SCAN) { 867 if (!info->end_transaction) 868 info->end_transaction = next_commit_ID; 869 } else { 870 /* It's really bad news if different passes end up at 871 * different places (but possible due to IO errors). */ 872 if (info->end_transaction != next_commit_ID) { 873 printk(KERN_ERR "JBD2: recovery pass %d ended at " 874 "transaction %u, expected %u\n", 875 pass, next_commit_ID, info->end_transaction); 876 if (!success) 877 success = -EIO; 878 } 879 } 880 if (block_error && success == 0) 881 success = -EIO; 882 return success; 883 884 failed: 885 return err; 886 } 887 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org