Btrfs: transaction rework
authorChris Mason <chris.mason@oracle.com>
Thu, 22 Mar 2007 19:59:16 +0000 (15:59 -0400)
committerDavid Woodhouse <dwmw2@hera.kernel.org>
Thu, 22 Mar 2007 19:59:16 +0000 (15:59 -0400)
Signed-off-by: Chris Mason <chris.mason@oracle.com>
fs/btrfs/Makefile
fs/btrfs/ctree.h
fs/btrfs/disk-io.c
fs/btrfs/disk-io.h
fs/btrfs/super.c
fs/btrfs/transaction.c [new file with mode: 0644]
fs/btrfs/transaction.h

index 1a0fb74223932cb106b6af186e1720645bb1d326..be7d74cdca049cff35f8a5e38a3bac1617887e23 100644 (file)
@@ -3,7 +3,7 @@ ifneq ($(KERNELRELEASE),)
 
 obj-m  := btrfs.o
 btrfs-y := super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \
-          hash.o file-item.o inode-item.o inode-map.o disk-io.o
+          hash.o file-item.o inode-item.o inode-map.o disk-io.o transaction.o
 
 #btrfs-y := ctree.o disk-io.o radix-tree.o extent-tree.o print-tree.o \
 #        root-tree.o dir-item.o hash.o file-item.o inode-item.o \
index 7748eecd9304c5e5bf485fd0c7c9bc76a4eeec3b..4c19a3f12afdcdc4f0071ad9b46a0dd75f2394a3 100644 (file)
@@ -5,6 +5,7 @@
 #include <linux/fs.h>
 
 struct btrfs_trans_handle;
+struct btrfs_transaction;
 
 #define BTRFS_MAGIC "_BtRfS_M"
 
