Btrfs: cleanup xattr code

[safe/jmp/linux-2.6] / fs / btrfs / file-item.c

diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index df04476..9646524 100644 (file)
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -24,9 +24,15 @@
 #include "transaction.h"
 #include "print-tree.h"
 
-#define MAX_CSUM_ITEMS(r,size) ((((BTRFS_LEAF_DATA_SIZE(r) - \
+#define MAX_CSUM_ITEMS(r, size) ((((BTRFS_LEAF_DATA_SIZE(r) - \
                                   sizeof(struct btrfs_item) * 2) / \
                                  size) - 1))
+
+#define MAX_ORDERED_SUM_BYTES(r) ((PAGE_SIZE - \
+                                  sizeof(struct btrfs_ordered_sum)) / \
+                                  sizeof(struct btrfs_sector_sum) * \
+                                  (r)->sectorsize - (r)->sectorsize)
+
 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
                             struct btrfs_root *root,
                             u64 objectid, u64 pos,
@@ -166,7 +172,7 @@ int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
        WARN_ON(bio->bi_vcnt <= 0);
 
        disk_bytenr = (u64)bio->bi_sector << 9;
-       while(bio_index < bio->bi_vcnt) {
+       while (bio_index < bio->bi_vcnt) {
                offset = page_offset(bvec->bv_page) + bvec->bv_offset;
                ret = btrfs_find_ordered_sum(inode, offset, disk_bytenr, &sum);
                if (ret == 0)
@@ -192,8 +198,9 @@ int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
                                                offset + bvec->bv_len - 1,
                                                EXTENT_NODATASUM, GFP_NOFS);
                                } else {
-                                       printk("no csum found for inode %lu "
-                                              "start %llu\n", inode->i_ino,
+                                       printk(KERN_INFO "btrfs no csum found "
+                                              "for inode %lu start %llu\n",
+                                              inode->i_ino,
                                               (unsigned long long)offset);
                                }
                                item = NULL;
@@ -258,8 +265,7 @@ int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
        key.offset = start;
        key.type = BTRFS_EXTENT_CSUM_KEY;
 
-       ret = btrfs_search_slot(NULL, root->fs_info->csum_root,
-                               &key, path, 0, 0);
+       ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
        if (ret < 0)
                goto fail;
        if (ret > 0 && path->slots[0] > 0) {
@@ -278,7 +284,7 @@ int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
        while (start <= end) {
                leaf = path->nodes[0];
                if (path->slots[0] >= btrfs_header_nritems(leaf)) {
-                       ret = btrfs_next_leaf(root->fs_info->csum_root, path);
+                       ret = btrfs_next_leaf(root, path);
                        if (ret < 0)
                                goto fail;
                        if (ret > 0)
@@ -300,34 +306,43 @@ int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
 
                size = btrfs_item_size_nr(leaf, path->slots[0]);
                csum_end = key.offset + (size / csum_size) * root->sectorsize;
+               if (csum_end <= start) {
+                       path->slots[0]++;
+                       continue;
+               }
 
-               size = min(csum_end, end + 1) - start;
-               sums = kzalloc(btrfs_ordered_sum_size(root, size), GFP_NOFS);
-               BUG_ON(!sums);
+               csum_end = min(csum_end, end + 1);
+               item = btrfs_item_ptr(path->nodes[0], path->slots[0],
+                                     struct btrfs_csum_item);
+               while (start < csum_end) {
+                       size = min_t(size_t, csum_end - start,
+                                       MAX_ORDERED_SUM_BYTES(root));
+                       sums = kzalloc(btrfs_ordered_sum_size(root, size),
+                                       GFP_NOFS);
+                       BUG_ON(!sums);
 
-               sector_sum = sums->sums;
-               sums->bytenr = start;
-               sums->len = size;
+                       sector_sum = sums->sums;
+                       sums->bytenr = start;
+                       sums->len = size;
 
-               offset = (start - key.offset) >>
-                        root->fs_info->sb->s_blocksize_bits;
-               offset *= csum_size;
+                       offset = (start - key.offset) >>
+                               root->fs_info->sb->s_blocksize_bits;
+                       offset *= csum_size;
 
-               item = btrfs_item_ptr(path->nodes[0], path->slots[0],
-                                     struct btrfs_csum_item);
-               while (size > 0) {
-                       read_extent_buffer(path->nodes[0], &sector_sum->sum,
-                                          ((unsigned long)item) + offset,
-                                          csum_size);
-                       sector_sum->bytenr = start;
-
-                       size -= root->sectorsize;
-                       start += root->sectorsize;
-                       offset += csum_size;
-                       sector_sum++;
+                       while (size > 0) {
+                               read_extent_buffer(path->nodes[0],
+                                               &sector_sum->sum,
+                                               ((unsigned long)item) +
+                                               offset, csum_size);
+                               sector_sum->bytenr = start;
+
+                               size -= root->sectorsize;
+                               start += root->sectorsize;
+                               offset += csum_size;
+                               sector_sum++;
+                       }
+                       list_add_tail(&sums->list, list);
                }
-               list_add_tail(&sums->list, list);
-
                path->slots[0]++;
        }
        ret = 0;
@@ -369,7 +384,7 @@ int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
        BUG_ON(!ordered);
        sums->bytenr = ordered->start;
 
-       while(bio_index < bio->bi_vcnt) {
+       while (bio_index < bio->bi_vcnt) {
                if (!contig)
                        offset = page_offset(bvec->bv_page) + bvec->bv_offset;
 
@@ -503,7 +518,7 @@ int btrfs_del_csums(struct btrfs_trans_handle *trans,
 
        path = btrfs_alloc_path();
 
-       while(1) {
+       while (1) {
                key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
                key.offset = end_byte - 1;
                key.type = BTRFS_EXTENT_CSUM_KEY;
@@ -537,6 +552,8 @@ int btrfs_del_csums(struct btrfs_trans_handle *trans,
                if (key.offset >= bytenr && csum_end <= end_byte) {
                        ret = btrfs_del_item(trans, root, path);
                        BUG_ON(ret);
+                       if (key.offset == bytenr)
+                               break;
                } else if (key.offset < bytenr && csum_end > end_byte) {
                        unsigned long offset;
                        unsigned long shift_len;
@@ -583,6 +600,8 @@ int btrfs_del_csums(struct btrfs_trans_handle *trans,
                        ret = truncate_one_csum(trans, root, path,
                                                &key, bytenr, len);
                        BUG_ON(ret);
+                       if (key.offset < bytenr)
+                               break;
                }
                btrfs_release_path(root, path);
        }
@@ -707,9 +726,8 @@ again:
                        goto csum;
 
                diff = diff - btrfs_item_size_nr(leaf, path->slots[0]);
-               if (diff != csum_size) {
+               if (diff != csum_size)
                        goto insert;
-               }
 
                ret = btrfs_extend_item(trans, root, path, diff);
                BUG_ON(ret);
@@ -724,7 +742,7 @@ insert:
                u64 next_sector = sector_sum->bytenr;
                struct btrfs_sector_sum *next = sector_sum + 1;
 
-               while(tmp < sums->len) {
+               while (tmp < sums->len) {
                        if (next_sector + root->sectorsize != next->bytenr)
                                break;
                        tmp += root->sectorsize;