ext4: rename s_error_work to s_sb_upd_work

The most common use that s_error_work will get scheduled is now the
periodic update of the superblock.  So rename it to s_sb_upd_work.

Also rename the function flush_stashed_error_work() to
update_super_work().

Signed-off-by: Theodore Ts'o <tytso@mit.edu>

diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 2c2c3191bf41d034d3a0428139a1dc0eeb12da2d..84618c46f2390e0253ea8caa88d43d4e539395d4 100644 (file)
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1698,10 +1698,13 @@ struct ext4_sb_info {
        const char *s_last_error_func;
        time64_t s_last_error_time;
        /*
-        * If we are in a context where we cannot update error information in
-        * the on-disk superblock, we queue this work to do it.
+        * If we are in a context where we cannot update the on-disk
+        * superblock, we queue the work here.  This is used to update
+        * the error information in the superblock, and for periodic
+        * updates of the superblock called from the commit callback
+        * function.
         */
-       struct work_struct s_error_work;
+       struct work_struct s_sb_upd_work;
 
        /* Ext4 fast commit sub transaction ID */
        atomic_t s_fc_subtid;

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index bf0cfdffa9d079392ab5189ce0faf2455f11eb28..91f20afa1d71cf269f2b16666e2d26cd9cc262cc 100644 (file)
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -481,7 +481,7 @@ static void ext4_maybe_update_superblock(struct super_block *sb)
        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);
+               schedule_work(&EXT4_SB(sb)->s_sb_upd_work);
 }
 
 /*
@@ -723,7 +723,7 @@ static void ext4_handle_error(struct super_block *sb, bool force_ro, int error,
                 * defer superblock flushing to a workqueue.
                 */
                if (continue_fs && journal)
-                       schedule_work(&EXT4_SB(sb)->s_error_work);
+                       schedule_work(&EXT4_SB(sb)->s_sb_upd_work);
                else
                        ext4_commit_super(sb);
        }
@@ -750,10 +750,10 @@ static void ext4_handle_error(struct super_block *sb, bool force_ro, int error,
        sb->s_flags |= SB_RDONLY;
 }
 
-static void flush_stashed_error_work(struct work_struct *work)
+static void update_super_work(struct work_struct *work)
 {
        struct ext4_sb_info *sbi = container_of(work, struct ext4_sb_info,
-                                               s_error_work);
+                                               s_sb_upd_work);
        journal_t *journal = sbi->s_journal;
        handle_t *handle;
 
@@ -1078,7 +1078,7 @@ __acquires(bitlock)
                if (!bdev_read_only(sb->s_bdev)) {
                        save_error_info(sb, EFSCORRUPTED, ino, block, function,
                                        line);
-                       schedule_work(&EXT4_SB(sb)->s_error_work);
+                       schedule_work(&EXT4_SB(sb)->s_sb_upd_work);
                }
                return;
        }
@@ -1318,10 +1318,10 @@ static void ext4_put_super(struct super_block *sb)
         * Unregister sysfs before destroying jbd2 journal.
         * Since we could still access attr_journal_task attribute via sysfs
         * path which could have sbi->s_journal->j_task as NULL
-        * Unregister sysfs before flush sbi->s_error_work.
+        * Unregister sysfs before flush sbi->s_sb_upd_work.
         * Since user may read /proc/fs/ext4/xx/mb_groups during umount, If
         * read metadata verify failed then will queue error work.
-        * flush_stashed_error_work will call start_this_handle may trigger
+        * update_super_work will call start_this_handle may trigger
         * BUG_ON.
         */
        ext4_unregister_sysfs(sb);
@@ -1333,7 +1333,7 @@ static void ext4_put_super(struct super_block *sb)
        ext4_unregister_li_request(sb);
        ext4_quotas_off(sb, EXT4_MAXQUOTAS);
 
-       flush_work(&sbi->s_error_work);
+       flush_work(&sbi->s_sb_upd_work);
        destroy_workqueue(sbi->rsv_conversion_wq);
        ext4_release_orphan_info(sb);
 
@@ -4998,8 +4998,8 @@ static int ext4_load_and_init_journal(struct super_block *sb,
        return 0;
 
 out:
-       /* flush s_error_work before journal destroy. */
-       flush_work(&sbi->s_error_work);
+       /* flush s_sb_upd_work before destroying the journal. */
+       flush_work(&sbi->s_sb_upd_work);
        jbd2_journal_destroy(sbi->s_journal);
        sbi->s_journal = NULL;
        return -EINVAL;
@@ -5322,7 +5322,7 @@ static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb)
 
        timer_setup(&sbi->s_err_report, print_daily_error_info, 0);
        spin_lock_init(&sbi->s_error_lock);
-       INIT_WORK(&sbi->s_error_work, flush_stashed_error_work);
+       INIT_WORK(&sbi->s_sb_upd_work, update_super_work);
 
        err = ext4_group_desc_init(sb, es, logical_sb_block, &first_not_zeroed);
        if (err)
@@ -5666,16 +5666,16 @@ failed_mount9: __maybe_unused
        sbi->s_ea_block_cache = NULL;
 
        if (sbi->s_journal) {
-               /* flush s_error_work before journal destroy. */
-               flush_work(&sbi->s_error_work);
+               /* flush s_sb_upd_work before journal destroy. */
+               flush_work(&sbi->s_sb_upd_work);
                jbd2_journal_destroy(sbi->s_journal);
                sbi->s_journal = NULL;
        }
 failed_mount3a:
        ext4_es_unregister_shrinker(sbi);
 failed_mount3:
-       /* flush s_error_work before sbi destroy */
-       flush_work(&sbi->s_error_work);
+       /* flush s_sb_upd_work before sbi destroy */
+       flush_work(&sbi->s_sb_upd_work);
        del_timer_sync(&sbi->s_err_report);
        ext4_stop_mmpd(sbi);
        ext4_group_desc_free(sbi);
@@ -6551,7 +6551,7 @@ static int __ext4_remount(struct fs_context *fc, struct super_block *sb)
        }
 
        /* Flush outstanding errors before changing fs state */
-       flush_work(&sbi->s_error_work);
+       flush_work(&sbi->s_sb_upd_work);
 
        if ((bool)(fc->sb_flags & SB_RDONLY) != sb_rdonly(sb)) {
                if (ext4_forced_shutdown(sb)) {