Merge branch 'for-linus-4.9' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs

Pull btrfs fixes from Chris Mason:
 "Some fixes from Omar and Dave Sterba for our new free space tree.

  This isn't heavily used yet, but as we move toward making it the new
  default we wanted to nail down an endian bug"

* 'for-linus-4.9' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs:
  btrfs: tests: uninline member definitions in free_space_extent
  btrfs: tests: constify free space extent specs
  Btrfs: expand free space tree sanity tests to catch endianness bug
  Btrfs: fix extent buffer bitmap tests on big-endian systems
  Btrfs: catch invalid free space trees
  Btrfs: fix mount -o clear_cache,space_cache=v2
  Btrfs: fix free space tree bitmaps on big-endian systems

8 files changed, 272 insertions, 157 deletions

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 6c21bad26a27..0b8ce2b9f7d0 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -252,7 +252,8 @@ struct btrfs_super_block {
 #define BTRFS_FEATURE_COMPAT_SAFE_CLEAR         0ULL
 
 #define BTRFS_FEATURE_COMPAT_RO_SUPP                    \
-        (BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE)
+        (BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE |      \
+         BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID)
 
 #define BTRFS_FEATURE_COMPAT_RO_SAFE_SET        0ULL
 #define BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR      0ULL
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index e720d3e6ec20..3a57f99d96aa 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -2586,6 +2586,7 @@ int open_ctree(struct super_block *sb,
         int num_backups_tried = 0;
         int backup_index = 0;
         int max_active;
+        int clear_free_space_tree = 0;
 
         tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info, GFP_KERNEL);
         chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info, GFP_KERNEL);
@@ -3148,6 +3149,26 @@ retry_root_backup:
         if (sb->s_flags & MS_RDONLY)
                 return 0;
 