@@ -224,10 +225,11 @@ struct btrfs_fs_info {
        u64 last_inode_alloc;
        u64 last_inode_alloc_dirid;
        u64 generation;
-       struct btrfs_trans_handle *running_transaction;
+       struct btrfs_transaction *running_transaction;
        struct btrfs_super_block *disk_super;
        struct buffer_head *sb_buffer;
        struct super_block *sb;
+       struct mutex trans_mutex;
 };
 
 /*
index df2061a735cd5601b15db9918b7855c012bfc457..9cacca0c525cbcc18f0fb8e4bb01b51989cc4ea5 100644 (file)
@@ -50,89 +50,6 @@ int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
        return 0;
 }
 
-int write_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
-                    struct buffer_head *buf)
-{
-       mark_buffer_dirty(buf);
-       return 0;
-}
-
-static int __commit_transaction(struct btrfs_trans_handle *trans, struct
-                               btrfs_root *root)
-{
-       filemap_write_and_wait(root->fs_info->sb->s_bdev->bd_inode->i_mapping);
-       return 0;
-}
-
-static int commit_tree_roots(struct btrfs_trans_handle *trans,
-                            struct btrfs_fs_info *fs_info)
-{
-       int ret;
-       u64 old_extent_block;
-       struct btrfs_root *tree_root = fs_info->tree_root;
-       struct btrfs_root *extent_root = fs_info->extent_root;
-       struct btrfs_root *inode_root = fs_info->inode_root;
-
-       btrfs_set_root_blocknr(&inode_root->root_item,
-                              inode_root->node->b_blocknr);
-       ret = btrfs_update_root(trans, tree_root,
-                               &inode_root->root_key,
-                               &inode_root->root_item);
-       BUG_ON(ret);
-       while(1) {
-               old_extent_block = btrfs_root_blocknr(&extent_root->root_item);
-               if (old_extent_block == extent_root->node->b_blocknr)
-                       break;
-               btrfs_set_root_blocknr(&extent_root->root_item,
-                                      extent_root->node->b_blocknr);
-               ret = btrfs_update_root(trans, tree_root,
-                                       &extent_root->root_key,
-                                       &extent_root->root_item);
-               BUG_ON(ret);
-       }
-       return 0;
-}
-
-int btrfs_commit_transaction(struct btrfs_trans_handle *trans, struct
-                            btrfs_root *root, struct btrfs_super_block *s)
-{
-       int ret = 0;
-       struct buffer_head *snap = root->commit_root;
-       struct btrfs_key snap_key;
-
-       if (root->commit_root == root->node)
-               return 0;
-
-       memcpy(&snap_key, &root->root_key, sizeof(snap_key));
-       root->root_key.offset++;
-
-       btrfs_set_root_blocknr(&root->root_item, root->node->b_blocknr);
-       ret = btrfs_insert_root(trans, root->fs_info->tree_root,
-                               &root->root_key, &root->root_item);
-       BUG_ON(ret);
-
-       ret = commit_tree_roots(trans, root->fs_info);
-       BUG_ON(ret);
-
-       ret = __commit_transaction(trans, root);
-       BUG_ON(ret);
-
-       write_ctree_super(trans, root, s);
-       btrfs_finish_extent_commit(trans, root->fs_info->extent_root);
-       btrfs_finish_extent_commit(trans, root->fs_info->tree_root);
-
-       root->commit_root = root->node;
-       get_bh(root->node);
-       ret = btrfs_drop_snapshot(trans, root, snap);
-       BUG_ON(ret);
-
-       ret = btrfs_del_root(trans, root->fs_info->tree_root, &snap_key);
-       BUG_ON(ret);
-       root->fs_info->generation = root->root_key.offset + 1;
-
-       return ret;
-}
-
 static int __setup_root(struct btrfs_super_block *super,
                        struct btrfs_root *root,
                        struct btrfs_fs_info *fs_info,
@@ -197,6 +114,7 @@ struct btrfs_root *open_ctree(struct super_block *sb,
        fs_info->disk_super = disk_super;
        fs_info->sb_buffer = sb_buffer;
        fs_info->sb = sb;
+       mutex_init(&fs_info->trans_mutex);
        memset(&fs_info->current_insert, 0, sizeof(fs_info->current_insert));
        memset(&fs_info->last_insert, 0, sizeof(fs_info->last_insert));
 
@@ -225,7 +143,7 @@ struct btrfs_root *open_ctree(struct super_block *sb,
 }
 
 int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
-                     *root, struct btrfs_super_block *s)
+                     *root)
 {
        return 0;
 #if 0
@@ -242,34 +160,19 @@ int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
 #endif
 }
 
-static int drop_cache(struct btrfs_root *root)
-{
-       return 0;
-#if 0
-       while(!list_empty(&root->fs_info->cache)) {
-               struct buffer_head *b = list_entry(root->fs_info->cache.next,
-                                                   struct buffer_head,
-                                                   cache);
-               list_del_init(&b->cache);
-               btrfs_block_release(root, b);
-       }
-       return 0;
-#endif
-}
-
 int close_ctree(struct btrfs_root *root)
 {
        int ret;
        struct btrfs_trans_handle *trans;
 
-       trans = root->fs_info->running_transaction;
-       btrfs_commit_transaction(trans, root, root->fs_info->disk_super);
-       ret = commit_tree_roots(trans, root->fs_info);
-       BUG_ON(ret);
-       ret = __commit_transaction(trans, root);
+       trans = btrfs_start_transaction(root, 1);
+       btrfs_commit_transaction(trans, root);
+       /* run commit again to  drop the original snapshot */
+       trans = btrfs_start_transaction(root, 1);
+       btrfs_commit_transaction(trans, root);
+       ret = btrfs_write_and_wait_transaction(NULL, root);
        BUG_ON(ret);
-       write_ctree_super(trans, root, root->fs_info->disk_super);
-       drop_cache(root);
+       write_ctree_super(NULL, root);
 
        if (root->node)
                btrfs_block_release(root, root->node);
index 7f4bb729b7347b4076811c62cd23e704a72cfa78..099f7eea0ec791cc3967765cda9857e1fd9050f5 100644 (file)
@@ -28,14 +28,14 @@ int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
                     struct buffer_head *buf);
 int clean_tree_block(struct btrfs_trans_handle *trans,
                     struct btrfs_root *root, struct buffer_head *buf);
-int btrfs_commit_transaction(struct btrfs_trans_handle *trans, struct btrfs_root
-                            *root, struct btrfs_super_block *s);
+int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
+                            struct btrfs_root *root);
 struct btrfs_root *open_ctree(struct super_block *sb,
                              struct buffer_head *sb_buffer,
                              struct btrfs_super_block *disk_super);
 int close_ctree(struct btrfs_root *root);
 void btrfs_block_release(struct btrfs_root *root, struct buffer_head *buf);
-int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root *root,
-                     struct btrfs_super_block *s);
+int write_ctree_super(struct btrfs_trans_handle *trans,
+                     struct btrfs_root *root);
 int mkfs(int fd, u64 num_blocks, u32 blocksize);
 #endif
index ccc056aad692c47859e745f58434a2b8ff570e1f..620430825840865eb02ef8e7c9260e314fc9e22b 100644 (file)
@@ -141,7 +141,6 @@ static void btrfs_read_locked_inode(struct inode *inode)
        struct btrfs_inode_item *inode_item;
        struct btrfs_root *root = btrfs_sb(inode->i_sb);
        int ret;
