Btrfs: Fix some data=ordered related data corruptions

Stress testing was showing data checksum errors, most of which were caused
by a lookup bug in the extent_map tree.  The tree was caching the last
pointer returned, and searches would check the last pointer first.

But, search callers also expect the search to return the very first
matching extent in the range, which wasn't always true with the last
pointer usage.

For now, the code to cache the last return value is just removed.  It is
easy to fix, but I think lookups are rare enough that it isn't required anymore.

This commit also replaces do_sync_mapping_range with a local copy of the
related functions.

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

10 files changed, 140 insertions, 83 deletions

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 96ab2797c09..f8fccdac305 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -1590,6 +1590,8 @@ int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
                         struct btrfs_root *root, struct btrfs_path *path,
                         u64 isize);
 /* inode.c */
+int btrfs_writepages(struct address_space *mapping,
+                     struct writeback_control *wbc);
 int btrfs_create_subvol_root(struct btrfs_root *new_root,
                 struct btrfs_trans_handle *trans, u64 new_dirid,
                 struct btrfs_block_group_cache *block_group);
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 7380449cb5b..9965993748d 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -97,7 +97,6 @@ void extent_io_tree_init(struct extent_io_tree *tree,
         spin_lock_init(&tree->lock);
         spin_lock_init(&tree->buffer_lock);
         tree->mapping = mapping;
-        tree->last = NULL;
 }
 EXPORT_SYMBOL(extent_io_tree_init);
 