+        if (btrfs_test_opt(fs_info, CLEAR_CACHE) &&
+            btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
+                clear_free_space_tree = 1;
+        } else if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&
+                   !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID)) {
+                btrfs_warn(fs_info, "free space tree is invalid");
+                clear_free_space_tree = 1;
+        }
+
+        if (clear_free_space_tree) {
+                btrfs_info(fs_info, "clearing free space tree");
+                ret = btrfs_clear_free_space_tree(fs_info);
+                if (ret) {
+                        btrfs_warn(fs_info,
+                                   "failed to clear free space tree: %d", ret);
+                        close_ctree(tree_root);
+                        return ret;
+                }
+        }
+
         if (btrfs_test_opt(tree_root->fs_info, FREE_SPACE_TREE) &&
             !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
                 btrfs_info(fs_info, "creating free space tree");
@@ -3185,18 +3206,6 @@ retry_root_backup:
 
         btrfs_qgroup_rescan_resume(fs_info);
 
-        if (btrfs_test_opt(tree_root->fs_info, CLEAR_CACHE) &&
-            btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
-                btrfs_info(fs_info, "clearing free space tree");
-                ret = btrfs_clear_free_space_tree(fs_info);
-                if (ret) {
-                        btrfs_warn(fs_info,
-                                "failed to clear free space tree: %d", ret);
-                        close_ctree(tree_root);
-                        return ret;
-                }
-        }
-
         if (!fs_info->uuid_root) {
                 btrfs_info(fs_info, "creating UUID tree");
                 ret = btrfs_create_uuid_tree(fs_info);
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index ee40384c394d..66a755150056 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -5558,17 +5558,45 @@ void copy_extent_buffer(struct extent_buffer *dst, struct extent_buffer *src,
         }
 }
 
-/*
- * The extent buffer bitmap operations are done with byte granularity because
- * bitmap items are not guaranteed to be aligned to a word and therefore a
- * single word in a bitmap may straddle two pages in the extent buffer.
- */
-#define BIT_BYTE(nr) ((nr) / BITS_PER_BYTE)
-#define BYTE_MASK ((1 << BITS_PER_BYTE) - 1)
-#define BITMAP_FIRST_BYTE_MASK(start) \
-        ((BYTE_MASK << ((start) & (BITS_PER_BYTE - 1))) & BYTE_MASK)
-#define BITMAP_LAST_BYTE_MASK(nbits) \
-        (BYTE_MASK >> (-(nbits) & (BITS_PER_BYTE - 1)))
+void le_bitmap_set(u8 *map, unsigned int start, int len)
+{
+        u8 *p = map + BIT_BYTE(start);
+        const unsigned int size = start + len;
+        int bits_to_set = BITS_PER_BYTE - (start % BITS_PER_BYTE);
+        u8 mask_to_set = BITMAP_FIRST_BYTE_MASK(start);
+
+        while (len - bits_to_set >= 0) {
+                *p |= mask_to_set;
+                len -= bits_to_set;
+                bits_to_set = BITS_PER_BYTE;
+                mask_to_set = ~(u8)0;
+                p++;
+        }
+        if (len) {
+                mask_to_set &= BITMAP_LAST_BYTE_MASK(size);
+                *p |= mask_to_set;
+        }
+}
+
+void le_bitmap_clear(u8 *map, unsigned int start, int len)
+{
+        u8 *p = map + BIT_BYTE(start);
+        const unsigned int size = start + len;
+        int bits_to_clear = BITS_PER_BYTE - (start % BITS_PER_BYTE);
+        u8 mask_to_clear = BITMAP_FIRST_BYTE_MASK(start);
+
+        while (len - bits_to_clear >= 0) {
+                *p &= ~mask_to_clear;
+                len -= bits_to_clear;
+                bits_to_clear = BITS_PER_BYTE;
+                mask_to_clear = ~(u8)0;
+                p++;
+        }
+        if (len) {
+                mask_to_clear &= BITMAP_LAST_BYTE_MASK(size);
+                *p &= ~mask_to_clear;
+        }
+}
 
 /*
  * eb_bitmap_offset() - calculate the page and offset of the byte containing the
@@ -5612,7 +5640,7 @@ static inline void eb_bitmap_offset(struct extent_buffer *eb,
 int extent_buffer_test_bit(struct extent_buffer *eb, unsigned long start,
                            unsigned long nr)
 {
-        char *kaddr;
+        u8 *kaddr;
         struct page *page;
         unsigned long i;
         size_t offset;
@@ -5634,13 +5662,13 @@ int extent_buffer_test_bit(struct extent_buffer *eb, unsigned long start,
 void extent_buffer_bitmap_set(struct extent_buffer *eb, unsigned long start,
                               unsigned long pos, unsigned long len)
 {
-        char *kaddr;
+        u8 *kaddr;
         struct page *page;
         unsigned long i;
         size_t offset;
         const unsigned int size = pos + len;
         int bits_to_set = BITS_PER_BYTE - (pos % BITS_PER_BYTE);
-        unsigned int mask_to_set = BITMAP_FIRST_BYTE_MASK(pos);
+        u8 mask_to_set = BITMAP_FIRST_BYTE_MASK(pos);
 
         eb_bitmap_offset(eb, start, pos, &i, &offset);
         page = eb->pages[i];
@@ -5651,7 +5679,7 @@ void extent_buffer_bitmap_set(struct extent_buffer *eb, unsigned long start,
                 kaddr[offset] |= mask_to_set;
                 len -= bits_to_set;
                 bits_to_set = BITS_PER_BYTE;
-                mask_to_set = ~0U;
+                mask_to_set = ~(u8)0;
                 if (++offset >= PAGE_SIZE && len > 0) {
                         offset = 0;
                         page = eb->pages[++i];
@@ -5676,13 +5704,13 @@ void extent_buffer_bitmap_set(struct extent_buffer *eb, unsigned long start,
 void extent_buffer_bitmap_clear(struct extent_buffer *eb, unsigned long start,
                                 unsigned long pos, unsigned long len)
 {
-        char *kaddr;
+        u8 *kaddr;
         struct page *page;
         unsigned long i;
         size_t offset;
         const unsigned int size = pos + len;
         int bits_to_clear = BITS_PER_BYTE - (pos % BITS_PER_BYTE);