-printk("read locked inode %lu\n", inode->i_ino);
        btrfs_init_path(&path);
        ret = btrfs_lookup_inode(NULL, root, &path, inode->i_ino, 0);
        if (ret) {
@@ -152,7 +151,6 @@ printk("read locked inode %lu\n", inode->i_ino);
                                  path.slots[0],
                                  struct btrfs_inode_item);
 
-printk("found locked inode %lu\n", inode->i_ino);
        inode->i_mode = btrfs_inode_mode(inode_item);
        inode->i_nlink = btrfs_inode_nlink(inode_item);
        inode->i_uid = btrfs_inode_uid(inode_item);
@@ -166,7 +164,6 @@ printk("found locked inode %lu\n", inode->i_ino);
        inode->i_ctime.tv_nsec = btrfs_timespec_nsec(&inode_item->ctime);
        inode->i_blocks = btrfs_inode_nblocks(inode_item);
        inode->i_generation = btrfs_inode_generation(inode_item);
-printk("about to release\n");
        btrfs_release_path(root, &path);
        switch (inode->i_mode & S_IFMT) {
 #if 0
@@ -176,19 +173,15 @@ printk("about to release\n");
                break;
 #endif
        case S_IFREG:
-printk("inode %lu now a file\n", inode->i_ino);
                break;
        case S_IFDIR:
-printk("inode %lu now a directory\n", inode->i_ino);
                inode->i_op = &btrfs_dir_inode_operations;
                inode->i_fop = &btrfs_dir_file_operations;
                break;
        case S_IFLNK:
-printk("inode %lu now a link\n", inode->i_ino);
                // inode->i_op = &page_symlink_inode_operations;
                break;
        }
-printk("returning!\n");
        return;
 }
 
