From e27a7b33d6351ff8b8bae101079af88f4eedac99 Mon Sep 17 00:00:00 2001 From: Vitaliy Kuznetsov Date: Tue, 11 Jul 2023 14:12:25 +0600 Subject: [PATCH] LU-16298 ldiskfs: Periodically write ldiskfs superblock This patch introduces a mechanism to periodically check and update the superblock within the ext4 file system. The main purpose of this patch is to keep the disk superblock up to date. The update will be performed if more than one hour has passed since the last update, and if more than 16MB of data have been written to disk. This check and update is performed within the ext4_journal_commit_callback function, ensuring that the superblock is written while the disk is active, rather than based on a timer that may trigger during disk idle periods. Signed-off-by: Vitaliy Kuznetsov Change-Id: I06eb9624b663a6ca6b15c6af2373b82f1bb63de6 Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/51340 Tested-by: jenkins Tested-by: Maloo Reviewed-by: Andreas Dilger Reviewed-by: Alex Zhuravlev Reviewed-by: Oleg Drokin --- .../ext4-add-periodic-superblock-update.patch | 304 +++++++++++++++++++++ .../ext4-add-periodic-superblock-update.patch | 110 ++++++++ .../series/ldiskfs-4.18-rhel8.1.series | 1 + .../series/ldiskfs-4.18-rhel8.2.series | 1 + .../series/ldiskfs-4.18-rhel8.3.series | 1 + .../series/ldiskfs-4.18-rhel8.4.series | 1 + .../series/ldiskfs-4.18-rhel8.5.series | 1 + .../series/ldiskfs-4.18-rhel8.6.series | 1 + .../series/ldiskfs-4.18-rhel8.7.series | 1 + .../series/ldiskfs-4.18-rhel8.8.series | 1 + .../series/ldiskfs-4.18-rhel8.series | 1 + .../series/ldiskfs-5.11.0-40-ubuntu20.series | 1 + .../series/ldiskfs-5.14-rhel9.1.series | 1 + .../series/ldiskfs-5.14-rhel9.2.series | 1 + .../series/ldiskfs-5.14-rhel9.series | 1 + .../series/ldiskfs-5.14.21-sles15sp4.series | 1 + .../series/ldiskfs-5.14.21-sles15sp5.series | 1 + 17 files changed, 429 insertions(+) create mode 100644 ldiskfs/kernel_patches/patches/rhel8/ext4-add-periodic-superblock-update.patch create mode 100644 ldiskfs/kernel_patches/patches/rhel9/ext4-add-periodic-superblock-update.patch diff --git a/ldiskfs/kernel_patches/patches/rhel8/ext4-add-periodic-superblock-update.patch b/ldiskfs/kernel_patches/patches/rhel8/ext4-add-periodic-superblock-update.patch new file mode 100644 index 0000000..bbdad7a --- /dev/null +++ b/ldiskfs/kernel_patches/patches/rhel8/ext4-add-periodic-superblock-update.patch @@ -0,0 +1,304 @@ +From 332f8696f462ae8affc0a44494423e4edd88bb29 Mon Sep 17 00:00:00 2001 +From: "Vitaliy Kuznetsov" +Date: Thu, 15 Jun 2023 11:17:14 +0300 +Subject: [PATCH] ext4: Add periodic superblock update check + +This patch introduces a mechanism to periodically check and update +the superblock within the ext4 file system. The main purpose of this +patch is to keep the disk superblock up to date. The update will be +performed if more than one hour has passed since the last update, and +if more than 16MB of data have been written to disk. + +This check and update is performed within the ext4_journal_commit_callback +function, ensuring that the superblock is written while the disk is +active, rather than based on a timer that may trigger during disk idle +periods. + +Signed-off-by: Vitaliy Kuznetsov +--- + fs/ext4/ext4.h | 1 + + fs/ext4/super.c | 186 +++++++++++++++++++++++++++++++++++++----------- + 2 files changed, 146 insertions(+), 41 deletions(-) + +diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h +index 7c7123f265c2..44f69f5c6931 100644 +--- a/fs/ext4/ext4.h ++++ b/fs/ext4/ext4.h +@@ -1446,6 +1446,7 @@ struct ext4_sb_info { + /* for write statistics */ + unsigned long s_sectors_written_start; + u64 s_kbytes_written; ++ struct work_struct s_stats_work; + + /* the size of zero-out chunk */ + unsigned int s_extent_max_zeroout_kb; +diff --git a/fs/ext4/super.c b/fs/ext4/super.c +index 10c45b3b7910..9d6e8b48f775 100644 +--- a/fs/ext4/super.c ++++ b/fs/ext4/super.c +@@ -64,6 +64,7 @@ static struct ratelimit_state ext4_mount_msg_ratelimit; + static int ext4_load_journal(struct super_block *, struct ext4_super_block *, + unsigned long journal_devnum); + static int ext4_show_options(struct seq_file *seq, struct dentry *root); ++static void ext4_update_super(struct super_block *sb, int sync); + static int ext4_commit_super(struct super_block *sb, int sync); + static void ext4_mark_recovery_complete(struct super_block *sb, + struct ext4_super_block *es); +@@ -469,6 +470,90 @@ static int block_device_ejected(struct super_block *sb) + return bdi->dev == NULL; + } + ++static void flush_stashed_stats_work(struct work_struct *work) ++{ ++ struct ext4_sb_info *sbi = container_of(work, struct ext4_sb_info, ++ s_stats_work); ++ journal_t *journal = sbi->s_journal; ++ struct buffer_head *sbh = sbi->s_sbh; ++ handle_t *handle; ++ ++ /* ++ * If the journal is still running, we have to write out superblock ++ * through the journal to avoid collisions of other journalled sb ++ * updates. ++ */ ++ if (sb_rdonly(sbi->s_sb) && !journal) ++ return; ++ ++ handle = jbd2_journal_start(journal, 1); ++ if (IS_ERR(handle)) ++ return; ++ ++ if (jbd2_journal_get_write_access(handle, sbh)) { ++ jbd2_journal_stop(handle); ++ return; ++ } ++ ++ ext4_update_super(sbi->s_sb, 1); ++ jbd2_journal_dirty_metadata(handle, sbh); ++ jbd2_journal_stop(handle); ++ return; ++} ++ ++#define EXT4_SB_REFRESH_INTERVAL_SEC (3600) /* seconds (1 hour) */ ++#define EXT4_SB_REFRESH_INTERVAL_KB (16384) /* kilobytes (16MB) */ ++ ++/* ++ * The ext4_maybe_update_superblock() function checks and updates the ++ * superblock if needed. ++ * ++ * This function is designed to update the on-disk superblock only under ++ * certain conditions to prevent excessive disk writes and unnecessary ++ * waking of the disk from sleep. The superblock will be updated if: ++ * 1. More than an hour has passed since the last superblock update, and ++ * 2. More than 16MB have been written since the last superblock update. ++ * ++ * @sb: The superblock ++ */ ++static void ext4_maybe_update_superblock(struct super_block *sb) ++{ ++ struct ext4_sb_info *sbi = EXT4_SB(sb); ++ struct ext4_super_block *es = sbi->s_es; ++ time64_t now; ++ __u64 last_update; ++ __u64 lifetime_write_kbytes; ++ __u64 diff_size; ++ ++ if (sb_rdonly(sb)) ++ return; ++ ++ now = ktime_get_real_seconds(); ++ last_update = ext4_get_tstamp(es, s_wtime); ++ ++ if (likely(now - last_update < EXT4_SB_REFRESH_INTERVAL_SEC)) ++ return; ++ ++ lifetime_write_kbytes = sbi->s_kbytes_written; ++ if (likely(sb->s_bdev->bd_part)) ++ lifetime_write_kbytes = sbi->s_kbytes_written + ++ ((part_stat_read(sb->s_bdev->bd_part, sectors[STAT_WRITE]) - ++ sbi->s_sectors_written_start) >> 1); ++ ++ ++ /* Get the number of kilobytes not written to disk to account ++ * for statistics and compare with a multiple of 16 MB. This ++ * is used to determine when the next superblock commit should ++ * occur (i.e. not more often than once per 16MB if there was ++ * less written in an hour). ++ */ ++ diff_size = lifetime_write_kbytes - ++ le64_to_cpu(es->s_kbytes_written); ++ ++ if (diff_size > EXT4_SB_REFRESH_INTERVAL_KB) ++ schedule_work(&EXT4_SB(sb)->s_stats_work); ++} ++ + static void ext4_journal_commit_callback(journal_t *journal, transaction_t *txn) + { + struct super_block *sb = journal->j_private; +@@ -479,7 +564,7 @@ static void ext4_journal_commit_callback(journal_t *journal, transaction_t *txn) + BUG_ON(txn->t_state == T_FINISHED); + + ext4_process_freed_data(sb, txn->t_tid); +- ++ ext4_maybe_update_superblock(sb); + spin_lock(&sbi->s_md_lock); + while (!list_empty(&txn->t_private_list)) { + jce = list_entry(txn->t_private_list.next, +@@ -1023,6 +1108,7 @@ static void ext4_put_super(struct super_block *sb) + + ext4_unregister_li_request(sb); + ext4_quota_off_umount(sb); ++ flush_work(&sbi->s_stats_work); + + destroy_workqueue(sbi->rsv_conversion_wq); + +@@ -4373,6 +4459,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) + } + + timer_setup(&sbi->s_err_report, print_daily_error_info, 0); ++ INIT_WORK(&sbi->s_stats_work, flush_stashed_stats_work); + + /* Register extent status tree shrinker */ + if (ext4_es_register_shrinker(sbi)) +@@ -4985,6 +5072,53 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb, + return NULL; + } + ++static void ext4_update_super(struct super_block *sb, int sync) ++{ ++ struct ext4_super_block *es = EXT4_SB(sb)->s_es; ++ struct buffer_head *sbh = EXT4_SB(sb)->s_sbh; ++ if (sync) ++ lock_buffer(sbh); ++ ++ /* ++ * If the file system is mounted read-only, don't update the ++ * superblock write time. This avoids updating the superblock ++ * write time when we are mounting the root file system ++ * read/only but we need to replay the journal; at that point, ++ * for people who are east of GMT and who make their clock ++ * tick in localtime for Windows bug-for-bug compatibility, ++ * the clock is set in the future, and this will cause e2fsck ++ * to complain and force a full file system check. ++ */ ++ if (!(sb->s_flags & SB_RDONLY)) ++ ext4_update_tstamp(es, s_wtime); ++ ++ if (sb->s_bdev->bd_part) { ++ es->s_kbytes_written = ++ cpu_to_le64(EXT4_SB(sb)->s_kbytes_written + ++ ((part_stat_read(sb->s_bdev->bd_part, ++ sectors[STAT_WRITE]) - ++ EXT4_SB(sb)->s_sectors_written_start) >> 1)); ++ } else { ++ es->s_kbytes_written = ++ cpu_to_le64(EXT4_SB(sb)->s_kbytes_written); ++ } ++ ++ if (percpu_counter_initialized(&EXT4_SB(sb)->s_freeclusters_counter)) { ++ ext4_free_blocks_count_set(es, ++ EXT4_C2B(EXT4_SB(sb), percpu_counter_sum_positive( ++ &EXT4_SB(sb)->s_freeclusters_counter))); ++ } ++ ++ if (percpu_counter_initialized(&EXT4_SB(sb)->s_freeinodes_counter)) { ++ es->s_free_inodes_count = ++ cpu_to_le32(percpu_counter_sum_positive( ++ &EXT4_SB(sb)->s_freeinodes_counter)); ++ } ++ ++ if (sync) ++ unlock_buffer(sbh); ++} ++ + static int ext4_load_journal(struct super_block *sb, + struct ext4_super_block *es, + unsigned long journal_devnum) +@@ -5095,7 +5229,6 @@ static int ext4_load_journal(struct super_block *sb, + + static int ext4_commit_super(struct super_block *sb, int sync) + { +- struct ext4_super_block *es = EXT4_SB(sb)->s_es; + struct buffer_head *sbh = EXT4_SB(sb)->s_sbh; + int error = 0; + +@@ -5109,41 +5242,9 @@ static int ext4_commit_super(struct super_block *sb, int sync) + * device was hot-removed. Not much we can do but fail the I/O. + */ + if (!buffer_mapped(sbh)) +- return error; ++ return -EIO; + +- /* +- * If the file system is mounted read-only, don't update the +- * superblock write time. This avoids updating the superblock +- * write time when we are mounting the root file system +- * read/only but we need to replay the journal; at that point, +- * for people who are east of GMT and who make their clock +- * tick in localtime for Windows bug-for-bug compatibility, +- * the clock is set in the future, and this will cause e2fsck +- * to complain and force a full file system check. +- */ +- if (!(sb->s_flags & SB_RDONLY)) +- ext4_update_tstamp(es, s_wtime); +- if (sb->s_bdev->bd_part) +- es->s_kbytes_written = +- cpu_to_le64(EXT4_SB(sb)->s_kbytes_written + +- ((part_stat_read(sb->s_bdev->bd_part, +- sectors[STAT_WRITE]) - +- EXT4_SB(sb)->s_sectors_written_start) >> 1)); +- else +- es->s_kbytes_written = +- cpu_to_le64(EXT4_SB(sb)->s_kbytes_written); +- if (percpu_counter_initialized(&EXT4_SB(sb)->s_freeclusters_counter)) +- ext4_free_blocks_count_set(es, +- EXT4_C2B(EXT4_SB(sb), percpu_counter_sum_positive( +- &EXT4_SB(sb)->s_freeclusters_counter))); +- if (percpu_counter_initialized(&EXT4_SB(sb)->s_freeinodes_counter)) +- es->s_free_inodes_count = +- cpu_to_le32(percpu_counter_sum_positive( +- &EXT4_SB(sb)->s_freeinodes_counter)); +- BUFFER_TRACE(sbh, "marking dirty"); +- ext4_superblock_csum_set(sb); +- if (sync) +- lock_buffer(sbh); ++ ext4_update_super(sb, sync); + if (buffer_write_io_error(sbh) || !buffer_uptodate(sbh)) { + /* + * Oh, dear. A previous attempt to write the +@@ -5153,19 +5254,19 @@ static int ext4_commit_super(struct super_block *sb, int sync) + * be remapped. Nothing we can do but to retry the + * write and hope for the best. + */ +- ext4_msg(sb, KERN_ERR, "previous I/O error to " +- "superblock detected"); ++ ext4_msg(sb, KERN_ERR, ++ "previous I/O error to superblock detected"); + clear_buffer_write_io_error(sbh); + set_buffer_uptodate(sbh); + } ++ BUFFER_TRACE(sbh, "marking dirty"); + mark_buffer_dirty(sbh); + if (sync) { +- unlock_buffer(sbh); + error = __sync_dirty_buffer(sbh, + REQ_SYNC | (test_opt(sb, BARRIER) ? REQ_FUA : 0)); + if (buffer_write_io_error(sbh)) { +- ext4_msg(sb, KERN_ERR, "I/O error while writing " +- "superblock"); ++ ext4_msg(sb, KERN_ERR, ++ "I/O error while writing superblock"); + clear_buffer_write_io_error(sbh); + set_buffer_uptodate(sbh); + } +@@ -5483,6 +5584,9 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) + set_task_ioprio(sbi->s_journal->j_task, journal_ioprio); + } + ++ /* Flush stats before changing fs state */ ++ flush_work(&sbi->s_stats_work); ++ + if ((bool)(*flags & SB_RDONLY) != sb_rdonly(sb)) { + if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED) { + err = -EROFS; +-- diff --git a/ldiskfs/kernel_patches/patches/rhel9/ext4-add-periodic-superblock-update.patch b/ldiskfs/kernel_patches/patches/rhel9/ext4-add-periodic-superblock-update.patch new file mode 100644 index 0000000..19ff1a1 --- /dev/null +++ b/ldiskfs/kernel_patches/patches/rhel9/ext4-add-periodic-superblock-update.patch @@ -0,0 +1,110 @@ +From 45c922115d9e44c0d62fd2012ccb4d020bbe8edc Mon Sep 17 00:00:00 2001 +From: "Vitaliy Kuznetsov" +Date: Thu, 15 Jun 2023 11:17:14 +0300 +Subject: [PATCH] ext4: Add periodic superblock update check + +This patch introduces a mechanism to periodically check and update +the superblock within the ext4 file system. The main purpose of this +patch is to keep the disk superblock up to date. The update will be +performed if more than one hour has passed since the last update, and +if more than 16MB of data have been written to disk. + +This check and update is performed within the ext4_journal_commit_callback +function, ensuring that the superblock is written while the disk is +active, rather than based on a timer that may trigger during disk idle +periods. + +Signed-off-by: Vitaliy Kuznetsov +--- + fs/ext4/super.c | 50 +++++++++++++++++++++++++++++++++++++++++++++++++ + fs/ext4/sysfs.c | 4 ++-- + 2 files changed, 52 insertions(+), 2 deletions(-) + +diff --git a/fs/ext4/super.c b/fs/ext4/super.c +index dfa09a277b56..0d2bf85cee34 100644 +--- a/fs/ext4/super.c ++++ b/fs/ext4/super.c +@@ -439,6 +439,55 @@ static int block_device_ejected(struct super_block *sb) + return bdi->dev == NULL; + } + ++#define EXT4_SB_REFRESH_INTERVAL_SEC (3600) /* seconds (1 hour) */ ++#define EXT4_SB_REFRESH_INTERVAL_KB (16384) /* kilobytes (16MB) */ ++ ++/* ++ * The ext4_maybe_update_superblock() function checks and updates the ++ * superblock if needed. ++ * ++ * This function is designed to update the on-disk superblock only under ++ * certain conditions to prevent excessive disk writes and unnecessary ++ * waking of the disk from sleep. The superblock will be updated if: ++ * 1. More than an hour has passed since the last superblock update, and ++ * 2. More than 16MB have been written since the last superblock update. ++ * ++ * @sb: The superblock ++ */ ++static void ext4_maybe_update_superblock(struct super_block *sb) ++{ ++ struct ext4_sb_info *sbi = EXT4_SB(sb); ++ struct ext4_super_block *es = sbi->s_es; ++ time64_t now; ++ __u64 last_update; ++ __u64 lifetime_write_kbytes; ++ __u64 diff_size; ++ ++ if (sb_rdonly(sb)) ++ return; ++ ++ now = ktime_get_real_seconds(); ++ last_update = ext4_get_tstamp(es, s_wtime); ++ ++ if (likely(now - last_update < EXT4_SB_REFRESH_INTERVAL_SEC)) ++ return; ++ ++ lifetime_write_kbytes = sbi->s_kbytes_written + ++ ((part_stat_read(sb->s_bdev, sectors[STAT_WRITE]) - ++ sbi->s_sectors_written_start) >> 1); ++ ++ /* Get the number of kilobytes not written to disk to account ++ * for statistics and compare with a multiple of 16 MB. This ++ * is used to determine when the next superblock commit should ++ * occur (i.e. not more often than once per 16MB if there was ++ * less written in an hour). ++ */ ++ diff_size = lifetime_write_kbytes - le64_to_cpu(es->s_kbytes_written); ++ ++ if (diff_size > EXT4_SB_REFRESH_INTERVAL_KB) ++ schedule_work(&EXT4_SB(sb)->s_error_work); ++} ++ + static void ext4_journal_commit_callback(journal_t *journal, transaction_t *txn) + { + struct super_block *sb = journal->j_private; +@@ -449,6 +498,7 @@ static void ext4_journal_commit_callback(journal_t *journal, transaction_t *txn) + BUG_ON(txn->t_state == T_FINISHED); + + ext4_process_freed_data(sb, txn->t_tid); ++ ext4_maybe_update_superblock(sb); + + spin_lock(&sbi->s_md_lock); + while (!list_empty(&txn->t_private_list)) { +diff --git a/fs/ext4/sysfs.c b/fs/ext4/sysfs.c +index 2314f7446592..a7219cc2fdc5 100644 +--- a/fs/ext4/sysfs.c ++++ b/fs/ext4/sysfs.c +@@ -508,7 +508,8 @@ static struct kobj_type ext4_feat_ktype = { + + void ext4_notify_error_sysfs(struct ext4_sb_info *sbi) + { +- sysfs_notify(&sbi->s_kobj, NULL, "errors_count"); ++ if (sbi->s_add_error_count > 0) ++ sysfs_notify(&sbi->s_kobj, NULL, "errors_count"); + } + + static struct kobject *ext4_root; +@@ -598,4 +599,3 @@ void ext4_exit_sysfs(void) + remove_proc_entry(proc_dirname, NULL); + ext4_proc_root = NULL; + } +- +-- diff --git a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.1.series b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.1.series index 12ffab2..4ad9d24 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.1.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.1.series @@ -30,5 +30,6 @@ rhel8/ext4-ialloc-uid-gid-and-pass-owner-down.patch base/ext4-projid-xattrs.patch rhel8/linux-5.4/ext4-enc-flag.patch base/ext4-delayed-iput.patch +rhel8/ext4-add-periodic-superblock-update.patch rhel8/ext4-filename-encode.patch rhel8/ext4-encdata.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.2.series b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.2.series index bb95965..74fb768 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.2.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.2.series @@ -30,6 +30,7 @@ rhel8/ext4-ialloc-uid-gid-and-pass-owner-down.patch base/ext4-projid-xattrs.patch rhel8/ext4-enc-flag.patch base/ext4-delayed-iput.patch +rhel8/ext4-add-periodic-superblock-update.patch rhel8/ext4-filename-encode.patch rhel8/ext4-encdata.patch rhel8.5/ext4-limit-per-inode-preallocation-list.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.3.series b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.3.series index 7f10f1b..53d528f 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.3.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.3.series @@ -30,6 +30,7 @@ rhel8/ext4-ialloc-uid-gid-and-pass-owner-down.patch base/ext4-projid-xattrs.patch rhel8/ext4-enc-flag.patch base/ext4-delayed-iput.patch +rhel8/ext4-add-periodic-superblock-update.patch rhel8/ext4-filename-encode.patch rhel8/ext4-encdata.patch rhel8.5/ext4-limit-per-inode-preallocation-list.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.4.series b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.4.series index b96f82e..a1d6943 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.4.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.4.series @@ -30,6 +30,7 @@ rhel8/ext4-ialloc-uid-gid-and-pass-owner-down.patch base/ext4-projid-xattrs.patch rhel8.4/ext4-enc-flag.patch base/ext4-delayed-iput.patch +rhel8/ext4-add-periodic-superblock-update.patch rhel8.5/ext4-filename-encode.patch rhel8/ext4-old_ea_inodes_handling_fix.patch rhel8.4/ext4-optimize-find_delayed_extent.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.5.series b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.5.series index 4fedc53..62fc701 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.5.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.5.series @@ -30,6 +30,7 @@ rhel8/ext4-ialloc-uid-gid-and-pass-owner-down.patch base/ext4-projid-xattrs.patch rhel8.5/ext4-enc-flag.patch base/ext4-delayed-iput.patch +rhel8/ext4-add-periodic-superblock-update.patch rhel8.5/ext4-filename-encode.patch rhel8/ext4-old_ea_inodes_handling_fix.patch rhel8.4/ext4-optimize-find_delayed_extent.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.6.series b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.6.series index 4fedc53..62fc701 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.6.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.6.series @@ -30,6 +30,7 @@ rhel8/ext4-ialloc-uid-gid-and-pass-owner-down.patch base/ext4-projid-xattrs.patch rhel8.5/ext4-enc-flag.patch base/ext4-delayed-iput.patch +rhel8/ext4-add-periodic-superblock-update.patch rhel8.5/ext4-filename-encode.patch rhel8/ext4-old_ea_inodes_handling_fix.patch rhel8.4/ext4-optimize-find_delayed_extent.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.7.series b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.7.series index 81a71e3..f6b817d 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.7.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.7.series @@ -31,6 +31,7 @@ rhel8/ext4-ialloc-uid-gid-and-pass-owner-down.patch base/ext4-projid-xattrs.patch rhel8.5/ext4-enc-flag.patch base/ext4-delayed-iput.patch +rhel8/ext4-add-periodic-superblock-update.patch rhel8.7/ext4-filename-encode.patch rhel8/ext4-old_ea_inodes_handling_fix.patch rhel8.4/ext4-optimize-find_delayed_extent.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.8.series b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.8.series index a47ca55..0a8fb74 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.8.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.8.series @@ -31,6 +31,7 @@ rhel8/ext4-ialloc-uid-gid-and-pass-owner-down.patch base/ext4-projid-xattrs.patch rhel8.5/ext4-enc-flag.patch base/ext4-delayed-iput.patch +rhel8/ext4-add-periodic-superblock-update.patch rhel8.7/ext4-filename-encode.patch rhel8/ext4-old_ea_inodes_handling_fix.patch rhel8.4/ext4-optimize-find_delayed_extent.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.series b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.series index ce4eac9..ac898d2 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.series @@ -32,5 +32,6 @@ rhel8/ext4-ialloc-uid-gid-and-pass-owner-down.patch ubuntu18/ext4-projid-xattrs.patch rhel8/ext4-enc-flag.patch base/ext4-delayed-iput.patch +rhel8/ext4-add-periodic-superblock-update.patch rhel8/ext4-filename-encode.patch rhel8/ext4-encdata.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-5.11.0-40-ubuntu20.series b/ldiskfs/kernel_patches/series/ldiskfs-5.11.0-40-ubuntu20.series index f89b93c..68a0f09 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-5.11.0-40-ubuntu20.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-5.11.0-40-ubuntu20.series @@ -33,3 +33,4 @@ base/ext4-delayed-iput.patch linux-5.10/ext4-fiemap-kernel-data.patch rhel8/ext4-old_ea_inodes_handling_fix.patch rhel8/ext4-encdata.patch +rhel9/ext4-add-periodic-superblock-update.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-5.14-rhel9.1.series b/ldiskfs/kernel_patches/series/ldiskfs-5.14-rhel9.1.series index 1b90b80..4fab615 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-5.14-rhel9.1.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-5.14-rhel9.1.series @@ -32,3 +32,4 @@ linux-5.14/ext4-xattr-disable-credits-check.patch linux-5.10/ext4-fiemap-kernel-data.patch rhel8/ext4-old_ea_inodes_handling_fix.patch rhel9.1/ext4-enc-flag.patch +rhel9/ext4-add-periodic-superblock-update.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-5.14-rhel9.2.series b/ldiskfs/kernel_patches/series/ldiskfs-5.14-rhel9.2.series index 455361d..b9623e6 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-5.14-rhel9.2.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-5.14-rhel9.2.series @@ -32,3 +32,4 @@ linux-5.14/ext4-xattr-disable-credits-check.patch rhel9.2/ext4-fiemap-kernel-data.patch rhel8/ext4-old_ea_inodes_handling_fix.patch rhel9.1/ext4-enc-flag.patch +rhel9/ext4-add-periodic-superblock-update.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-5.14-rhel9.series b/ldiskfs/kernel_patches/series/ldiskfs-5.14-rhel9.series index 2b43648..7f3244f 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-5.14-rhel9.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-5.14-rhel9.series @@ -32,3 +32,4 @@ linux-5.14/ext4-xattr-disable-credits-check.patch linux-5.10/ext4-fiemap-kernel-data.patch rhel8/ext4-old_ea_inodes_handling_fix.patch linux-5.14/ext4-enc-flag.patch +rhel9/ext4-add-periodic-superblock-update.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-5.14.21-sles15sp4.series b/ldiskfs/kernel_patches/series/ldiskfs-5.14.21-sles15sp4.series index e40d556..d9ade04 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-5.14.21-sles15sp4.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-5.14.21-sles15sp4.series @@ -31,3 +31,4 @@ linux-5.14/ext4-xattr-disable-credits-check.patch linux-5.10/ext4-fiemap-kernel-data.patch rhel8/ext4-old_ea_inodes_handling_fix.patch linux-5.14/ext4-enc-flag.patch +rhel9/ext4-add-periodic-superblock-update.patch diff --git a/ldiskfs/kernel_patches/series/ldiskfs-5.14.21-sles15sp5.series b/ldiskfs/kernel_patches/series/ldiskfs-5.14.21-sles15sp5.series index 9fa1926..af55e34 100644 --- a/ldiskfs/kernel_patches/series/ldiskfs-5.14.21-sles15sp5.series +++ b/ldiskfs/kernel_patches/series/ldiskfs-5.14.21-sles15sp5.series @@ -30,3 +30,4 @@ base/ext4-delayed-iput.patch linux-5.14/ext4-xattr-disable-credits-check.patch linux-5.10/ext4-fiemap-kernel-data.patch rhel8/ext4-old_ea_inodes_handling_fix.patch +rhel9/ext4-add-periodic-superblock-update.patch -- 1.8.3.1