writeback: switch to per-bdi threads for flushing data
[linux-2.6.git] / fs / sync.c
index 4487b55..103cc7f 100644 (file)
--- a/fs/sync.c
+++ b/fs/sync.c
                        SYNC_FILE_RANGE_WAIT_AFTER)
 
 /*
- * Do the filesystem syncing work. For simple filesystems sync_inodes_sb(sb, 0)
- * just dirties buffers with inodes so we have to submit IO for these buffers
- * via __sync_blockdev(). This also speeds up the wait == 1 case since in that
- * case write_inode() functions do sync_dirty_buffer() and thus effectively
- * write one block at a time.
+ * Do the filesystem syncing work. For simple filesystems
+ * writeback_inodes_sb(sb) just dirties buffers with inodes so we have to
+ * submit IO for these buffers via __sync_blockdev(). This also speeds up the
+ * wait == 1 case since in that case write_inode() functions do
+ * sync_dirty_buffer() and thus effectively write one block at a time.
  */
 static int __sync_filesystem(struct super_block *sb, int wait)
 {
        /* Avoid doing twice syncing and cache pruning for quota sync */
-       if (!wait)
+       if (!wait) {
                writeout_quota_sb(sb, -1);
-       else
+               writeback_inodes_sb(sb);
+       } else {
                sync_quota_sb(sb, -1);
-       sync_inodes_sb(sb, wait);
-       lock_super(sb);
-       if (sb->s_dirt && sb->s_op->write_super)
-               sb->s_op->write_super(sb);
-       unlock_super(sb);
+               sync_inodes_sb(sb);
+       }
        if (sb->s_op->sync_fs)
                sb->s_op->sync_fs(sb, wait);
        return __sync_blockdev(sb->s_bdev, wait);
@@ -51,6 +49,18 @@ int sync_filesystem(struct super_block *sb)
 {
        int ret;
 
+       /*
+        * We need to be protected against the filesystem going from
+        * r/o to r/w or vice versa.
+        */
+       WARN_ON(!rwsem_is_locked(&sb->s_umount));
+
+       /*
+        * No point in syncing out anything if the filesystem is read-only.
+        */
+       if (sb->s_flags & MS_RDONLY)
+               return 0;
+
        ret = __sync_filesystem(sb, 0);
        if (ret < 0)
                return ret;
@@ -79,25 +89,22 @@ static void sync_filesystems(int wait)
 
        mutex_lock(&mutex);             /* Could be down_interruptible */
        spin_lock(&sb_lock);
-       list_for_each_entry(sb, &super_blocks, s_list) {
-               if (sb->s_flags & MS_RDONLY)
-                       continue;
+       list_for_each_entry(sb, &super_blocks, s_list)
                sb->s_need_sync = 1;
-       }
 
 restart:
        list_for_each_entry(sb, &super_blocks, s_list) {
                if (!sb->s_need_sync)
                        continue;
                sb->s_need_sync = 0;
-               if (sb->s_flags & MS_RDONLY)
-                       continue;       /* hm.  Was remounted r/o meanwhile */
                sb->s_count++;
                spin_unlock(&sb_lock);
+
                down_read(&sb->s_umount);
-               if (sb->s_root)
+               if (!(sb->s_flags & MS_RDONLY) && sb->s_root)
                        __sync_filesystem(sb, wait);
                up_read(&sb->s_umount);
+
                /* restart only when sb is no longer on the list */
                spin_lock(&sb_lock);
                if (__put_super_and_need_restart(sb))
@@ -107,8 +114,13 @@ restart:
        mutex_unlock(&mutex);
 }
 
+/*
+ * sync everything.  Start out by waking pdflush, because that writes back
+ * all queues in parallel.
+ */
 SYSCALL_DEFINE0(sync)
 {
+       wakeup_flusher_threads(0);
        sync_filesystems(0);
        sync_filesystems(1);
        if (unlikely(laptop_mode))
@@ -155,10 +167,8 @@ int file_fsync(struct file *filp, struct dentry *dentry, int datasync)
 
        /* sync the superblock to buffers */
        sb = inode->i_sb;
-       lock_super(sb);
        if (sb->s_dirt && sb->s_op->write_super)
                sb->s_op->write_super(sb);
-       unlock_super(sb);
 
        /* .. finally sync the buffers to disk */
        err = sync_blockdev(sb->s_bdev);