@@ -232,7 +225,6 @@ static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
                return ERR_PTR(ret);
        inode = NULL;
        if (ino) {
-printk("lookup on %.*s returns %lu\n", dentry->d_name.len, dentry->d_name.name, ino);
                inode = iget(dir->i_sb, ino);
                if (!inode)
                        return ERR_PTR(-EACCES);
@@ -257,7 +249,6 @@ static int btrfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
        int over;
 
        key.objectid = inode->i_ino;
-printk("readdir on dir %Lu pos %Lu\n", key.objectid, filp->f_pos);
        key.flags = 0;
        btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
        key.offset = filp->f_pos;
@@ -266,15 +257,12 @@ printk("readdir on dir %Lu pos %Lu\n", key.objectid, filp->f_pos);
        if (ret < 0) {
                goto err;
        }
-printk("first ret %d\n", ret);
        advance = filp->f_pos > 0 && ret != 0;
        while(1) {
                leaf = btrfs_buffer_leaf(path.nodes[0]);
                nritems = btrfs_header_nritems(&leaf->header);
                slot = path.slots[0];
-printk("leaf %Lu nritems %lu slot %d\n", path.nodes[0]->b_blocknr, nritems, slot);
                if (advance) {
-printk("advancing!\n");
                        if (slot == nritems -1) {
                                ret = btrfs_next_leaf(root, &path);
                                if (ret)
@@ -282,7 +270,6 @@ printk("advancing!\n");
                                leaf = btrfs_buffer_leaf(path.nodes[0]);
                                nritems = btrfs_header_nritems(&leaf->header);
                                slot = path.slots[0];
-printk("2leaf %Lu nritems %lu slot %d\n", path.nodes[0]->b_blocknr, nritems, slot);
                        } else {
                                slot++;
                                path.slots[0]++;
@@ -290,15 +277,11 @@ printk("2leaf %Lu nritems %lu slot %d\n", path.nodes[0]->b_blocknr, nritems, slo
                }
                advance = 1;
                item = leaf->items + slot;
-printk("item key %Lu %u %Lu\n", btrfs_disk_key_objectid(&item->key),
-       btrfs_disk_key_flags(&item->key), btrfs_disk_key_offset(&item->key));
                if (btrfs_disk_key_objectid(&item->key) != key.objectid)
                        break;
                if (btrfs_disk_key_type(&item->key) != BTRFS_DIR_ITEM_KEY)
                        continue;
                di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
-printk("filldir name %.*s, objectid %Lu\n", btrfs_dir_name_len(di),
-       (const char *)(di + 1), btrfs_dir_objectid(di));
                over = filldir(dirent, (const char *)(di + 1),
                               btrfs_dir_name_len(di),
                               btrfs_disk_key_offset(&item->key),
@@ -307,7 +290,6 @@ printk("filldir name %.*s, objectid %Lu\n", btrfs_dir_name_len(di),
                        break;
                filp->f_pos = btrfs_disk_key_offset(&item->key) + 1;
        }
-printk("filldir all done\n");
        ret = 0;
 err:
        btrfs_release_path(root, &path);
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
new file mode 100644 (file)
index 0000000..8dc1c17
--- /dev/null
@@ -0,0 +1,199 @@
+#include <linux/module.h>
+#include <linux/fs.h>
+#include "ctree.h"
+#include "disk-io.h"
+#include "transaction.h"
+
+
+static void put_transaction(struct btrfs_transaction *transaction)
+{
+       transaction->use_count--;
+       if (transaction->use_count == 0)
+               kfree(transaction);
+}
+
+static int join_transaction(struct btrfs_root *root)
+{
+       struct btrfs_transaction *cur_trans;
+       cur_trans = root->fs_info->running_transaction;
+       if (!cur_trans) {
+               cur_trans = kmalloc(sizeof(*cur_trans), GFP_NOFS);
+               BUG_ON(!cur_trans);
+               root->fs_info->running_transaction = cur_trans;
+               cur_trans->num_writers = 0;
+               cur_trans->transid = root->root_key.offset + 1;
+               init_waitqueue_head(&cur_trans->writer_wait);
+               init_waitqueue_head(&cur_trans->commit_wait);
+               cur_trans->in_commit = 0;
+               cur_trans->use_count = 0;
+               cur_trans->commit_done = 0;
+       }
+       cur_trans->num_writers++;
+       return 0;
+}
+
+struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
+                                                  int num_blocks)
+{
+       struct btrfs_trans_handle *h = kmalloc(sizeof(*h), GFP_NOFS);
+       int ret;
+
+       mutex_lock(&root->fs_info->trans_mutex);
+       ret = join_transaction(root);
+       BUG_ON(ret);
+       h->transid = root->fs_info->running_transaction->transid;
+       h->transaction = root->fs_info->running_transaction;
+       h->blocks_reserved = num_blocks;
+       h->blocks_used = 0;
+       root->fs_info->running_transaction->use_count++;
+       mutex_unlock(&root->fs_info->trans_mutex);
+       return h;
+}
+
+int btrfs_end_transaction(struct btrfs_trans_handle *trans,
+                         struct btrfs_root *root)
+{
+       struct btrfs_transaction *cur_trans;
+       mutex_lock(&root->fs_info->trans_mutex);
+       cur_trans = root->fs_info->running_transaction;
+       WARN_ON(cur_trans->num_writers <= 1);
+       if (waitqueue_active(&cur_trans->writer_wait))
+               wake_up(&cur_trans->writer_wait);
+       cur_trans->num_writers--;
+       put_transaction(cur_trans);
+       mutex_unlock(&root->fs_info->trans_mutex);
+       kfree(trans);
+       return 0;
+}
+
+
+int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
+                                    struct btrfs_root *root)
+{
+       filemap_write_and_wait(root->fs_info->sb->s_bdev->bd_inode->i_mapping);
+       return 0;
+}
+
+int btrfs_commit_tree_roots(struct btrfs_trans_handle *trans,
+                           struct btrfs_root *root)
+{
+       int ret;
+       u64 old_extent_block;
+       struct btrfs_fs_info *fs_info = root->fs_info;
+       struct btrfs_root *tree_root = fs_info->tree_root;
+       struct btrfs_root *extent_root = fs_info->extent_root;
+       struct btrfs_root *inode_root = fs_info->inode_root;
+
+       btrfs_set_root_blocknr(&inode_root->root_item,
+                              inode_root->node->b_blocknr);
+       ret = btrfs_update_root(trans, tree_root,
+                               &inode_root->root_key,
+                               &inode_root->root_item);
+       BUG_ON(ret);
+       while(1) {
+               old_extent_block = btrfs_root_blocknr(&extent_root->root_item);
+               if (old_extent_block == extent_root->node->b_blocknr)
+                       break;
+               btrfs_set_root_blocknr(&extent_root->root_item,
+                                      extent_root->node->b_blocknr);
+               ret = btrfs_update_root(trans, tree_root,
+                                       &extent_root->root_key,
+                                       &extent_root->root_item);
+               BUG_ON(ret);
+       }
+       return 0;
+}
+
+static int wait_for_commit(struct btrfs_root *root,
+                          struct btrfs_transaction *commit)
+{
+       DEFINE_WAIT(wait);
+       commit->use_count++;
+       while(!commit->commit_done) {
+               prepare_to_wait(&commit->commit_wait, &wait,
+                               TASK_UNINTERRUPTIBLE);
+               if (commit->commit_done)
+                       break;
+               mutex_unlock(&root->fs_info->trans_mutex);
+               schedule();
+               mutex_lock(&root->fs_info->trans_mutex);
+       }
+       finish_wait(&commit->commit_wait, &wait);
+       return 0;
+}
+
+int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
+                            struct btrfs_root *root)
+{
+       int ret = 0;
+       struct buffer_head *snap = root->commit_root;
+       struct btrfs_key snap_key;
+       struct btrfs_transaction *cur_trans;
+       DEFINE_WAIT(wait);
+
+       mutex_lock(&root->fs_info->trans_mutex);
+       if (trans->transaction->in_commit) {
+               cur_trans = trans->transaction;
+               trans->transaction->use_count++;
+               btrfs_end_transaction(trans, root);
+               ret = wait_for_commit(root, cur_trans);
+               BUG_ON(ret);
+               put_transaction(cur_trans);
+               mutex_unlock(&root->fs_info->trans_mutex);
+               return 0;
+       }
+       while (trans->transaction->num_writers > 1) {
+               prepare_to_wait(&trans->transaction->writer_wait, &wait,
+                               TASK_UNINTERRUPTIBLE);
+               if (trans->transaction->num_writers <= 1)
+                       break;
+               mutex_unlock(&root->fs_info->trans_mutex);
+               schedule();
+               mutex_lock(&root->fs_info->trans_mutex);
+       }
+       finish_wait(&trans->transaction->writer_wait, &wait);
+
+       cur_trans = root->fs_info->running_transaction;
+       root->fs_info->running_transaction = NULL;
+       mutex_unlock(&root->fs_info->trans_mutex);
+
+       memcpy(&snap_key, &root->root_key, sizeof(snap_key));
+       root->root_key.offset++;
+
+       if (btrfs_root_blocknr(&root->root_item) != root->node->b_blocknr) {
+               btrfs_set_root_blocknr(&root->root_item, root->node->b_blocknr);
+               ret = btrfs_insert_root(trans, root->fs_info->tree_root,
+                                       &root->root_key, &root->root_item);
+               BUG_ON(ret);
+       }
+
+       ret = btrfs_commit_tree_roots(trans, root);
+       BUG_ON(ret);
+
+       ret = btrfs_write_and_wait_transaction(trans, root);
+       BUG_ON(ret);
+
+       write_ctree_super(trans, root);
+       btrfs_finish_extent_commit(trans, root->fs_info->extent_root);
+       btrfs_finish_extent_commit(trans, root->fs_info->tree_root);
+       put_transaction(cur_trans);
+       kfree(trans);
+
+       if (root->node != root->commit_root) {
+               trans = btrfs_start_transaction(root, 1);
+               root->commit_root = root->node;
+               get_bh(root->node);
+               ret = btrfs_drop_snapshot(trans, root, snap);
+               BUG_ON(ret);
+
+               ret = btrfs_del_root(trans, root->fs_info->tree_root,
+                                    &snap_key);
+               BUG_ON(ret);
+               root->fs_info->generation = root->root_key.offset + 1;
+               ret = btrfs_end_transaction(trans, root);
+               BUG_ON(ret);
+       }
+
+       return ret;
+}
+
index 9ab27b7491c55c832a5c88969e66246a1d629b2d..7e6c08a0accdf1543039671bd38de34fe5101fb9 100644 (file)
@@ -1,27 +1,30 @@
 #ifndef __TRANSACTION__
 #define __TRANSACTION__
 
+struct btrfs_transaction {
+       u64 transid;
+       unsigned long num_writers;
+       int in_commit;
+       int use_count;
+       int commit_done;
+       wait_queue_head_t writer_wait;
+       wait_queue_head_t commit_wait;
+};
+
 struct btrfs_trans_handle {
        u64 transid;
        unsigned long blocks_reserved;
        unsigned long blocks_used;
+       struct btrfs_transaction *transaction;
 };
 
-static inline struct btrfs_trans_handle *
-btrfs_start_transaction(struct btrfs_root *root, int num_blocks)
-{
-       struct btrfs_trans_handle *h = kmalloc(sizeof(*h), GFP_NOFS);
-       h->transid = root->root_key.offset;
-       h->blocks_reserved = num_blocks;
-       h->blocks_used = 0;
-       return h;
-}
-
-static inline void btrfs_free_transaction(struct btrfs_root *root,
-                                         struct btrfs_trans_handle *handle)
-{
-       memset(handle, 0, sizeof(*handle));
-       kfree(handle);
-}
 
+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);
+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,
+                           struct btrfs_root *root);
 #endif