reiserfs: get rid of resierfs_sync_super

This patch stops reiserfs using the VFS 'write_super()' method along with the
s_dirt flag, because they are on their way out.

The whole "superblock write-out" VFS infrastructure is served by the
'sync_supers()' kernel thread, which wakes up every 5 (by default) seconds and
writes out all dirty superblock using the '->write_super()' call-back.  But the
problem with this thread is that it wastes power by waking up the system every
5 seconds, even if there are no diry superblocks, or there are no client
file-systems which would need this (e.g., btrfs does not use
'->write_super()'). So we want to kill it completely and thus, we need to make
file-systems to stop using the '->write_super()' VFS service, and then remove
it together with the kernel thread.

Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

1 files changed, 45 insertions, 9 deletions

diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index 60cddb7e6389..651ce767b55d 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -72,20 +72,58 @@ static int reiserfs_sync_fs(struct super_block *s, int wait)
         if (!journal_begin(&th, s, 1))
                 if (!journal_end_sync(&th, s, 1))
                         reiserfs_flush_old_commits(s);
-        s->s_dirt = 0;  /* Even if it's not true.
-                         * We'll loop forever in sync_supers otherwise */
         reiserfs_write_unlock(s);
         return 0;
 }
 
-static void reiserfs_write_super(struct super_block *s)
+static void flush_old_commits(struct work_struct *work)
 {
+        struct reiserfs_sb_info *sbi;
+        struct super_block *s;
+
+        sbi = container_of(work, struct reiserfs_sb_info, old_work.work);
+        s = sbi->s_journal->j_work_sb;
+
+        spin_lock(&sbi->old_work_lock);
+        sbi->work_queued = 0;
+        spin_unlock(&sbi->old_work_lock);
+
         reiserfs_sync_fs(s, 1);
 }
 
+void reiserfs_schedule_old_flush(struct super_block *s)
+{
+        struct reiserfs_sb_info *sbi = REISERFS_SB(s);
+        unsigned long delay;
+
+        if (s->s_flags & MS_RDONLY)
+                return;
+
+        spin_lock(&sbi->old_work_lock);
+        if (!sbi->work_queued) {
+                delay = msecs_to_jiffies(dirty_writeback_interval * 10);
+                queue_delayed_work(system_long_wq, &sbi->old_work, delay);
+                sbi->work_queued = 1;
+        }
+        spin_unlock(&sbi->old_work_lock);
+}
+
+static void cancel_old_flush(struct super_block *s)
+{
+        struct reiserfs_sb_info *sbi = REISERFS_SB(s);
+
+        cancel_delayed_work_sync(&REISERFS_SB(s)->old_work);
+        spin_lock(&sbi->old_work_lock);
+        sbi->work_queued = 0;
+        spin_unlock(&sbi->old_work_lock);
+}
+
 static int reiserfs_freeze(struct super_block *s)
 {
         struct reiserfs_transaction_handle th;
+
+        cancel_old_flush(s);
+
         reiserfs_write_lock(s);
         if (!(s->s_flags & MS_RDONLY)) {
                 int err = journal_begin(&th, s, 1);
@@ -99,7 +137,6 @@ static int reiserfs_freeze(struct super_block *s)
                         journal_end_sync(&th, s, 1);
                 }
         }
-        s->s_dirt = 0;
         reiserfs_write_unlock(s);
         return 0;
 }
@@ -483,9 +520,6 @@ static void reiserfs_put_super(struct super_block *s)
 
         reiserfs_write_lock(s);
 
-        if (s->s_dirt)
-                reiserfs_write_super(s);
-
         /* change file system state to current state if it was mounted with read-write permissions */
         if (!(s->s_flags & MS_RDONLY)) {
                 if (!journal_begin(&th, s, 10)) {
@@ -692,7 +726,6 @@ static const struct super_operations reiserfs_sops = {
         .dirty_inode = reiserfs_dirty_inode,
         .evict_inode = reiserfs_evict_inode,
         .put_super = reiserfs_put_super,
-        .write_super = reiserfs_write_super,
         .sync_fs = reiserfs_sync_fs,
         .freeze_fs = reiserfs_freeze,
         .unfreeze_fs = reiserfs_unfreeze,
@@ -1400,7 +1433,6 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
         err = journal_end(&th, s, 10);
         if (err)
                 goto out_err;
-        s->s_dirt = 0;
 
         if (!(*mount_flags & MS_RDONLY)) {
                 dquot_resume(s, -1);
@@ -1741,6 +1773,8 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
         /* setup default block allocator options */
         reiserfs_init_alloc_options(s);
 
+        spin_lock_init(&sbi->old_work_lock);
+        INIT_DELAYED_WORK(&sbi->old_work, flush_old_commits);
         mutex_init(&sbi->lock);
         sbi->lock_depth = -1;
 
@@ -2003,6 +2037,8 @@ error_unlocked:
                 reiserfs_write_unlock(s);
         }
 
+        cancel_delayed_work_sync(&REISERFS_SB(s)->old_work);
+
         reiserfs_free_bitmap_cache(s);
         if (SB_BUFFER_WITH_SB(s))
                 brelse(SB_BUFFER_WITH_SB(s));