1 files changed, 46 insertions, 6 deletions

diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index 202008ec367d..81296c57405a 100644
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -33,6 +33,8 @@
 
 static int link_free_space(struct btrfs_free_space_ctl *ctl,
                            struct btrfs_free_space *info);
+static void unlink_free_space(struct btrfs_free_space_ctl *ctl,
+                              struct btrfs_free_space *info);
 
 static struct inode *__lookup_free_space_inode(struct btrfs_root *root,
                                                struct btrfs_path *path,
@@ -75,7 +77,8 @@ static struct inode *__lookup_free_space_inode(struct btrfs_root *root,
                 return ERR_PTR(-ENOENT);
         }
 
-        inode->i_mapping->flags &= ~__GFP_FS;
+        mapping_set_gfp_mask(inode->i_mapping,
+                        mapping_gfp_mask(inode->i_mapping) & ~__GFP_FS);
 
         return inode;
 }
@@ -365,7 +368,7 @@ static int io_ctl_prepare_pages(struct io_ctl *io_ctl, struct inode *inode,
 
 static void io_ctl_set_generation(struct io_ctl *io_ctl, u64 generation)
 {
-        u64 *val;
+        __le64 *val;
 
         io_ctl_map_page(io_ctl, 1);
 
@@ -388,7 +391,7 @@ static void io_ctl_set_generation(struct io_ctl *io_ctl, u64 generation)
 
 static int io_ctl_check_generation(struct io_ctl *io_ctl, u64 generation)
 {
-        u64 *gen;
+        __le64 *gen;
 
         /*
          * Skip the crc area.  If we don't check crcs then we just have a 64bit
@@ -584,6 +587,44 @@ static int io_ctl_read_bitmap(struct io_ctl *io_ctl,
         return 0;
 }
 
+/*
+ * Since we attach pinned extents after the fact we can have contiguous sections
+ * of free space that are split up in entries.  This poses a problem with the
+ * tree logging stuff since it could have allocated across what appears to be 2
+ * entries since we would have merged the entries when adding the pinned extents
+ * back to the free space cache.  So run through the space cache that we just
+ * loaded and merge contiguous entries.  This will make the log replay stuff not
+ * blow up and it will make for nicer allocator behavior.
+ */
+static void merge_space_tree(struct btrfs_free_space_ctl *ctl)
+{
+        struct btrfs_free_space *e, *prev = NULL;
+        struct rb_node *n;
+
+again:
+        spin_lock(&ctl->tree_lock);
+        for (n = rb_first(&ctl->free_space_offset); n; n = rb_next(n)) {
+                e = rb_entry(n, struct btrfs_free_space, offset_index);
+                if (!prev)
+                        goto next;
+                if (e->bitmap || prev->bitmap)
+                        goto next;
+                if (prev->offset + prev->bytes == e->offset) {
+                        unlink_free_space(ctl, prev);
+                        unlink_free_space(ctl, e);
+                        prev->bytes += e->bytes;
+                        kmem_cache_free(btrfs_free_space_cachep, e);
+                        link_free_space(ctl, prev);
+                        prev = NULL;
+                        spin_unlock(&ctl->tree_lock);
+                        goto again;
+                }
+next:
+                prev = e;
+        }
+        spin_unlock(&ctl->tree_lock);
+}
+
 int __load_free_space_cache(struct btrfs_root *root, struct inode *inode,
                             struct btrfs_free_space_ctl *ctl,
                             struct btrfs_path *path, u64 offset)
@@ -726,6 +767,7 @@ int __load_free_space_cache(struct btrfs_root *root, struct inode *inode,
         }
 
         io_ctl_drop_pages(&io_ctl);
+        merge_space_tree(ctl);
         ret = 1;
 out:
         io_ctl_free(&io_ctl);
@@ -972,9 +1014,7 @@ int __btrfs_write_out_cache(struct btrfs_root *root, struct inode *inode,
                 goto out;
 
 
-        ret = filemap_write_and_wait(inode->i_mapping);
-        if (ret)
-                goto out;
+        btrfs_wait_ordered_range(inode, 0, (u64)-1);
 
         key.objectid = BTRFS_FREE_SPACE_OBJECTID;
         key.offset = offset;