btrfs_start_transaction: wait for commits in progress to finish

btrfs_commit_transaction has to loop waiting for any writers in the
transaction to finish before it can proceed.  btrfs_start_transaction
should be polite and not join a transaction that is in the process
of being finished off.

There are a few places that can't wait, basically the ones doing IO that
might be needed to finish the transaction.  For them, btrfs_join_transaction
is added.

Signed-off-by: Chris Mason <chris.mason@oracle.com>

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 4ddc8a8f82cd3911eab3c128a5f86016a44d8686..acbce542d291bb6c6f5c10922bf5b1dacbe12078 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -513,6 +513,7 @@ struct btrfs_fs_info {
        u64 alloc_start;
        struct btrfs_transaction *running_transaction;
        wait_queue_head_t transaction_throttle;
+       wait_queue_head_t transaction_wait;
        struct btrfs_super_block super_copy;
        struct btrfs_super_block super_for_commit;
        struct block_device *__bdev;

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 66466d125c0521c9dd8f5b2d22faed94166d8ff6..99bb385c298274fc7f53c27af13c27060752c223 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1291,6 +1291,7 @@ struct btrfs_root *open_ctree(struct super_block *sb,
        mutex_init(&fs_info->cleaner_mutex);
        mutex_init(&fs_info->volume_mutex);
        init_waitqueue_head(&fs_info->transaction_throttle);
+       init_waitqueue_head(&fs_info->transaction_wait);
 
 #if 0
        ret = add_hasher(fs_info, "crc32c");

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 3e4e5c227c0c33e72d93b0b9fdde24bb151870c7..d6505892cd52ed2dc6ee81a54a28ae3982c412b0 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -251,7 +251,7 @@ static int noinline dirty_and_release_pages(struct btrfs_trans_handle *trans,
        end_of_last_block = start_pos + num_bytes - 1;
 
        lock_extent(io_tree, start_pos, end_of_last_block, GFP_NOFS);
-       trans = btrfs_start_transaction(root, 1);
+       trans = btrfs_join_transaction(root, 1);
        if (!trans) {
                err = -ENOMEM;
                goto out_unlock;

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index baf46017d0d3c3cac1612f21829f3073a586b2a1..0a687326c0b00343ab7571e5d4494b8f5281326a 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -116,7 +116,7 @@ static int cow_file_range(struct inode *inode, u64 start, u64 end)
        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
        int ret = 0;
 
-       trans = btrfs_start_transaction(root, 1);
+       trans = btrfs_join_transaction(root, 1);
        BUG_ON(!trans);
        btrfs_set_trans_block_group(trans, inode);
 
@@ -502,7 +502,7 @@ int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
                return 0;
        }
 
-       trans = btrfs_start_transaction(root, 1);
+       trans = btrfs_join_transaction(root, 1);
 
        ordered_extent = btrfs_lookup_ordered_extent(inode, start);
        BUG_ON(!ordered_extent);
@@ -1812,7 +1812,7 @@ int btrfs_write_inode(struct inode *inode, int wait)
        int ret = 0;
 
        if (wait) {
-               trans = btrfs_start_transaction(root, 1);
+               trans = btrfs_join_transaction(root, 1);
                btrfs_set_trans_block_group(trans, inode);
                ret = btrfs_commit_transaction(trans, root);
        }
@@ -1830,7 +1830,7 @@ void btrfs_dirty_inode(struct inode *inode)
        struct btrfs_root *root = BTRFS_I(inode)->root;
        struct btrfs_trans_handle *trans;
 
-       trans = btrfs_start_transaction(root, 1);
+       trans = btrfs_join_transaction(root, 1);
        btrfs_set_trans_block_group(trans, inode);
        btrfs_update_inode(trans, root, inode);
        btrfs_end_transaction(trans, root);
@@ -2395,7 +2395,7 @@ again:
                                free_extent_map(em);
                                em = NULL;
                                btrfs_release_path(root, path);
-                               trans = btrfs_start_transaction(root, 1);
+                               trans = btrfs_join_transaction(root, 1);
                                goto again;
                        }
                        write_extent_buffer(leaf, map + pg_offset, ptr,

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 86a5acc19ce7fca22f28174f3885343214856c46..05823904ecba686df1f3cdfc7361342d070508b8 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -62,6 +62,7 @@ static noinline int join_transaction(struct btrfs_root *root)
                init_waitqueue_head(&cur_trans->writer_wait);
                init_waitqueue_head(&cur_trans->commit_wait);
                cur_trans->in_commit = 0;
+               cur_trans->blocked = 0;
                cur_trans->use_count = 1;
                cur_trans->commit_done = 0;
                cur_trans->start_time = get_seconds();
@@ -99,14 +100,36 @@ static noinline int record_root_in_trans(struct btrfs_root *root)
        return 0;
 }
 
-struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
-                                                  int num_blocks)
+struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
+                                            int num_blocks, int join)
 {
        struct btrfs_trans_handle *h =
                kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
+       struct btrfs_transaction *cur_trans;
        int ret;
 
        mutex_lock(&root->fs_info->trans_mutex);
+       cur_trans = root->fs_info->running_transaction;
+       if (cur_trans && cur_trans->blocked && !join) {
+               DEFINE_WAIT(wait);
+               cur_trans->use_count++;
+               while(1) {
+                       prepare_to_wait(&root->fs_info->transaction_wait, &wait,
+                                       TASK_UNINTERRUPTIBLE);
+                       if (cur_trans->blocked) {
+                               mutex_unlock(&root->fs_info->trans_mutex);
+                               schedule();
+                               mutex_lock(&root->fs_info->trans_mutex);
+                               finish_wait(&root->fs_info->transaction_wait,
+                                           &wait);
+                       } else {
+                               finish_wait(&root->fs_info->transaction_wait,
+                                           &wait);
+                               break;
+                       }
+               }
+               put_transaction(cur_trans);
+       }
        ret = join_transaction(root);
        BUG_ON(ret);
 
@@ -123,6 +146,17 @@ struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
        return h;
 }
 
+struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
+                                                  int num_blocks)
+{
+       return start_transaction(root, num_blocks, 0);
+}
+struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root,
+                                                  int num_blocks)
+{
+       return start_transaction(root, num_blocks, 1);
+}
+
 static noinline int wait_for_commit(struct btrfs_root *root,
                                    struct btrfs_transaction *commit)
 {
@@ -156,7 +190,7 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
        if (waitqueue_active(&cur_trans->writer_wait))
                wake_up(&cur_trans->writer_wait);
 
-       if (cur_trans->in_commit && throttle) {
+       if (0 && cur_trans->in_commit && throttle) {
                DEFINE_WAIT(wait);
                mutex_unlock(&root->fs_info->trans_mutex);
                prepare_to_wait(&root->fs_info->transaction_throttle, &wait,
@@ -617,6 +651,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
 
 printk("commit trans %Lu\n", trans->transid);
        trans->transaction->in_commit = 1;
+       trans->transaction->blocked = 1;
        cur_trans = trans->transaction;
        if (cur_trans->list.prev != &root->fs_info->trans_list) {
                prev_trans = list_entry(cur_trans->list.prev,
@@ -684,7 +719,9 @@ printk("commit trans %Lu\n", trans->transid);
 
        btrfs_copy_pinned(root, pinned_copy);
 
+       trans->transaction->blocked = 0;
        wake_up(&root->fs_info->transaction_throttle);
+       wake_up(&root->fs_info->transaction_wait);
 
        mutex_unlock(&root->fs_info->trans_mutex);
        ret = btrfs_write_and_wait_transaction(trans, root);

diff --git a/fs/btrfs/transaction.h b/fs/btrfs/transaction.h
index 910350cd4cf06a66f7f26c4895aea290f8274e8e..11fbdeceb26ce63a7c5bfa87c63804d6dfac2d92 100644 (file)
--- a/fs/btrfs/transaction.h
+++ b/fs/btrfs/transaction.h
@@ -27,6 +27,7 @@ struct btrfs_transaction {
        int in_commit;
        int use_count;
        int commit_done;
+       int blocked;
        struct list_head list;
        struct extent_io_tree dirty_pages;
        unsigned long start_time;
@@ -75,6 +76,8 @@ int btrfs_end_transaction(struct btrfs_trans_handle *trans,
                          struct btrfs_root *root);
 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
                                                   int num_blocks);
+struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root,
+                                                  int num_blocks);
 int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
                                     struct btrfs_root *root);
 int btrfs_commit_tree_roots(struct btrfs_trans_handle *trans,