Btrfs: Calculate appropriate chunk sizes for both small and large filesystems

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

1 files changed, 61 insertions, 7 deletions

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 93aa36e2436e..e3ddd7fb8edd 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -627,6 +627,27 @@ int btrfs_add_system_chunk(struct btrfs_trans_handle *trans,
         return 0;
 }
 
+static u64 div_factor(u64 num, int factor)
+{
+        if (factor == 10)
+                return num;
+        num *= factor;
+        do_div(num, 10);
+        return num;
+}
+
+static u64 chunk_bytes_by_type(u64 type, u64 calc_size, int num_stripes,
+                               int sub_stripes)
+{
+        if (type & (BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_DUP))
+                return calc_size;
+        else if (type & BTRFS_BLOCK_GROUP_RAID10)
+                return calc_size * (num_stripes / sub_stripes);
+        else
+                return calc_size * num_stripes;
+}
+
+
 int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
                       struct btrfs_root *extent_root, u64 *start,
                       u64 *num_bytes, u64 type)
@@ -643,11 +664,14 @@ int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
         struct extent_map_tree *em_tree;
         struct map_lookup *map;
         struct extent_map *em;
+        int min_chunk_size = 8 * 1024 * 1024;
         u64 physical;
         u64 calc_size = 1024 * 1024 * 1024;
-        u64 min_free = calc_size;
+        u64 max_chunk_size = calc_size;
+        u64 min_free;
         u64 avail;
         u64 max_avail = 0;
+        u64 percent_max;
         int num_stripes = 1;
         int sub_stripes = 0;
         int looped = 0;
@@ -666,6 +690,8 @@ int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
         if (type & (BTRFS_BLOCK_GROUP_RAID1)) {
                 num_stripes = min_t(u64, 2,
                                   btrfs_super_num_devices(&info->super_copy));
+                if (num_stripes < 2)
+                        return -ENOSPC;
         }
         if (type & (BTRFS_BLOCK_GROUP_RAID10)) {
                 num_stripes = btrfs_super_num_devices(&info->super_copy);
@@ -674,13 +700,45 @@ int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
                 num_stripes &= ~(u32)1;
                 sub_stripes = 2;
         }
+
+        if (type & BTRFS_BLOCK_GROUP_DATA) {
+                max_chunk_size = 10 * calc_size;
+                min_chunk_size = 256 * 1024 * 1024;
+        } else if (type & BTRFS_BLOCK_GROUP_METADATA) {
+                max_chunk_size = 4 * calc_size;
+                min_chunk_size = 64 * 1024 * 1024;
+        } else {
+                min_chunk_size = 32 * 1024 * 1024;
+        }
+
+        /* we don't want a chunk larger than 10% of the FS */
+        percent_max = div_factor(btrfs_super_total_bytes(&info->super_copy), 1);
+        max_chunk_size = min(percent_max, max_chunk_size);
+
+        if (calc_size * num_stripes > max_chunk_size) {
+                calc_size = max_chunk_size;
+                do_div(calc_size, num_stripes);
+                do_div(calc_size, stripe_len);
+                calc_size *= stripe_len;
+        }
+        /* we don't want tiny stripes */
+        *num_bytes = chunk_bytes_by_type(type, calc_size,
+                                         num_stripes, sub_stripes);
+        calc_size = max_t(u64, chunk_bytes_by_type(type, min_chunk_size,
+                          num_stripes, sub_stripes), calc_size);
+
 again:
+        do_div(calc_size, stripe_len);
+        calc_size *= stripe_len;
+
         INIT_LIST_HEAD(&private_devs);
         cur = dev_list->next;
         index = 0;
 
         if (type & BTRFS_BLOCK_GROUP_DUP)
                 min_free = calc_size * 2;
+        else
+                min_free = calc_size;
 
         /* build a private list of devices we will allocate from */
         while(index < num_stripes) {
@@ -727,13 +785,9 @@ again:
         }
 
         stripes = &chunk->stripe;
+        *num_bytes = chunk_bytes_by_type(type, calc_size,
+                                         num_stripes, sub_stripes);
 
-        if (type & (BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_DUP))
-                *num_bytes = calc_size;
-        else if (type & BTRFS_BLOCK_GROUP_RAID10)
-                *num_bytes = calc_size * (num_stripes / sub_stripes);
-        else
-                *num_bytes = calc_size * num_stripes;
 
         index = 0;
 printk("new chunk type %Lu start %Lu size %Lu\n", type, key.offset, *num_bytes);