@@ -173,12 +172,6 @@ static struct rb_node *__etree_search(struct extent_io_tree *tree, u64 offset,
         struct tree_entry *entry;
         struct tree_entry *prev_entry = NULL;
 
-        if (tree->last) {
-                struct extent_state *state;
-                state = tree->last;
-                if (state->start <= offset && offset <= state->end)
-                        return &tree->last->rb_node;
-        }
         while(n) {
                 entry = rb_entry(n, struct tree_entry, rb_node);
                 prev = n;
@@ -189,7 +182,6 @@ static struct rb_node *__etree_search(struct extent_io_tree *tree, u64 offset,
                 else if (offset > entry->end)
                         n = n->rb_right;
                 else {
-                        tree->last = rb_entry(n, struct extent_state, rb_node);
                         return n;
                 }
         }
@@ -223,10 +215,6 @@ static inline struct rb_node *tree_search(struct extent_io_tree *tree,
 
         ret = __etree_search(tree, offset, &prev, NULL);
         if (!ret) {
-                if (prev) {
-                        tree->last = rb_entry(prev, struct extent_state,
-                                              rb_node);
-                }
                 return prev;
         }
         return ret;
@@ -301,8 +289,6 @@ static int merge_state(struct extent_io_tree *tree,
                     other->state == state->state) {
                         state->start = other->start;
                         other->tree = NULL;
-                        if (tree->last == other)
-                                tree->last = state;
                         rb_erase(&other->rb_node, &tree->state);
                         free_extent_state(other);
                 }
@@ -314,8 +300,6 @@ static int merge_state(struct extent_io_tree *tree,
                     other->state == state->state) {
                         other->start = state->start;
                         state->tree = NULL;
-                        if (tree->last == state)
-                                tree->last = other;
                         rb_erase(&state->rb_node, &tree->state);
                         free_extent_state(state);
                 }
@@ -378,7 +362,6 @@ static int insert_state(struct extent_io_tree *tree,
                 return -EEXIST;
         }
         state->tree = tree;
-        tree->last = state;
         merge_state(tree, state);
         return 0;
 }
@@ -444,9 +427,6 @@ static int clear_state_bit(struct extent_io_tree *tree,
         if (delete || state->state == 0) {
                 if (state->tree) {
                         clear_state_cb(tree, state, state->state);
-                        if (tree->last == state) {
-                                tree->last = extent_state_next(state);
-                        }
                         rb_erase(&state->rb_node, &tree->state);
                         state->tree = NULL;
                         free_extent_state(state);
diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index 6c03e6a1993..315cfceae31 100644
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -60,7 +60,6 @@ struct extent_io_tree {
         spinlock_t lock;
         spinlock_t buffer_lock;
         struct extent_io_ops *ops;
-        struct extent_state *last;
 };
 
 struct extent_state {
diff --git a/fs/btrfs/extent_map.c b/fs/btrfs/extent_map.c
index 71b1ac15535..8a502ee2f23 100644
--- a/fs/btrfs/extent_map.c
+++ b/fs/btrfs/extent_map.c
@@ -42,7 +42,6 @@ void extent_map_exit(void)
 void extent_map_tree_init(struct extent_map_tree *tree, gfp_t mask)
 {
         tree->map.rb_node = NULL;
-        tree->last = NULL;
         spin_lock_init(&tree->lock);
 }
 EXPORT_SYMBOL(extent_map_tree_init);
@@ -239,7 +238,6 @@ int add_extent_mapping(struct extent_map_tree *tree,
                 merge->in_tree = 0;
                 free_extent_map(merge);
         }
-        tree->last = em;
 out:
         return ret;
 }
@@ -273,10 +271,6 @@ struct extent_map *lookup_extent_mapping(struct extent_map_tree *tree,
         u64 end = range_end(start, len);
 
         BUG_ON(spin_trylock(&tree->lock));
-        em = tree->last;
-        if (em && end > em->start && start < extent_map_end(em))
-                goto found;
-
         rb_node = __tree_search(&tree->map, start, &prev, &next);
         if (!rb_node && prev) {
                 em = rb_entry(prev, struct extent_map, rb_node);
@@ -305,7 +299,6 @@ struct extent_map *lookup_extent_mapping(struct extent_map_tree *tree,
 
 found:
         atomic_inc(&em->refs);
-        tree->last = em;
 out:
         return em;
 }
@@ -327,8 +320,6 @@ int remove_extent_mapping(struct extent_map_tree *tree, struct extent_map *em)
         BUG_ON(spin_trylock(&tree->lock));
         rb_erase(&em->rb_node, &tree->map);
         em->in_tree = 0;
-        if (tree->last == em)
-                tree->last = NULL;
         return ret;
 }
 EXPORT_SYMBOL(remove_extent_mapping);
diff --git a/fs/btrfs/extent_map.h b/fs/btrfs/extent_map.h
index a3978ec2784..26ac6fe0b26 100644
--- a/fs/btrfs/extent_map.h
+++ b/fs/btrfs/extent_map.h
@@ -26,7 +26,6 @@ struct extent_map {
 
 struct extent_map_tree {
         struct rb_root map;
-        struct extent_map *last;
         spinlock_t lock;
 };
 
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 591a30208ac..e5ffb66ad32 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -381,14 +381,13 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end)
                         break;
                 }
                 if (test_bit(EXTENT_FLAG_PINNED, &em->flags)) {
-                        start = em->start + em->len;
-                        free_extent_map(em);
-                        spin_unlock(&em_tree->lock);
-                        if (start < end) {
-                                len = end - start + 1;
-                                continue;
-                        }
-                        break;
+                        printk(KERN_CRIT "inode %lu trying to drop pinned "
+                               "extent start %llu end %llu, em [%llu %llu]\n",
+                               inode->i_ino,
+                               (unsigned long long)start,
+                               (unsigned long long)end,
+                               (unsigned long long)em->start,
+                               (unsigned long long)em->len);
                 }
                 remove_extent_mapping(em_tree, em);
 
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 60852ada658..3da12a4d913 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -485,7 +485,7 @@ int btrfs_writepage_start_hook(struct page *page, u64 start, u64 end)
         fixup = kzalloc(sizeof(*fixup), GFP_NOFS);
         if (!fixup)
                 return -EAGAIN;
-printk("queueing worker to fixup page %lu %Lu\n", inode->i_ino, page_offset(page));
+
         SetPageChecked(page);
         page_cache_get(page);
         fixup->work.func = btrfs_writepage_fixup_worker;
@@ -502,11 +502,13 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
         struct extent_map *em;
+        struct extent_map *em_orig;
         u64 alloc_hint = 0;
         u64 clear_start;
         u64 clear_end;
         struct list_head list;
         struct btrfs_key ins;
+        struct rb_node *rb;
         int ret;
 
         ret = btrfs_dec_test_ordered_pending(inode, start, end - start + 1);
@@ -535,6 +537,22 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
 
         mutex_lock(&BTRFS_I(inode)->extent_mutex);
 
+        spin_lock(&em_tree->lock);
+        clear_start = ordered_extent->file_offset;
+        clear_end = ordered_extent->file_offset + ordered_extent->len;
+        em = lookup_extent_mapping(em_tree, clear_start,
+                                   ordered_extent->len);
+        em_orig = em;
+        while(em && clear_start < extent_map_end(em) && clear_end > em->start) {
+                clear_bit(EXTENT_FLAG_PINNED, &em->flags);
+                rb = rb_next(&em->rb_node);
+                if (!rb)
+                        break;
+                em = rb_entry(rb, struct extent_map, rb_node);
+        }
+        free_extent_map(em_orig);
+        spin_unlock(&em_tree->lock);
+
         ret = btrfs_drop_extents(trans, root, inode,
                                  ordered_extent->file_offset,
                                  ordered_extent->file_offset +
@@ -548,22 +566,6 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
                                        ordered_extent->len, 0);
         BUG_ON(ret);
 
-        spin_lock(&em_tree->lock);
-        clear_start = ordered_extent->file_offset;
-        clear_end = ordered_extent->file_offset + ordered_extent->len;
-        while(clear_start < clear_end) {
-                em = lookup_extent_mapping(em_tree, clear_start,
-                                           clear_end - clear_start);
-                if (em) {
-                        clear_bit(EXTENT_FLAG_PINNED, &em->flags);
-                        clear_start = em->start + em->len;
-                        free_extent_map(em);
-                } else {
-                        break;
-                }
-        }
-        spin_unlock(&em_tree->lock);
-
         btrfs_drop_extent_cache(inode, ordered_extent->file_offset,
                                 ordered_extent->file_offset +
                                 ordered_extent->len - 1);
@@ -2318,7 +2320,7 @@ struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
         u64 extent_end = 0;
         u64 objectid = inode->i_ino;
         u32 found_type;
-        struct btrfs_path *path;
+        struct btrfs_path *path = NULL;
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_file_extent_item *item;
         struct extent_buffer *leaf;
@@ -2328,9 +2330,6 @@ struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
         struct btrfs_trans_handle *trans = NULL;
 
-        path = btrfs_alloc_path();
-        BUG_ON(!path);
-
 again:
         spin_lock(&em_tree->lock);
         em = lookup_extent_mapping(em_tree, start, len);
@@ -2354,6 +2353,12 @@ again:
         em->bdev = root->fs_info->fs_devices->latest_bdev;
         em->start = EXTENT_MAP_HOLE;
         em->len = (u64)-1;
+
+        if (!path) {
+                path = btrfs_alloc_path();
+                BUG_ON(!path);
+        }
+
         ret = btrfs_lookup_file_extent(trans, root, path,
                                        objectid, start, trans != NULL);
         if (ret < 0) {
@@ -2530,7 +2535,8 @@ insert:
         }
         spin_unlock(&em_tree->lock);
 out:
-        btrfs_free_path(path);
+        if (path)
+                btrfs_free_path(path);
         if (trans) {
                 ret = btrfs_end_transaction(trans, root);
                 if (!err) {
@@ -2643,8 +2649,8 @@ static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
         return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
 }
 
-static int btrfs_writepages(struct address_space *mapping,
-                            struct writeback_control *wbc)
+int btrfs_writepages(struct address_space *mapping,
+                     struct writeback_control *wbc)
 {
         struct extent_io_tree *tree;
         tree = &BTRFS_I(mapping->host)->io_tree;
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 0d87795fdd8..830dbaea685 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -19,6 +19,8 @@
 #include <linux/gfp.h>
 #include <linux/slab.h>
 #include <linux/blkdev.h>
+#include <linux/writeback.h>
+#include <linux/pagevec.h>
 #include "ctree.h"
 #include "transaction.h"
 #include "btrfs_inode.h"
@@ -307,12 +309,7 @@ void btrfs_start_ordered_extent(struct inode *inode,
          * start IO on any dirty ones so the wait doesn't stall waiting
          * for pdflush to find them
          */
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
-        do_sync_file_range(file, start, end, SYNC_FILE_RANGE_WRITE);
-#else
-        do_sync_mapping_range(inode->i_mapping, start, end,
-                              SYNC_FILE_RANGE_WRITE);
-#endif
+        btrfs_fdatawrite_range(inode->i_mapping, start, end, WB_SYNC_NONE);
         if (wait)
                 wait_event(entry->wait, test_bit(BTRFS_ORDERED_COMPLETE,
                                                  &entry->flags));
@@ -327,28 +324,26 @@ void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
         u64 orig_end;
         u64 wait_end;
         struct btrfs_ordered_extent *ordered;
-        u64 mask = BTRFS_I(inode)->root->sectorsize - 1;
 
         if (start + len < start) {
-                wait_end = (inode->i_size + mask) & ~mask;
-                orig_end = (u64)-1;
+                orig_end = INT_LIMIT(loff_t);
         } else {
                 orig_end = start + len - 1;
-                wait_end = orig_end;
+                if (orig_end > INT_LIMIT(loff_t))
+                        orig_end = INT_LIMIT(loff_t);
         }
+        wait_end = orig_end;
 again:
         /* start IO across the range first to instantiate any delalloc
          * extents
          */
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
-        do_sync_file_range(file, start, wait_end, SYNC_FILE_RANGE_WRITE);
-#else
-        do_sync_mapping_range(inode->i_mapping, start, wait_end,
-                              SYNC_FILE_RANGE_WRITE);
-#endif
-        end = orig_end;
-        wait_on_extent_writeback(&BTRFS_I(inode)->io_tree, start, orig_end);
+        btrfs_fdatawrite_range(inode->i_mapping, start, orig_end, WB_SYNC_NONE);
+
+        btrfs_wait_on_page_writeback_range(inode->i_mapping,
+                                           start >> PAGE_CACHE_SHIFT,
+                                           orig_end >> PAGE_CACHE_SHIFT);
 
+        end = orig_end;
         while(1) {
                 ordered = btrfs_lookup_first_ordered_extent(inode, end);
                 if (!ordered) {
@@ -565,3 +560,87 @@ out:
         return ret;
 }
 
+
+/**
+ * taken from mm/filemap.c because it isn't exported
+ *
+ * __filemap_fdatawrite_range - start writeback on mapping dirty pages in range
+ * @mapping:    address space structure to write
+ * @start:      offset in bytes where the range starts
+ * @end:        offset in bytes where the range ends (inclusive)
+ * @sync_mode:  enable synchronous operation
+ *
+ * Start writeback against all of a mapping's dirty pages that lie
+ * within the byte offsets <start, end> inclusive.
+ *
+ * If sync_mode is WB_SYNC_ALL then this is a "data integrity" operation, as
+ * opposed to a regular memory cleansing writeback.  The difference between
+ * these two operations is that if a dirty page/buffer is encountered, it must
+ * be waited upon, and not just skipped over.
+ */
+int btrfs_fdatawrite_range(struct address_space *mapping, loff_t start,
+                           loff_t end, int sync_mode)
+{
+        struct writeback_control wbc = {
+                .sync_mode = sync_mode,
+                .nr_to_write = mapping->nrpages * 2,
+                .range_start = start,
+                .range_end = end,
+                .for_writepages = 1,
+        };
+        return btrfs_writepages(mapping, &wbc);
+}
+
+/**
+ * taken from mm/filemap.c because it isn't exported
+ *
+ * wait_on_page_writeback_range - wait for writeback to complete
+ * @mapping:    target address_space
+ * @start:      beginning page index
+ * @end:        ending page index
+ *
+ * Wait for writeback to complete against pages indexed by start->end
+ * inclusive
+ */
+int btrfs_wait_on_page_writeback_range(struct address_space *mapping,
+                                       pgoff_t start, pgoff_t end)
+{
+        struct pagevec pvec;
+        int nr_pages;
+        int ret = 0;
+        pgoff_t index;
+
+        if (end < start)
+                return 0;
+
+        pagevec_init(&pvec, 0);
+        index = start;
+        while ((index <= end) &&
+                        (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
+                        PAGECACHE_TAG_WRITEBACK,
+                        min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1)) != 0) {
+                unsigned i;
+
+                for (i = 0; i < nr_pages; i++) {
+                        struct page *page = pvec.pages[i];
+
+                        /* until radix tree lookup accepts end_index */
+                        if (page->index > end)
+                                continue;
+
+                        wait_on_page_writeback(page);
+                        if (PageError(page))
+                                ret = -EIO;
+                }
+                pagevec_release(&pvec);
+                cond_resched();
+        }
+
+        /* Check for outstanding write errors */
+        if (test_and_clear_bit(AS_ENOSPC, &mapping->flags))
+                ret = -ENOSPC;
+        if (test_and_clear_bit(AS_EIO, &mapping->flags))
+                ret = -EIO;
+
+        return ret;
+}
diff --git a/fs/btrfs/ordered-data.h b/fs/btrfs/ordered-data.h
index 1794efd13ca..8e8e3c0404f 100644
--- a/fs/btrfs/ordered-data.h
+++ b/fs/btrfs/ordered-data.h
@@ -132,4 +132,8 @@ btrfs_lookup_first_ordered_extent(struct inode * inode, u64 file_offset);
 int btrfs_ordered_update_i_size(struct inode *inode,
                                 struct btrfs_ordered_extent *ordered);
 int btrfs_find_ordered_sum(struct inode *inode, u64 offset, u32 *sum);
+int btrfs_wait_on_page_writeback_range(struct address_space *mapping,
+                                       pgoff_t start, pgoff_t end);
+int btrfs_fdatawrite_range(struct address_space *mapping, loff_t start,
+                           loff_t end, int sync_mode);
 #endif
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 05823904ecb..38c75a0256c 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -649,7 +649,6 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
         extent_io_tree_init(pinned_copy,
                              root->fs_info->btree_inode->i_mapping, GFP_NOFS);
 
-printk("commit trans %Lu\n", trans->transid);
         trans->transaction->in_commit = 1;
         trans->transaction->blocked = 1;
         cur_trans = trans->transaction;
@@ -745,7 +744,6 @@ printk("commit trans %Lu\n", trans->transid);
                 list_splice_init(&dirty_fs_roots, &root->fs_info->dead_roots);
 
         mutex_unlock(&root->fs_info->trans_mutex);
-printk("done commit trans %Lu\n", trans->transid);
         kmem_cache_free(btrfs_trans_handle_cachep, trans);
 
         if (root->fs_info->closing) {