Btrfs: New data=ordered implementation

The old data=ordered code would force commit to wait until
all the data extents from the transaction were fully on disk.  This
introduced large latencies into the commit and stalled new writers
in the transaction for a long time.

The new code changes the way data allocations and extents work:

* When delayed allocation is filled, data extents are reserved, and
  the extent bit EXTENT_ORDERED is set on the entire range of the extent.
  A struct btrfs_ordered_extent is allocated an inserted into a per-inode
  rbtree to track the pending extents.

* As each page is written EXTENT_ORDERED is cleared on the bytes corresponding
  to that page.

* When all of the bytes corresponding to a single struct btrfs_ordered_extent
  are written, The previously reserved extent is inserted into the FS
  btree and into the extent allocation trees.  The checksums for the file
  data are also updated.

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

1 files changed, 93 insertions, 39 deletions

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 8ebfa6be0790..343d1101c31c 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -1895,36 +1895,17 @@ error:
         return ret;
 }
 
-/*
- * finds a free extent and does all the dirty work required for allocation
- * returns the key for the extent through ins, and a tree buffer for
- * the first block of the extent through buf.
- *
- * returns 0 if everything worked, non-zero otherwise.
- */
-int btrfs_alloc_extent(struct btrfs_trans_handle *trans,
-                       struct btrfs_root *root,
-                       u64 num_bytes, u64 min_alloc_size,
-                       u64 root_objectid, u64 ref_generation,
-                       u64 owner, u64 owner_offset,
-                       u64 empty_size, u64 hint_byte,
-                       u64 search_end, struct btrfs_key *ins, u64 data)
+static int __btrfs_reserve_extent(struct btrfs_trans_handle *trans,
+                                  struct btrfs_root *root,
+                                  u64 num_bytes, u64 min_alloc_size,
+                                  u64 empty_size, u64 hint_byte,
+                                  u64 search_end, struct btrfs_key *ins,
+                                  u64 data)
 {
         int ret;
-        int pending_ret;
-        u64 super_used;
-        u64 root_used;
         u64 search_start = 0;
         u64 alloc_profile;
-        u32 sizes[2];
         struct btrfs_fs_info *info = root->fs_info;
-        struct btrfs_root *extent_root = info->extent_root;
-        struct btrfs_extent_item *extent_item;
-        struct btrfs_extent_ref *ref;
-        struct btrfs_path *path;
-        struct btrfs_key keys[2];
-
-        maybe_lock_mutex(root);
 
         if (data) {
                 alloc_profile = info->avail_data_alloc_bits &
@@ -1974,11 +1955,48 @@ again:
         }
         if (ret) {
                 printk("allocation failed flags %Lu\n", data);
-        }
-        if (ret) {
                 BUG();
-                goto out;
         }
+        clear_extent_dirty(&root->fs_info->free_space_cache,
+                           ins->objectid, ins->objectid + ins->offset - 1,
+                           GFP_NOFS);
+        return 0;
+}
+
+int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
+                                  struct btrfs_root *root,
+                                  u64 num_bytes, u64 min_alloc_size,
+                                  u64 empty_size, u64 hint_byte,
+                                  u64 search_end, struct btrfs_key *ins,
+                                  u64 data)
+{
+        int ret;
+        maybe_lock_mutex(root);
+        ret = __btrfs_reserve_extent(trans, root, num_bytes, min_alloc_size,
+                                     empty_size, hint_byte, search_end, ins,
+                                     data);
+        maybe_unlock_mutex(root);
+        return ret;
+}
+
+static int __btrfs_alloc_reserved_extent(struct btrfs_trans_handle *trans,
+                                         struct btrfs_root *root,
+                                         u64 root_objectid, u64 ref_generation,
+                                         u64 owner, u64 owner_offset,
+                                         struct btrfs_key *ins)
+{
+        int ret;
+        int pending_ret;
+        u64 super_used;
+        u64 root_used;
+        u64 num_bytes = ins->offset;
+        u32 sizes[2];
+        struct btrfs_fs_info *info = root->fs_info;
+        struct btrfs_root *extent_root = info->extent_root;
+        struct btrfs_extent_item *extent_item;
+        struct btrfs_extent_ref *ref;
+        struct btrfs_path *path;
+        struct btrfs_key keys[2];
 
         /* block accounting for super block */
         spin_lock_irq(&info->delalloc_lock);
@@ -1990,10 +2008,6 @@ again:
         root_used = btrfs_root_used(&root->root_item);
         btrfs_set_root_used(&root->root_item, root_used + num_bytes);
 
-        clear_extent_dirty(&root->fs_info->free_space_cache,
-                           ins->objectid, ins->objectid + ins->offset - 1,
-                           GFP_NOFS);
-
         if (root == extent_root) {
                 set_extent_bits(&root->fs_info->extent_ins, ins->objectid,
                                 ins->objectid + ins->offset - 1,
@@ -2001,10 +2015,6 @@ again:
                 goto update_block;
         }
 
-        WARN_ON(trans->alloc_exclude_nr);
-        trans->alloc_exclude_start = ins->objectid;
-        trans->alloc_exclude_nr = ins->offset;
-
         memcpy(&keys[0], ins, sizeof(*ins));
         keys[1].offset = hash_extent_ref(root_objectid, ref_generation,
                                          owner, owner_offset);
@@ -2054,6 +2064,51 @@ update_block:
                 BUG();
         }
 out:
+        return ret;
+}
+
+int btrfs_alloc_reserved_extent(struct btrfs_trans_handle *trans,
+                                struct btrfs_root *root,
+                                u64 root_objectid, u64 ref_generation,
+                                u64 owner, u64 owner_offset,
+                                struct btrfs_key *ins)
+{
+        int ret;
+        maybe_lock_mutex(root);
+        ret = __btrfs_alloc_reserved_extent(trans, root, root_objectid,
+                                            ref_generation, owner,
+                                            owner_offset, ins);
+        maybe_unlock_mutex(root);
+        return ret;
+}
+/*
+ * finds a free extent and does all the dirty work required for allocation
+ * returns the key for the extent through ins, and a tree buffer for
+ * the first block of the extent through buf.
+ *
+ * returns 0 if everything worked, non-zero otherwise.
+ */
+int btrfs_alloc_extent(struct btrfs_trans_handle *trans,
+                       struct btrfs_root *root,
+                       u64 num_bytes, u64 min_alloc_size,
+                       u64 root_objectid, u64 ref_generation,
+                       u64 owner, u64 owner_offset,
+                       u64 empty_size, u64 hint_byte,
+                       u64 search_end, struct btrfs_key *ins, u64 data)
+{
+        int ret;
+
+        maybe_lock_mutex(root);
+
+        ret = __btrfs_reserve_extent(trans, root, num_bytes,
+                                     min_alloc_size, empty_size, hint_byte,
+                                     search_end, ins, data);
+        BUG_ON(ret);
+        ret = __btrfs_alloc_reserved_extent(trans, root, root_objectid,
+                                            ref_generation, owner,
+                                            owner_offset, ins);
+        BUG_ON(ret);
+
         maybe_unlock_mutex(root);
         return ret;
 }
@@ -2288,8 +2343,8 @@ static int noinline walk_down_tree(struct btrfs_trans_handle *trans,
                         mutex_lock(&root->fs_info->alloc_mutex);
 
                         /* we've dropped the lock, double check */
-                        ret = drop_snap_lookup_refcount(root, bytenr,
-                                                blocksize, &refs);
+                        ret = lookup_extent_ref(NULL, root, bytenr, blocksize,
+                                                &refs);
                         BUG_ON(ret);
                         if (refs != 1) {
                                 parent = path->nodes[*level];
@@ -2584,7 +2639,6 @@ out_unlock:
         kfree(ra);
         trans = btrfs_start_transaction(BTRFS_I(inode)->root, 1);
         if (trans) {
-                btrfs_add_ordered_inode(inode);
                 btrfs_end_transaction(trans, BTRFS_I(inode)->root);
                 mark_inode_dirty(inode);
         }