From: Li Dongyang Date: Tue, 9 Oct 2018 05:28:11 +0000 (+1100) Subject: LU-11071 build: kernel update Ubuntu 18.04 X-Git-Tag: 2.12.0-RC1~45 X-Git-Url: https://git.whamcloud.com/?a=commitdiff_plain;h=29029277088c39553081fe3464791b1eb5cf8924;p=fs%2Flustre-release.git LU-11071 build: kernel update Ubuntu 18.04 This enables ldiskfs support for kernels newer than 4.15.0-24.26 Signed-off-by: Li Dongyang Change-Id: I1d61534d7f5288495b0e26c3362211c10b9826dd Reviewed-on: https://review.whamcloud.com/33322 Reviewed-by: Gu Zheng Reviewed-by: Andreas Dilger Tested-by: Jenkins Reviewed-by: James Simmons Tested-by: Maloo Reviewed-by: Oleg Drokin --- diff --git a/config/lustre-build-ldiskfs.m4 b/config/lustre-build-ldiskfs.m4 index 242afc3..444b492 100644 --- a/config/lustre-build-ldiskfs.m4 +++ b/config/lustre-build-ldiskfs.m4 @@ -78,12 +78,13 @@ AS_IF([test x$RHEL_KERNEL = xyes], [ AS_IF( [test -z "$KPLEV"], [ AC_MSG_WARN([Failed to determine Kernel patch level. Assume latest.]) - LDISKFS_SERIES="4.15.0-20-ubuntu18.series" + LDISKFS_SERIES="4.15.0-24-ubuntu18.series" ], + [test $KPLEV -ge 24], [LDISKFS_SERIES="4.15.0-24-ubuntu18.series"], [test $KPLEV -ge 20], [LDISKFS_SERIES="4.15.0-20-ubuntu18.series"] ) ], - [LDISKFS_SERIES="4.15.0-20-ubuntu18.series"]) + [LDISKFS_SERIES="4.15.0-24-ubuntu18.series"]) ]) ]) AS_IF([test -z "$LDISKFS_SERIES"], diff --git a/ldiskfs/kernel_patches/patches/ubuntu18/ext4-corrupted-inode-block-bitmaps-handling-patches-001.patch b/ldiskfs/kernel_patches/patches/ubuntu18/ext4-corrupted-inode-block-bitmaps-handling-patches-001.patch new file mode 100644 index 0000000..8eb7add --- /dev/null +++ b/ldiskfs/kernel_patches/patches/ubuntu18/ext4-corrupted-inode-block-bitmaps-handling-patches-001.patch @@ -0,0 +1,434 @@ +Since we could skip corrupt block groups, this patch +use ext4_warning() intead of ext4_error() to make FS not +emount RO in default, also fix a leftover from upstream +commit 163a203ddb36c36d4a1c942 + +Index: linux-4.15.0/fs/ext4/balloc.c +=================================================================== +--- linux-4.15.0.orig/fs/ext4/balloc.c ++++ linux-4.15.0/fs/ext4/balloc.c +@@ -185,25 +185,17 @@ static int ext4_init_block_bitmap(struct + struct ext4_sb_info *sbi = EXT4_SB(sb); + ext4_fsblk_t start, tmp; + int flex_bg = 0; +- struct ext4_group_info *grp; + + J_ASSERT_BH(bh, buffer_locked(bh)); + + /* If checksum is bad mark all blocks used to prevent allocation + * essentially implementing a per-group read-only flag. */ + if (!ext4_group_desc_csum_verify(sb, block_group, gdp)) { +- grp = ext4_get_group_info(sb, block_group); +- if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp)) +- percpu_counter_sub(&sbi->s_freeclusters_counter, +- grp->bb_free); +- set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state); +- if (!EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) { +- int count; +- count = ext4_free_inodes_count(sb, gdp); +- percpu_counter_sub(&sbi->s_freeinodes_counter, +- count); +- } +- set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state); ++ ext4_corrupted_block_group(sb, block_group, ++ EXT4_GROUP_INFO_BBITMAP_CORRUPT | ++ EXT4_GROUP_INFO_IBITMAP_CORRUPT, ++ "Checksum bad for group %u", ++ block_group); + return -EFSBADCRC; + } + memset(bh->b_data, 0, sb->s_blocksize); +@@ -369,7 +361,6 @@ static int ext4_validate_block_bitmap(st + { + ext4_fsblk_t blk; + struct ext4_group_info *grp = ext4_get_group_info(sb, block_group); +- struct ext4_sb_info *sbi = EXT4_SB(sb); + + if (buffer_verified(bh)) + return 0; +@@ -380,22 +371,19 @@ static int ext4_validate_block_bitmap(st + if (unlikely(!ext4_block_bitmap_csum_verify(sb, block_group, + desc, bh))) { + ext4_unlock_group(sb, block_group); +- ext4_error(sb, "bg %u: bad block bitmap checksum", block_group); +- if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp)) +- percpu_counter_sub(&sbi->s_freeclusters_counter, +- grp->bb_free); +- set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state); ++ ext4_corrupted_block_group(sb, block_group, ++ EXT4_GROUP_INFO_BBITMAP_CORRUPT, ++ "bg %u: bad block bitmap checksum", ++ block_group); + return -EFSBADCRC; + } + blk = ext4_valid_block_bitmap(sb, desc, block_group, bh); + if (unlikely(blk != 0)) { + ext4_unlock_group(sb, block_group); +- ext4_error(sb, "bg %u: block %llu: invalid block bitmap", +- block_group, blk); +- if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp)) +- percpu_counter_sub(&sbi->s_freeclusters_counter, +- grp->bb_free); +- set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state); ++ ext4_corrupted_block_group(sb, block_group, ++ EXT4_GROUP_INFO_BBITMAP_CORRUPT, ++ "bg %u: block %llu: invalid block bitmap", ++ block_group, blk); + return -EFSCORRUPTED; + } + set_buffer_verified(bh); +@@ -450,8 +438,6 @@ ext4_read_block_bitmap_nowait(struct sup + ext4_unlock_group(sb, block_group); + unlock_buffer(bh); + if (err) { +- ext4_error(sb, "Failed to init block bitmap for group " +- "%u: %d", block_group, err); + goto out; + } + goto verify; +Index: linux-4.15.0/fs/ext4/ext4.h +=================================================================== +--- linux-4.15.0.orig/fs/ext4/ext4.h ++++ linux-4.15.0/fs/ext4/ext4.h +@@ -101,6 +101,18 @@ typedef __u32 ext4_lblk_t; + /* data type for block group number */ + typedef unsigned int ext4_group_t; + ++void __ext4_corrupted_block_group(struct super_block *sb, ++ ext4_group_t group, unsigned int flags, ++ const char *function, unsigned int line); ++ ++#define ext4_corrupted_block_group(sb, group, flags, fmt, ...) \ ++ do { \ ++ __ext4_warning(sb, __func__, __LINE__, fmt, \ ++ ##__VA_ARGS__); \ ++ __ext4_corrupted_block_group(sb, group, flags, \ ++ __func__, __LINE__); \ ++ } while (0) ++ + enum SHIFT_DIRECTION { + SHIFT_LEFT = 0, + SHIFT_RIGHT, +@@ -3032,7 +3044,11 @@ struct ext4_group_info { + #define EXT4_GROUP_INFO_NEED_INIT_BIT 0 + #define EXT4_GROUP_INFO_WAS_TRIMMED_BIT 1 + #define EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT 2 ++#define EXT4_GROUP_INFO_BBITMAP_CORRUPT \ ++ (1 << EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT) + #define EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT 3 ++#define EXT4_GROUP_INFO_IBITMAP_CORRUPT \ ++ (1 << EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT) + + #define EXT4_MB_GRP_NEED_INIT(grp) \ + (test_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &((grp)->bb_state))) +Index: linux-4.15.0/fs/ext4/ialloc.c +=================================================================== +--- linux-4.15.0.orig/fs/ext4/ialloc.c ++++ linux-4.15.0/fs/ext4/ialloc.c +@@ -83,7 +83,6 @@ static int ext4_validate_inode_bitmap(st + { + ext4_fsblk_t blk; + struct ext4_group_info *grp = ext4_get_group_info(sb, block_group); +- struct ext4_sb_info *sbi = EXT4_SB(sb); + + if (buffer_verified(bh)) + return 0; +@@ -95,16 +94,10 @@ static int ext4_validate_inode_bitmap(st + if (!ext4_inode_bitmap_csum_verify(sb, block_group, desc, bh, + EXT4_INODES_PER_GROUP(sb) / 8)) { + ext4_unlock_group(sb, block_group); +- ext4_error(sb, "Corrupt inode bitmap - block_group = %u, " +- "inode_bitmap = %llu", block_group, blk); +- grp = ext4_get_group_info(sb, block_group); +- if (!EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) { +- int count; +- count = ext4_free_inodes_count(sb, desc); +- percpu_counter_sub(&sbi->s_freeinodes_counter, +- count); +- } +- set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state); ++ ext4_corrupted_block_group(sb, block_group, ++ EXT4_GROUP_INFO_IBITMAP_CORRUPT, ++ "Corrupt inode bitmap - block_group = %u, inode_bitmap = %llu", ++ block_group, blk); + return -EFSBADCRC; + } + set_buffer_verified(bh); +@@ -330,14 +323,9 @@ out: + if (!fatal) + fatal = err; + } else { +- ext4_error(sb, "bit already cleared for inode %lu", ino); +- if (gdp && !EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) { +- int count; +- count = ext4_free_inodes_count(sb, gdp); +- percpu_counter_sub(&sbi->s_freeinodes_counter, +- count); +- } +- set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state); ++ ext4_corrupted_block_group(sb, block_group, ++ EXT4_GROUP_INFO_IBITMAP_CORRUPT, ++ "bit already cleared for inode %lu", ino); + } + + error_return: +Index: linux-4.15.0/fs/ext4/mballoc.c +=================================================================== +--- linux-4.15.0.orig/fs/ext4/mballoc.c ++++ linux-4.15.0/fs/ext4/mballoc.c +@@ -751,10 +751,18 @@ int ext4_mb_generate_buddy(struct super_ + if (free != grp->bb_free) { + struct ext4_group_desc *gdp; + gdp = ext4_get_group_desc(sb, group, NULL); +- ext4_error(sb, "group %lu: %u blocks in bitmap, %u in bb, " +- "%u in gd, %lu pa's\n", (long unsigned int)group, +- free, grp->bb_free, ext4_free_group_clusters(sb, gdp), +- grp->bb_prealloc_nr); ++ ++ ext4_corrupted_block_group(sb, group, ++ EXT4_GROUP_INFO_BBITMAP_CORRUPT, ++ "group %lu: %u blocks in bitmap, %u in bb, %u in gd, %lu pa's block bitmap corrupt", ++ (unsigned long int)group, free, grp->bb_free, ++ ext4_free_group_clusters(sb, gdp), ++ grp->bb_prealloc_nr); ++ /* ++ * If we intend to continue, we consider group descriptor ++ * corrupt and update bb_free using bitmap value ++ */ ++ grp->bb_free = free; + return -EIO; + } + mb_set_largest_free_order(sb, grp); +@@ -1110,7 +1118,7 @@ ext4_mb_load_buddy_gfp(struct super_bloc + int block; + int pnum; + int poff; +- struct page *page; ++ struct page *page = NULL; + int ret; + struct ext4_group_info *grp; + struct ext4_sb_info *sbi = EXT4_SB(sb); +@@ -1136,7 +1144,7 @@ ext4_mb_load_buddy_gfp(struct super_bloc + */ + ret = ext4_mb_init_group(sb, group, gfp); + if (ret) +- return ret; ++ goto err; + } + + /* +@@ -1239,6 +1247,7 @@ err: + put_page(e4b->bd_buddy_page); + e4b->bd_buddy = NULL; + e4b->bd_bitmap = NULL; ++ ext4_warning(sb, "Error loading buddy information for %u", group); + return ret; + } + +@@ -3689,9 +3698,11 @@ int ext4_mb_check_ondisk_bitmap(struct s + } + + if (free != free_in_gdp) { +- ext4_error(sb, "on-disk bitmap for group %d" +- "corrupted: %u blocks free in bitmap, %u - in gd\n", +- group, free, free_in_gdp); ++ ext4_corrupted_block_group(sb, group, ++ EXT4_GROUP_INFO_BBITMAP_CORRUPT, ++ "on-disk bitmap for group %d corrupted: %u blocks free in bitmap, %u - in gd\n", ++ group, free, ++ free_in_gdp); + return -EIO; + } + return 0; +@@ -4052,16 +4063,8 @@ ext4_mb_release_inode_pa(struct ext4_bud + /* "free < pa->pa_free" means we maybe double alloc the same blocks, + * otherwise maybe leave some free blocks unavailable, no need to BUG.*/ + if ((free > pa->pa_free && !pa->pa_error) || (free < pa->pa_free)) { +- ext4_error(sb, "pa free mismatch: [pa %p] " +- "[phy %lu] [logic %lu] [len %u] [free %u] " +- "[error %u] [inode %lu] [freed %u]", pa, +- (unsigned long)pa->pa_pstart, +- (unsigned long)pa->pa_lstart, +- (unsigned)pa->pa_len, (unsigned)pa->pa_free, +- (unsigned)pa->pa_error, pa->pa_inode->i_ino, +- free); + ext4_grp_locked_error(sb, group, 0, 0, "free %u, pa_free %u", +- free, pa->pa_free); ++ free, pa->pa_free); + /* + * pa is already deleted so we use the value obtained + * from the bitmap and continue. +@@ -4123,15 +4126,11 @@ ext4_mb_discard_group_preallocations(str + bitmap_bh = ext4_read_block_bitmap(sb, group); + if (IS_ERR(bitmap_bh)) { + err = PTR_ERR(bitmap_bh); +- ext4_error(sb, "Error %d reading block bitmap for %u", +- err, group); + return 0; + } + + err = ext4_mb_load_buddy(sb, group, &e4b); + if (err) { +- ext4_warning(sb, "Error %d loading buddy information for %u", +- err, group); + put_bh(bitmap_bh); + return 0; + } +@@ -4292,17 +4291,12 @@ repeat: + + err = ext4_mb_load_buddy_gfp(sb, group, &e4b, + GFP_NOFS|__GFP_NOFAIL); +- if (err) { +- ext4_error(sb, "Error %d loading buddy information for %u", +- err, group); ++ if (err) + return; +- } + + bitmap_bh = ext4_read_block_bitmap(sb, group); + if (IS_ERR(bitmap_bh)) { + err = PTR_ERR(bitmap_bh); +- ext4_error(sb, "Error %d reading block bitmap for %u", +- err, group); + ext4_mb_unload_buddy(&e4b); + continue; + } +@@ -4565,11 +4559,8 @@ ext4_mb_discard_lg_preallocations(struct + group = ext4_get_group_number(sb, pa->pa_pstart); + err = ext4_mb_load_buddy_gfp(sb, group, &e4b, + GFP_NOFS|__GFP_NOFAIL); +- if (err) { +- ext4_error(sb, "Error %d loading buddy information for %u", +- err, group); ++ if (err) + continue; +- } + ext4_lock_group(sb, group); + list_del(&pa->pa_group_list); + ext4_get_group_info(sb, group)->bb_prealloc_nr--; +@@ -4822,17 +4813,18 @@ errout: + * been updated or not when fail case. So can + * not revert pa_free back, just mark pa_error*/ + pa->pa_error++; +- ext4_error(sb, +- "Updating bitmap error: [err %d] " +- "[pa %p] [phy %lu] [logic %lu] " +- "[len %u] [free %u] [error %u] " +- "[inode %lu]", *errp, pa, +- (unsigned long)pa->pa_pstart, +- (unsigned long)pa->pa_lstart, +- (unsigned)pa->pa_len, +- (unsigned)pa->pa_free, +- (unsigned)pa->pa_error, +- pa->pa_inode ? pa->pa_inode->i_ino : 0); ++ ext4_corrupted_block_group(sb, 0, 0, ++ "Updating bitmap error: [err %d] " ++ "[pa %p] [phy %lu] [logic %lu] " ++ "[len %u] [free %u] [error %u] " ++ "[inode %lu]", *errp, pa, ++ (unsigned long)pa->pa_pstart, ++ (unsigned long)pa->pa_lstart, ++ (unsigned)pa->pa_len, ++ (unsigned)pa->pa_free, ++ (unsigned)pa->pa_error, ++ pa->pa_inode ? ++ pa->pa_inode->i_ino : 0); + } + } + ext4_mb_release_context(ac); +@@ -5118,7 +5110,7 @@ do_more: + err = ext4_mb_load_buddy_gfp(sb, block_group, &e4b, + GFP_NOFS|__GFP_NOFAIL); + if (err) +- goto error_return; ++ goto error_brelse; + + /* + * We need to make sure we don't reuse the freed block until after the +@@ -5200,8 +5192,9 @@ do_more: + goto do_more; + } + error_return: +- brelse(bitmap_bh); + ext4_std_error(sb, err); ++error_brelse: ++ brelse(bitmap_bh); + return; + } + +@@ -5301,7 +5294,7 @@ int ext4_group_add_blocks(handle_t *hand + + err = ext4_mb_load_buddy(sb, block_group, &e4b); + if (err) +- goto error_return; ++ goto error_brelse; + + /* + * need to update group_info->bb_free and bitmap +@@ -5339,8 +5332,9 @@ int ext4_group_add_blocks(handle_t *hand + err = ret; + + error_return: +- brelse(bitmap_bh); + ext4_std_error(sb, err); ++error_brelse: ++ brelse(bitmap_bh); + return err; + } + +@@ -5415,11 +5409,9 @@ ext4_trim_all_free(struct super_block *s + trace_ext4_trim_all_free(sb, group, start, max); + + ret = ext4_mb_load_buddy(sb, group, &e4b); +- if (ret) { +- ext4_warning(sb, "Error %d loading buddy information for %u", +- ret, group); ++ if (ret) + return ret; +- } ++ + bitmap = e4b.bd_bitmap; + + ext4_lock_group(sb, group); +Index: linux-4.15.0/fs/ext4/super.c +=================================================================== +--- linux-4.15.0.orig/fs/ext4/super.c ++++ linux-4.15.0/fs/ext4/super.c +@@ -708,6 +708,37 @@ void __ext4_warning_inode(const struct i + va_end(args); + } + ++void __ext4_corrupted_block_group(struct super_block *sb, ext4_group_t group, ++ unsigned int flags, const char *function, ++ unsigned int line) ++{ ++ struct ext4_sb_info *sbi = EXT4_SB(sb); ++ struct ext4_group_info *grp = ext4_get_group_info(sb, group); ++ struct ext4_group_desc *gdp = ext4_get_group_desc(sb, group, NULL); ++ ++ if (flags & EXT4_GROUP_INFO_BBITMAP_CORRUPT && ++ !EXT4_MB_GRP_BBITMAP_CORRUPT(grp)) { ++ percpu_counter_sub(&sbi->s_freeclusters_counter, ++ grp->bb_free); ++ set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, ++ &grp->bb_state); ++ } ++ ++ if (flags & EXT4_GROUP_INFO_IBITMAP_CORRUPT && ++ !EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) { ++ if (gdp) { ++ int count; ++ ++ count = ext4_free_inodes_count(sb, gdp); ++ percpu_counter_sub(&sbi->s_freeinodes_counter, ++ count); ++ } ++ set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, ++ &grp->bb_state); ++ } ++ save_error_info(sb, function, line); ++} ++ + void __ext4_grp_locked_error(const char *function, unsigned int line, + struct super_block *sb, ext4_group_t grp, + unsigned long ino, ext4_fsblk_t block, diff --git a/ldiskfs/kernel_patches/series/ldiskfs-4.15.0-24-ubuntu18.series b/ldiskfs/kernel_patches/series/ldiskfs-4.15.0-24-ubuntu18.series new file mode 100644 index 0000000..ebb7a12 --- /dev/null +++ b/ldiskfs/kernel_patches/series/ldiskfs-4.15.0-24-ubuntu18.series @@ -0,0 +1,23 @@ +sles12sp2/ext4-inode-version.patch +sles12sp2/ext4-lookup-dotdot.patch +sles12sp2/ext4-print-inum-in-htree-warning.patch +sles12sp2/ext4-prealloc.patch +ubuntu18/ext4-osd-iop-common.patch +ubuntu18/ext4-misc.patch +ubuntu18/ext4-mballoc-extra-checks.patch +ubuntu18/ext4-hash-indexed-dir-dotdot-update.patch +ubuntu18/ext4-kill-dx-root.patch +rhel7/ext4-mballoc-pa-free-mismatch.patch +ubuntu18/ext4-data-in-dirent.patch +ubuntu18/ext4-nocmtime.patch +ubuntu18/ext4-pdirop.patch +sles12sp2/ext4-max-dir-size.patch +ubuntu18/ext4-remove-truncate-warning.patch +ubuntu18/ext4-corrupted-inode-block-bitmaps-handling-patches-001.patch +ubuntu18/ext4-give-warning-with-dir-htree-growing.patch +ubuntu18/ext4-jcb-optimization.patch +ubuntu18/ext4-attach-jinode-in-writepages.patch +ubuntu18/ext4-dont-check-before-replay.patch +rhel7/ext4-use-GFP_NOFS-in-ext4_inode_attach_jinode.patch +rhel7/ext4-export-orphan-add.patch +rhel7/ext4-mmp-dont-mark-bh-dirty.patch