1 files changed, 49 insertions, 19 deletions

diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index b16450b840e7..a94b05f72869 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -349,10 +349,13 @@ int btrfs_dec_test_first_ordered_pending(struct inode *inode,
         if (!uptodate)
                 set_bit(BTRFS_ORDERED_IOERR, &entry->flags);
 
-        if (entry->bytes_left == 0)
+        if (entry->bytes_left == 0) {
                 ret = test_and_set_bit(BTRFS_ORDERED_IO_DONE, &entry->flags);
-        else
+                if (waitqueue_active(&entry->wait))
+                        wake_up(&entry->wait);
+        } else {
                 ret = 1;
+        }
 out:
         if (!ret && cached && entry) {
                 *cached = entry;
@@ -410,10 +413,13 @@ have_entry:
         if (!uptodate)
                 set_bit(BTRFS_ORDERED_IOERR, &entry->flags);
 
-        if (entry->bytes_left == 0)
+        if (entry->bytes_left == 0) {
                 ret = test_and_set_bit(BTRFS_ORDERED_IO_DONE, &entry->flags);
-        else
+                if (waitqueue_active(&entry->wait))
+                        wake_up(&entry->wait);
+        } else {
                 ret = 1;
+        }
 out:
         if (!ret && cached && entry) {
                 *cached = entry;
@@ -424,27 +430,48 @@ out:
 }
 
 /* Needs to either be called under a log transaction or the log_mutex */
-void btrfs_get_logged_extents(struct btrfs_root *log, struct inode *inode)
+void btrfs_get_logged_extents(struct inode *inode,
+                              struct list_head *logged_list)
 {
         struct btrfs_ordered_inode_tree *tree;
         struct btrfs_ordered_extent *ordered;
         struct rb_node *n;
-        int index = log->log_transid % 2;
 
         tree = &BTRFS_I(inode)->ordered_tree;
         spin_lock_irq(&tree->lock);
         for (n = rb_first(&tree->tree); n; n = rb_next(n)) {
                 ordered = rb_entry(n, struct btrfs_ordered_extent, rb_node);
-                spin_lock(&log->log_extents_lock[index]);
-                if (list_empty(&ordered->log_list)) {
-                        list_add_tail(&ordered->log_list, &log->logged_list[index]);
-                        atomic_inc(&ordered->refs);
-                }
-                spin_unlock(&log->log_extents_lock[index]);
+                if (!list_empty(&ordered->log_list))
+                        continue;
+                list_add_tail(&ordered->log_list, logged_list);
+                atomic_inc(&ordered->refs);
         }
         spin_unlock_irq(&tree->lock);
 }
 
+void btrfs_put_logged_extents(struct list_head *logged_list)
+{
+        struct btrfs_ordered_extent *ordered;
+
+        while (!list_empty(logged_list)) {
+                ordered = list_first_entry(logged_list,
+                                           struct btrfs_ordered_extent,
+                                           log_list);
+                list_del_init(&ordered->log_list);
+                btrfs_put_ordered_extent(ordered);
+        }
+}
+
+void btrfs_submit_logged_extents(struct list_head *logged_list,
+                                 struct btrfs_root *log)
+{
+        int index = log->log_transid % 2;
+
+        spin_lock_irq(&log->log_extents_lock[index]);
+        list_splice_tail(logged_list, &log->logged_list[index]);
+        spin_unlock_irq(&log->log_extents_lock[index]);
+}
+
 void btrfs_wait_logged_extents(struct btrfs_root *log, u64 transid)
 {
         struct btrfs_ordered_extent *ordered;
@@ -577,7 +604,7 @@ int btrfs_wait_ordered_extents(struct btrfs_root *root, int nr)
         INIT_LIST_HEAD(&splice);
         INIT_LIST_HEAD(&works);
 
-        mutex_lock(&root->fs_info->ordered_operations_mutex);
+        mutex_lock(&root->ordered_extent_mutex);
         spin_lock(&root->ordered_extent_lock);
         list_splice_init(&root->ordered_extents, &splice);
         while (!list_empty(&splice) && nr) {
@@ -588,10 +615,11 @@ int btrfs_wait_ordered_extents(struct btrfs_root *root, int nr)
                 atomic_inc(&ordered->refs);
                 spin_unlock(&root->ordered_extent_lock);
 
-                ordered->flush_work.func = btrfs_run_ordered_extent_work;
+                btrfs_init_work(&ordered->flush_work,
+                                btrfs_run_ordered_extent_work, NULL, NULL);
                 list_add_tail(&ordered->work_list, &works);
-                btrfs_queue_worker(&root->fs_info->flush_workers,
-                                   &ordered->flush_work);
+                btrfs_queue_work(root->fs_info->flush_workers,
+                                 &ordered->flush_work);
 
                 cond_resched();
                 spin_lock(&root->ordered_extent_lock);
@@ -608,7 +636,7 @@ int btrfs_wait_ordered_extents(struct btrfs_root *root, int nr)
                 btrfs_put_ordered_extent(ordered);
                 cond_resched();
         }
-        mutex_unlock(&root->fs_info->ordered_operations_mutex);
+        mutex_unlock(&root->ordered_extent_mutex);
 
         return count;
 }
@@ -621,6 +649,7 @@ void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, int nr)
 
         INIT_LIST_HEAD(&splice);
 
+        mutex_lock(&fs_info->ordered_operations_mutex);
         spin_lock(&fs_info->ordered_root_lock);
         list_splice_init(&fs_info->ordered_roots, &splice);
         while (!list_empty(&splice) && nr) {
@@ -643,6 +672,7 @@ void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, int nr)
         }
         list_splice_tail(&splice, &fs_info->ordered_roots);
         spin_unlock(&fs_info->ordered_root_lock);
+        mutex_unlock(&fs_info->ordered_operations_mutex);
 }
 
 /*
@@ -704,8 +734,8 @@ int btrfs_run_ordered_operations(struct btrfs_trans_handle *trans,
                         goto out;
                 }
                 list_add_tail(&work->list, &works);
-                btrfs_queue_worker(&root->fs_info->flush_workers,
-                                   &work->work);
+                btrfs_queue_work(root->fs_info->flush_workers,
+                                 &work->work);
 
                 cond_resched();
                 spin_lock(&root->fs_info->ordered_root_lock);