Btrfs: Allow large data extents in a single file to span into metadata block groups

[safe/jmp/linux-2.6] / fs / btrfs / extent-tree.c

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 7de7707..7405bd5 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -168,25 +168,34 @@ static u64 find_search_start(struct btrfs_root *root,
        u64 last;
        u64 start = 0;
        u64 end = 0;
+       u64 cache_miss = 0;
+       int wrapped = 0;
 
 again:
        ret = cache_block_group(root, cache);
        if (ret)
                goto out;
+
        last = max(search_start, cache->key.objectid);
 
        while(1) {
                ret = find_first_extent_bit(&root->fs_info->free_space_cache,
                                            last, &start, &end, EXTENT_DIRTY);
                if (ret) {
+                       if (!cache_miss)
+                               cache_miss = last;
                        goto new_group;
                }
 
                start = max(last, start);
                last = end + 1;
-               if (end + 1 - start < num)
+               if (last - start < num) {
+                       if (last == cache->key.objectid + cache->key.offset)
+                               cache_miss = start;
                        continue;
-               if (start + num >= cache->key.objectid + cache->key.offset)
+               }
+               if (data != BTRFS_BLOCK_GROUP_MIXED &&
+                   start + num >= cache->key.objectid + cache->key.offset)
                        goto new_group;
                return start;
        }
@@ -195,17 +204,33 @@ out:
 
 new_group:
        last = cache->key.objectid + cache->key.offset;
+wrapped:
        cache = btrfs_lookup_block_group(root->fs_info, last);
        if (!cache) {
+               if (!wrapped) {
+                       wrapped = 1;
+                       last = search_start;
+                       data = BTRFS_BLOCK_GROUP_MIXED;
+                       goto wrapped;
+               }
                return search_start;
        }
+       if (cache_miss && !cache->cached) {
+               cache_block_group(root, cache);
+               last = cache_miss;
+
+               cache = btrfs_lookup_block_group(root->fs_info, last);
+       }
        cache = btrfs_find_block_group(root, cache, last, data, 0);
        *cache_ret = cache;
+       cache_miss = 0;
        goto again;
 }
 
 static u64 div_factor(u64 num, int factor)
 {
+       if (factor == 10)
+               return num;
        num *= factor;
        do_div(num, 10);
        return num;
@@ -236,9 +261,12 @@ struct btrfs_block_group_cache *btrfs_find_block_group(struct btrfs_root *root,
        block_group_cache = &info->block_group_cache;
 
        if (!owner)
-               factor = 5;
+               factor = 8;
 
-       if (data)
+       if (data == BTRFS_BLOCK_GROUP_MIXED) {
+               bit = BLOCK_GROUP_DATA | BLOCK_GROUP_METADATA;
+               factor = 10;
+       } else if (data)
                bit = BLOCK_GROUP_DATA;
        else
                bit = BLOCK_GROUP_METADATA;
@@ -246,14 +274,16 @@ struct btrfs_block_group_cache *btrfs_find_block_group(struct btrfs_root *root,
        if (search_start) {
                struct btrfs_block_group_cache *shint;
                shint = btrfs_lookup_block_group(info, search_start);
-               if (shint && shint->data == data) {
+               if (shint && (shint->data == data ||
+                             shint->data == BTRFS_BLOCK_GROUP_MIXED)) {
                        used = btrfs_block_group_used(&shint->item);
                        if (used < div_factor(shint->key.offset, factor)) {
                                return shint;
                        }
                }
        }
-       if (hint && hint->data == data) {
+       if (hint && (hint->data == data ||
+                    hint->data == BTRFS_BLOCK_GROUP_MIXED)) {
                used = btrfs_block_group_used(&hint->item);
                if (used < div_factor(hint->key.offset, factor)) {
                        return hint;
@@ -588,16 +618,19 @@ static int update_block_group(struct btrfs_trans_handle *trans,
                            old_val < (cache->key.offset >> 1)) {
                                int bit_to_clear;
                                int bit_to_set;
-
                                cache->data = data;
                                if (data) {
-                                       bit_to_clear = BLOCK_GROUP_DATA;
-                                       bit_to_set = BLOCK_GROUP_METADATA;
+                                       bit_to_clear = BLOCK_GROUP_METADATA;
+                                       bit_to_set = BLOCK_GROUP_DATA;
+                                       cache->item.flags &=
+                                               ~BTRFS_BLOCK_GROUP_MIXED;
                                        cache->item.flags |=
                                                BTRFS_BLOCK_GROUP_DATA;
                                } else {
-                                       bit_to_clear = BLOCK_GROUP_METADATA;
-                                       bit_to_set = BLOCK_GROUP_DATA;
+                                       bit_to_clear = BLOCK_GROUP_DATA;
+                                       bit_to_set = BLOCK_GROUP_METADATA;
+                                       cache->item.flags &=
+                                               ~BTRFS_BLOCK_GROUP_MIXED;
                                        cache->item.flags &=
                                                ~BTRFS_BLOCK_GROUP_DATA;
                                }
@@ -607,6 +640,14 @@ static int update_block_group(struct btrfs_trans_handle *trans,
                                set_extent_bits(&info->block_group_cache,
                                                start, end, bit_to_set,
                                                GFP_NOFS);
+                       } else if (cache->data != data &&
+                                  cache->data != BTRFS_BLOCK_GROUP_MIXED) {
+                               cache->data = BTRFS_BLOCK_GROUP_MIXED;
+                               set_extent_bits(&info->block_group_cache,
+                                               start, end,
+                                               BLOCK_GROUP_DATA |
+                                               BLOCK_GROUP_METADATA,
+                                               GFP_NOFS);
                        }
                        old_val += num_bytes;
                } else {
@@ -715,7 +756,7 @@ static int pin_down_bytes(struct btrfs_root *root, u64 bytenr, u32 num_bytes,
                                    root->fs_info->running_transaction->transid;
                                if (btrfs_header_generation(buf) == transid) {
                                        free_extent_buffer(buf);
-                                       return 0;
+                                       return 1;
                                }
                        }
                        free_extent_buffer(buf);
@@ -775,7 +816,9 @@ static int __free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
 
                if (pin) {
                        ret = pin_down_bytes(root, bytenr, num_bytes, 0);
-                       BUG_ON(ret);
+                       if (ret > 0)
+                               mark_free = 1;
+                       BUG_ON(ret < 0);
                }
 
                /* block accounting for super block */
@@ -885,12 +928,17 @@ static int find_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
        struct btrfs_block_group_cache *block_group;
        int full_scan = 0;
        int wrapped = 0;
+       u64 cached_start;
 
        WARN_ON(num_bytes < root->sectorsize);
        btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY);
 
        level = btrfs_header_level(root->node);
 
+       if (num_bytes >= 96 * 1024 * 1024 && hint_byte) {
+               data = BTRFS_BLOCK_GROUP_MIXED;
+       }
+
        if (search_end == (u64)-1)
                search_end = btrfs_super_total_bytes(&info->super_copy);
        if (hint_byte) {
@@ -909,6 +957,8 @@ static int find_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
 check_failed:
        search_start = find_search_start(root, &block_group,
                                         search_start, total_needed, data);
+       cached_start = search_start;
+
        btrfs_init_path(path);
        ins->objectid = search_start;
        ins->offset = 0;
@@ -993,7 +1043,8 @@ check_failed:
                start_found = 1;
                last_byte = key.objectid + key.offset;
 
-               if (!full_scan && last_byte >= block_group->key.objectid +
+               if (!full_scan && data != BTRFS_BLOCK_GROUP_MIXED &&
+                   last_byte >= block_group->key.objectid +
                    block_group->key.offset) {
                        btrfs_release_path(root, path);
                        search_start = block_group->key.objectid +
@@ -1014,7 +1065,8 @@ check_pending:
        if (ins->objectid + num_bytes >= search_end)
                goto enospc;
 
-       if (!full_scan && ins->objectid + num_bytes >= block_group->
+       if (!full_scan && data != BTRFS_BLOCK_GROUP_MIXED &&
+           ins->objectid + num_bytes >= block_group->
            key.objectid + block_group->key.offset) {
                search_start = block_group->key.objectid +
                        block_group->key.offset;
@@ -1459,13 +1511,16 @@ int btrfs_free_block_groups(struct btrfs_fs_info *info)
 {
        u64 start;
        u64 end;
+       u64 ptr;
        int ret;
-
        while(1) {
                ret = find_first_extent_bit(&info->block_group_cache, 0,
                                            &start, &end, (unsigned int)-1);
                if (ret)
                        break;
+               ret = get_state_private(&info->block_group_cache, start, &ptr);
+               if (!ret)
+                       kfree((void *)(unsigned long)ptr);
                clear_extent_bits(&info->block_group_cache, start,
                                  end, (unsigned int)-1, GFP_NOFS);
        }
@@ -1528,9 +1583,12 @@ int btrfs_read_block_groups(struct btrfs_root *root)
                key.objectid = found_key.objectid + found_key.offset;
                btrfs_release_path(root, path);
 
-               if (cache->item.flags & BTRFS_BLOCK_GROUP_DATA) {
+               if (cache->item.flags & BTRFS_BLOCK_GROUP_MIXED) {
+                       bit = BLOCK_GROUP_DATA | BLOCK_GROUP_METADATA;
+                       cache->data = BTRFS_BLOCK_GROUP_MIXED;
+               } else if (cache->item.flags & BTRFS_BLOCK_GROUP_DATA) {
                        bit = BLOCK_GROUP_DATA;
-                       cache->data = 1;
+                       cache->data = BTRFS_BLOCK_GROUP_DATA;
                } else {
                        bit = BLOCK_GROUP_METADATA;
                        cache->data = 0;