git.samba.org / sfrench / cifs-2.6.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
btrfs: don't check stripe length if the profile is not stripe based
[sfrench/cifs-2.6.git] / fs / btrfs / ctree.c
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index f704339c6b8652a0c3cc1dded80c20b2426a7fb2..94b2be118b5018489bd20ab928eb93f26aa41388 100644 (file)
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -2616,19 +2616,14 @@ static noinline int split_node(struct btrfs_trans_handle *trans,
  */
 static int leaf_space_used(struct extent_buffer *l, int start, int nr)
 {
-       struct btrfs_item *start_item;
-       struct btrfs_item *end_item;
        int data_len;
        int nritems = btrfs_header_nritems(l);
        int end = min(nritems, start + nr) - 1;
 
        if (!nr)
                return 0;
-       start_item = btrfs_item_nr(start);
-       end_item = btrfs_item_nr(end);
-       data_len = btrfs_item_offset(l, start_item) +
-                  btrfs_item_size(l, start_item);
-       data_len = data_len - btrfs_item_offset(l, end_item);
+       data_len = btrfs_item_offset(l, start) + btrfs_item_size(l, start);
+       data_len = data_len - btrfs_item_offset(l, end);
        data_len += sizeof(struct btrfs_item) * nr;
        WARN_ON(data_len < 0);
        return data_len;
@@ -2675,7 +2670,6 @@ static noinline int __push_leaf_right(struct btrfs_path *path,
        u32 i;
        int push_space = 0;
        int push_items = 0;
-       struct btrfs_item *item;
        u32 nr;
        u32 right_nritems;
        u32 data_end;
@@ -2692,8 +2686,6 @@ static noinline int __push_leaf_right(struct btrfs_path *path,
        slot = path->slots[1];
        i = left_nritems - 1;
        while (i >= nr) {
-               item = btrfs_item_nr(i);
-
                if (!empty && push_items > 0) {
                        if (path->slots[0] > i)
                                break;
@@ -2708,12 +2700,13 @@ static noinline int __push_leaf_right(struct btrfs_path *path,
                if (path->slots[0] == i)
                        push_space += data_size;
 
-               this_item_size = btrfs_item_size(left, item);
-               if (this_item_size + sizeof(*item) + push_space > free_space)
+               this_item_size = btrfs_item_size(left, i);
+               if (this_item_size + sizeof(struct btrfs_item) +
+                   push_space > free_space)
                        break;
 
                push_items++;
-               push_space += this_item_size + sizeof(*item);
+               push_space += this_item_size + sizeof(struct btrfs_item);
                if (i == 0)
                        break;
                i--;
@@ -2727,7 +2720,7 @@ static noinline int __push_leaf_right(struct btrfs_path *path,
        /* push left to right */
        right_nritems = btrfs_header_nritems(right);
 
-       push_space = btrfs_item_end_nr(left, left_nritems - push_items);
+       push_space = btrfs_item_data_end(left, left_nritems - push_items);
        push_space -= leaf_data_end(left);
 
        /* make room in the right data area */
@@ -2758,9 +2751,8 @@ static noinline int __push_leaf_right(struct btrfs_path *path,
        btrfs_set_header_nritems(right, right_nritems);
        push_space = BTRFS_LEAF_DATA_SIZE(fs_info);
        for (i = 0; i < right_nritems; i++) {
-               item = btrfs_item_nr(i);
-               push_space -= btrfs_token_item_size(&token, item);
-               btrfs_set_token_item_offset(&token, item, push_space);
+               push_space -= btrfs_token_item_size(&token, i);
+               btrfs_set_token_item_offset(&token, i, push_space);
        }
 
        left_nritems -= push_items;
@@ -2905,7 +2897,6 @@ static noinline int __push_leaf_left(struct btrfs_path *path, int data_size,
        int i;
        int push_space = 0;
        int push_items = 0;
-       struct btrfs_item *item;
        u32 old_left_nritems;
        u32 nr;
        int ret = 0;
@@ -2919,8 +2910,6 @@ static noinline int __push_leaf_left(struct btrfs_path *path, int data_size,
                nr = min(right_nritems - 1, max_slot);
 
        for (i = 0; i < nr; i++) {
-               item = btrfs_item_nr(i);
-
                if (!empty && push_items > 0) {
                        if (path->slots[0] < i)
                                break;
@@ -2935,12 +2924,13 @@ static noinline int __push_leaf_left(struct btrfs_path *path, int data_size,
                if (path->slots[0] == i)
                        push_space += data_size;
 
-               this_item_size = btrfs_item_size(right, item);
-               if (this_item_size + sizeof(*item) + push_space > free_space)
+               this_item_size = btrfs_item_size(right, i);
+               if (this_item_size + sizeof(struct btrfs_item) + push_space >
+                   free_space)
                        break;
 
                push_items++;
-               push_space += this_item_size + sizeof(*item);
+               push_space += this_item_size + sizeof(struct btrfs_item);
        }
 
        if (push_items == 0) {
@@ -2956,25 +2946,23 @@ static noinline int __push_leaf_left(struct btrfs_path *path, int data_size,
                           push_items * sizeof(struct btrfs_item));
 
        push_space = BTRFS_LEAF_DATA_SIZE(fs_info) -
-                    btrfs_item_offset_nr(right, push_items - 1);
+                    btrfs_item_offset(right, push_items - 1);
 
        copy_extent_buffer(left, right, BTRFS_LEAF_DATA_OFFSET +
                     leaf_data_end(left) - push_space,
                     BTRFS_LEAF_DATA_OFFSET +
-                    btrfs_item_offset_nr(right, push_items - 1),
+                    btrfs_item_offset(right, push_items - 1),
                     push_space);
        old_left_nritems = btrfs_header_nritems(left);
        BUG_ON(old_left_nritems <= 0);
 
        btrfs_init_map_token(&token, left);
-       old_left_item_size = btrfs_item_offset_nr(left, old_left_nritems - 1);
+       old_left_item_size = btrfs_item_offset(left, old_left_nritems - 1);
        for (i = old_left_nritems; i < old_left_nritems + push_items; i++) {
                u32 ioff;
 
-               item = btrfs_item_nr(i);
-
-               ioff = btrfs_token_item_offset(&token, item);
-               btrfs_set_token_item_offset(&token, item,
+               ioff = btrfs_token_item_offset(&token, i);
+               btrfs_set_token_item_offset(&token, i,
                      ioff - (BTRFS_LEAF_DATA_SIZE(fs_info) - old_left_item_size));
        }
        btrfs_set_header_nritems(left, old_left_nritems + push_items);
@@ -2985,7 +2973,7 @@ static noinline int __push_leaf_left(struct btrfs_path *path, int data_size,
                       right_nritems);
 
        if (push_items < right_nritems) {
-               push_space = btrfs_item_offset_nr(right, push_items - 1) -
+               push_space = btrfs_item_offset(right, push_items - 1) -
                                                  leaf_data_end(right);
                memmove_extent_buffer(right, BTRFS_LEAF_DATA_OFFSET +
                                      BTRFS_LEAF_DATA_SIZE(fs_info) - push_space,
@@ -3003,10 +2991,8 @@ static noinline int __push_leaf_left(struct btrfs_path *path, int data_size,
        btrfs_set_header_nritems(right, right_nritems);
        push_space = BTRFS_LEAF_DATA_SIZE(fs_info);
        for (i = 0; i < right_nritems; i++) {
-               item = btrfs_item_nr(i);
-
-               push_space = push_space - btrfs_token_item_size(&token, item);
-               btrfs_set_token_item_offset(&token, item, push_space);
+               push_space = push_space - btrfs_token_item_size(&token, i);
+               btrfs_set_token_item_offset(&token, i, push_space);
        }
 
        btrfs_mark_buffer_dirty(left);
@@ -3134,7 +3120,7 @@ static noinline void copy_for_split(struct btrfs_trans_handle *trans,
 
        nritems = nritems - mid;
        btrfs_set_header_nritems(right, nritems);
-       data_copy_size = btrfs_item_end_nr(l, mid) - leaf_data_end(l);
+       data_copy_size = btrfs_item_data_end(l, mid) - leaf_data_end(l);
 
        copy_extent_buffer(right, l, btrfs_item_nr_offset(0),
                           btrfs_item_nr_offset(mid),
@@ -3145,15 +3131,14 @@ static noinline void copy_for_split(struct btrfs_trans_handle *trans,
                     data_copy_size, BTRFS_LEAF_DATA_OFFSET +
                     leaf_data_end(l), data_copy_size);
 
-       rt_data_off = BTRFS_LEAF_DATA_SIZE(fs_info) - btrfs_item_end_nr(l, mid);
+       rt_data_off = BTRFS_LEAF_DATA_SIZE(fs_info) - btrfs_item_data_end(l, mid);
 
        btrfs_init_map_token(&token, right);
        for (i = 0; i < nritems; i++) {
-               struct btrfs_item *item = btrfs_item_nr(i);
                u32 ioff;
 
-               ioff = btrfs_token_item_offset(&token, item);
-               btrfs_set_token_item_offset(&token, item, ioff + rt_data_off);
+               ioff = btrfs_token_item_offset(&token, i);
+               btrfs_set_token_item_offset(&token, i, ioff + rt_data_off);
        }
 
        btrfs_set_header_nritems(l, mid);
@@ -3269,7 +3254,7 @@ static noinline int split_leaf(struct btrfs_trans_handle *trans,
 
        l = path->nodes[0];
        slot = path->slots[0];
-       if (extend && data_size + btrfs_item_size_nr(l, slot) +
+       if (extend && data_size + btrfs_item_size(l, slot) +
            sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(fs_info))
                return -EOVERFLOW;
 
@@ -3438,7 +3423,7 @@ static noinline int setup_leaf_for_split(struct btrfs_trans_handle *trans,
        if (btrfs_leaf_free_space(leaf) >= ins_len)
                return 0;
 
-       item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+       item_size = btrfs_item_size(leaf, path->slots[0]);
        if (key.type == BTRFS_EXTENT_DATA_KEY) {
                fi = btrfs_item_ptr(leaf, path->slots[0],
                                    struct btrfs_file_extent_item);
@@ -3458,7 +3443,7 @@ static noinline int setup_leaf_for_split(struct btrfs_trans_handle *trans,
        ret = -EAGAIN;
        leaf = path->nodes[0];
        /* if our item isn't there, return now */
-       if (item_size != btrfs_item_size_nr(leaf, path->slots[0]))
+       if (item_size != btrfs_item_size(leaf, path->slots[0]))
                goto err;
 
        /* the leaf has  changed, it now has room.  return now */
@@ -3489,9 +3474,7 @@ static noinline int split_item(struct btrfs_path *path,
                               unsigned long split_offset)
 {
        struct extent_buffer *leaf;
-       struct btrfs_item *item;
-       struct btrfs_item *new_item;
-       int slot;
+       int orig_slot, slot;
        char *buf;
        u32 nritems;
        u32 item_size;
@@ -3501,9 +3484,9 @@ static noinline int split_item(struct btrfs_path *path,
        leaf = path->nodes[0];
        BUG_ON(btrfs_leaf_free_space(leaf) < sizeof(struct btrfs_item));
 
-       item = btrfs_item_nr(path->slots[0]);
-       orig_offset = btrfs_item_offset(leaf, item);
-       item_size = btrfs_item_size(leaf, item);
+       orig_slot = path->slots[0];
+       orig_offset = btrfs_item_offset(leaf, path->slots[0]);
+       item_size = btrfs_item_size(leaf, path->slots[0]);
 
        buf = kmalloc(item_size, GFP_NOFS);
        if (!buf)
@@ -3524,14 +3507,12 @@ static noinline int split_item(struct btrfs_path *path,
        btrfs_cpu_key_to_disk(&disk_key, new_key);
        btrfs_set_item_key(leaf, &disk_key, slot);
 
-       new_item = btrfs_item_nr(slot);
-
-       btrfs_set_item_offset(leaf, new_item, orig_offset);
-       btrfs_set_item_size(leaf, new_item, item_size - split_offset);
+       btrfs_set_item_offset(leaf, slot, orig_offset);
+       btrfs_set_item_size(leaf, slot, item_size - split_offset);
 
-       btrfs_set_item_offset(leaf, item,
-                             orig_offset + item_size - split_offset);
-       btrfs_set_item_size(leaf, item, split_offset);
+       btrfs_set_item_offset(leaf, orig_slot,
+                                orig_offset + item_size - split_offset);
+       btrfs_set_item_size(leaf, orig_slot, split_offset);
 
        btrfs_set_header_nritems(leaf, nritems + 1);
 
@@ -3592,7 +3573,6 @@ void btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end)
 {
        int slot;
        struct extent_buffer *leaf;
-       struct btrfs_item *item;
        u32 nritems;
        unsigned int data_end;
        unsigned int old_data_start;
@@ -3604,14 +3584,14 @@ void btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end)
        leaf = path->nodes[0];
        slot = path->slots[0];
 
-       old_size = btrfs_item_size_nr(leaf, slot);
+       old_size = btrfs_item_size(leaf, slot);
        if (old_size == new_size)
                return;
 
        nritems = btrfs_header_nritems(leaf);
        data_end = leaf_data_end(leaf);
 
-       old_data_start = btrfs_item_offset_nr(leaf, slot);
+       old_data_start = btrfs_item_offset(leaf, slot);
 
        size_diff = old_size - new_size;
 
@@ -3625,10 +3605,9 @@ void btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end)
        btrfs_init_map_token(&token, leaf);
        for (i = slot; i < nritems; i++) {
                u32 ioff;
-               item = btrfs_item_nr(i);
 
-               ioff = btrfs_token_item_offset(&token, item);
-               btrfs_set_token_item_offset(&token, item, ioff + size_diff);
+               ioff = btrfs_token_item_offset(&token, i);
+               btrfs_set_token_item_offset(&token, i, ioff + size_diff);
        }
 
        /* shift the data */
@@ -3671,8 +3650,7 @@ void btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end)
                        fixup_low_keys(path, &disk_key, 1);
        }
 
-       item = btrfs_item_nr(slot);
-       btrfs_set_item_size(leaf, item, new_size);
+       btrfs_set_item_size(leaf, slot, new_size);
        btrfs_mark_buffer_dirty(leaf);
 
        if (btrfs_leaf_free_space(leaf) < 0) {
@@ -3688,7 +3666,6 @@ void btrfs_extend_item(struct btrfs_path *path, u32 data_size)
 {
        int slot;
        struct extent_buffer *leaf;
-       struct btrfs_item *item;
        u32 nritems;
        unsigned int data_end;
        unsigned int old_data;
@@ -3706,7 +3683,7 @@ void btrfs_extend_item(struct btrfs_path *path, u32 data_size)
                BUG();
        }
        slot = path->slots[0];
-       old_data = btrfs_item_end_nr(leaf, slot);
+       old_data = btrfs_item_data_end(leaf, slot);
 
        BUG_ON(slot < 0);
        if (slot >= nritems) {
@@ -3723,10 +3700,9 @@ void btrfs_extend_item(struct btrfs_path *path, u32 data_size)
        btrfs_init_map_token(&token, leaf);
        for (i = slot; i < nritems; i++) {
                u32 ioff;
-               item = btrfs_item_nr(i);
 
-               ioff = btrfs_token_item_offset(&token, item);
-               btrfs_set_token_item_offset(&token, item, ioff - data_size);
+               ioff = btrfs_token_item_offset(&token, i);
+               btrfs_set_token_item_offset(&token, i, ioff - data_size);
        }
 
        /* shift the data */
@@ -3735,9 +3711,8 @@ void btrfs_extend_item(struct btrfs_path *path, u32 data_size)
                      data_end, old_data - data_end);
 
        data_end = old_data;
-       old_size = btrfs_item_size_nr(leaf, slot);
-       item = btrfs_item_nr(slot);
-       btrfs_set_item_size(leaf, item, old_size + data_size);
+       old_size = btrfs_item_size(leaf, slot);
+       btrfs_set_item_size(leaf, slot, old_size + data_size);
        btrfs_mark_buffer_dirty(leaf);
 
        if (btrfs_leaf_free_space(leaf) < 0) {
@@ -3759,7 +3734,6 @@ static void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *p
                                   const struct btrfs_item_batch *batch)
 {
        struct btrfs_fs_info *fs_info = root->fs_info;
-       struct btrfs_item *item;
        int i;
        u32 nritems;
        unsigned int data_end;
@@ -3796,7 +3770,7 @@ static void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *p
 
        btrfs_init_map_token(&token, leaf);
        if (slot != nritems) {
-               unsigned int old_data = btrfs_item_end_nr(leaf, slot);
+               unsigned int old_data = btrfs_item_data_end(leaf, slot);
 
                if (old_data < data_end) {
                        btrfs_print_leaf(leaf);
@@ -3812,10 +3786,9 @@ static void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *p
                for (i = slot; i < nritems; i++) {
                        u32 ioff;
 
-                       item = btrfs_item_nr(i);
-                       ioff = btrfs_token_item_offset(&token, item);
-                       btrfs_set_token_item_offset(&token, item,
-                                                   ioff - batch->total_data_size);
+                       ioff = btrfs_token_item_offset(&token, i);
+                       btrfs_set_token_item_offset(&token, i,
+                                                      ioff - batch->total_data_size);
                }
                /* shift the items */
                memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + batch->nr),
@@ -3834,10 +3807,9 @@ static void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *p
        for (i = 0; i < batch->nr; i++) {
                btrfs_cpu_key_to_disk(&disk_key, &batch->keys[i]);
                btrfs_set_item_key(leaf, &disk_key, slot + i);
-               item = btrfs_item_nr(slot + i);
                data_end -= batch->data_sizes[i];
-               btrfs_set_token_item_offset(&token, item, data_end);
-               btrfs_set_token_item_size(&token, item, batch->data_sizes[i]);
+               btrfs_set_token_item_offset(&token, slot + i, data_end);
+               btrfs_set_token_item_size(&token, slot + i, batch->data_sizes[i]);
        }
 
        btrfs_set_header_nritems(leaf, nritems + batch->nr);
@@ -3944,7 +3916,7 @@ int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
        u32 item_size;
 
        leaf = path->nodes[0];
-       item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+       item_size = btrfs_item_size(leaf, path->slots[0]);
        ret = setup_leaf_for_split(trans, root, path,
                                   item_size + sizeof(struct btrfs_item));
        if (ret)
@@ -4045,7 +4017,6 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 {
        struct btrfs_fs_info *fs_info = root->fs_info;
        struct extent_buffer *leaf;
-       struct btrfs_item *item;
        u32 last_off;
        u32 dsize = 0;
        int ret = 0;
@@ -4054,10 +4025,10 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
        u32 nritems;
 
        leaf = path->nodes[0];
-       last_off = btrfs_item_offset_nr(leaf, slot + nr - 1);
+       last_off = btrfs_item_offset(leaf, slot + nr - 1);
 
        for (i = 0; i < nr; i++)
-               dsize += btrfs_item_size_nr(leaf, slot + i);
+               dsize += btrfs_item_size(leaf, slot + i);
 
        nritems = btrfs_header_nritems(leaf);
 
@@ -4074,9 +4045,8 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
                for (i = slot + nr; i < nritems; i++) {
                        u32 ioff;
 
-                       item = btrfs_item_nr(i);
-                       ioff = btrfs_token_item_offset(&token, item);
-                       btrfs_set_token_item_offset(&token, item, ioff + dsize);
+                       ioff = btrfs_token_item_offset(&token, i);
+                       btrfs_set_token_item_offset(&token, i, ioff + dsize);
                }
 
                memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot),
Unnamed repository; edit this file 'description' to name the repository.