-#include <linux/module.h>
+/*
+ * Copyright (C) 2007 Oracle. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#include <linux/bio.h>
+#include <linux/pagemap.h>
+#include <linux/highmem.h>
#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
+#include "print-tree.h"
#define MAX_CSUM_ITEMS(r) ((((BTRFS_LEAF_DATA_SIZE(r) - \
- sizeof(struct btrfs_item) * 2) / \
- sizeof(struct btrfs_csum_item)) - 1))
+ sizeof(struct btrfs_item) * 2) / \
+ BTRFS_CRC32_SIZE) - 1))
int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- u64 objectid, u64 pos,
- u64 offset, u64 num_blocks)
+ struct btrfs_root *root,
+ u64 objectid, u64 pos,
+ u64 disk_offset, u64 disk_num_bytes,
+ u64 num_bytes, u64 offset)
{
int ret = 0;
struct btrfs_file_extent_item *item;
struct btrfs_key file_key;
struct btrfs_path *path;
+ struct extent_buffer *leaf;
path = btrfs_alloc_path();
BUG_ON(!path);
- btrfs_init_path(path);
file_key.objectid = objectid;
file_key.offset = pos;
- file_key.flags = 0;
btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY);
ret = btrfs_insert_empty_item(trans, root, path, &file_key,
sizeof(*item));
+ if (ret < 0)
+ goto out;
BUG_ON(ret);
- item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
+ leaf = path->nodes[0];
+ item = btrfs_item_ptr(leaf, path->slots[0],
struct btrfs_file_extent_item);
- btrfs_set_file_extent_disk_blocknr(item, offset);
- btrfs_set_file_extent_disk_num_blocks(item, num_blocks);
- btrfs_set_file_extent_offset(item, 0);
- btrfs_set_file_extent_num_blocks(item, num_blocks);
- btrfs_set_file_extent_generation(item, trans->transid);
- btrfs_mark_buffer_dirty(path->nodes[0]);
-
- btrfs_release_path(root, path);
+ btrfs_set_file_extent_disk_bytenr(leaf, item, disk_offset);
+ btrfs_set_file_extent_disk_num_bytes(leaf, item, disk_num_bytes);
+ btrfs_set_file_extent_offset(leaf, item, offset);
+ btrfs_set_file_extent_num_bytes(leaf, item, num_bytes);
+ btrfs_set_file_extent_generation(leaf, item, trans->transid);
+ btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG);
+ btrfs_mark_buffer_dirty(leaf);
+out:
btrfs_free_path(path);
- return 0;
+ return ret;
}
struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
struct btrfs_key file_key;
struct btrfs_key found_key;
struct btrfs_csum_item *item;
- struct btrfs_leaf *leaf;
+ struct extent_buffer *leaf;
u64 csum_offset = 0;
int csums_in_item;
file_key.objectid = objectid;
file_key.offset = offset;
- file_key.flags = 0;
btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY);
ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow);
if (ret < 0)
goto fail;
- leaf = btrfs_buffer_leaf(path->nodes[0]);
+ leaf = path->nodes[0];
if (ret > 0) {
ret = 1;
if (path->slots[0] == 0)
goto fail;
path->slots[0]--;
- btrfs_disk_key_to_cpu(&found_key,
- &leaf->items[path->slots[0]].key);
+ btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY ||
found_key.objectid != objectid) {
goto fail;
}
csum_offset = (offset - found_key.offset) >>
root->fs_info->sb->s_blocksize_bits;
- csums_in_item = btrfs_item_size(leaf->items + path->slots[0]);
- csums_in_item /= sizeof(struct btrfs_csum_item);
+ csums_in_item = btrfs_item_size_nr(leaf, path->slots[0]);
+ csums_in_item /= BTRFS_CRC32_SIZE;
if (csum_offset >= csums_in_item) {
ret = -EFBIG;
}
}
item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
- item += csum_offset;
+ item = (struct btrfs_csum_item *)((unsigned char *)item +
+ csum_offset * BTRFS_CRC32_SIZE);
return item;
fail:
if (ret > 0)
file_key.objectid = objectid;
file_key.offset = offset;
- file_key.flags = 0;
btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY);
ret = btrfs_search_slot(trans, root, &file_key, path, ins_len, cow);
return ret;
}
-int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- u64 objectid, u64 offset,
- char *data, size_t len)
+int btrfs_csum_one_bio(struct btrfs_root *root,
+ struct bio *bio, char **sums_ret)
{
+ u32 *sums;
+ char *data;
+ struct bio_vec *bvec = bio->bi_io_vec;
+ int bio_index = 0;
+
+ sums = kmalloc(bio->bi_vcnt * BTRFS_CRC32_SIZE, GFP_NOFS);
+ if (!sums)
+ return -ENOMEM;
+ *sums_ret = (char *)sums;
+
+ while(bio_index < bio->bi_vcnt) {
+ data = kmap_atomic(bvec->bv_page, KM_USER0);
+ *sums = ~(u32)0;
+ *sums = btrfs_csum_data(root, data + bvec->bv_offset,
+ *sums, bvec->bv_len);
+ kunmap_atomic(data, KM_USER0);
+ btrfs_csum_final(*sums, (char *)sums);
+ sums++;
+ bio_index++;
+ bvec++;
+ }
+ return 0;
+}
+
+int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
+ struct btrfs_root *root, struct inode *inode,
+ struct bio *bio, char *sums)
+{
+ u64 objectid = inode->i_ino;
+ u64 offset;
int ret;
struct btrfs_key file_key;
struct btrfs_key found_key;
+ u64 next_offset;
+ int found_next;
struct btrfs_path *path;
struct btrfs_csum_item *item;
- struct btrfs_leaf *leaf;
+ struct btrfs_csum_item *item_end;
+ struct extent_buffer *leaf = NULL;
u64 csum_offset;
+ u32 *sums32 = (u32 *)sums;
+ u32 nritems;
+ u32 ins_size;
+ int bio_index = 0;
+ struct bio_vec *bvec = bio->bi_io_vec;
+ char *eb_map;
+ char *eb_token;
+ unsigned long map_len;
+ unsigned long map_start;
path = btrfs_alloc_path();
BUG_ON(!path);
-
+again:
+ next_offset = (u64)-1;
+ found_next = 0;
+ offset = page_offset(bvec->bv_page) + bvec->bv_offset;
file_key.objectid = objectid;
file_key.offset = offset;
- file_key.flags = 0;
btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY);
item = btrfs_lookup_csum(trans, root, path, objectid, offset, 1);
- if (!IS_ERR(item))
+ if (!IS_ERR(item)) {
+ leaf = path->nodes[0];
goto found;
+ }
ret = PTR_ERR(item);
if (ret == -EFBIG) {
u32 item_size;
/* we found one, but it isn't big enough yet */
- leaf = btrfs_buffer_leaf(path->nodes[0]);
- item_size = btrfs_item_size(leaf->items + path->slots[0]);
- if ((item_size / sizeof(struct btrfs_csum_item)) >=
- MAX_CSUM_ITEMS(root)) {
+ leaf = path->nodes[0];
+ item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+ if ((item_size / BTRFS_CRC32_SIZE) >= MAX_CSUM_ITEMS(root)) {
/* already at max size, make a new one */
goto insert;
}
} else {
+ int slot = path->slots[0] + 1;
/* we didn't find a csum item, insert one */
+ nritems = btrfs_header_nritems(path->nodes[0]);
+ if (path->slots[0] >= nritems - 1) {
+ ret = btrfs_next_leaf(root, path);
+ if (ret == 1)
+ found_next = 1;
+ if (ret != 0)
+ goto insert;
+ slot = 0;
+ }
+ btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot);
+ if (found_key.objectid != objectid ||
+ found_key.type != BTRFS_CSUM_ITEM_KEY) {
+ found_next = 1;
+ goto insert;
+ }
+ next_offset = found_key.offset;
+ found_next = 1;
goto insert;
}
*/
btrfs_release_path(root, path);
ret = btrfs_search_slot(trans, root, &file_key, path,
- sizeof(struct btrfs_csum_item), 1);
+ BTRFS_CRC32_SIZE, 1);
if (ret < 0)
goto fail;
if (ret == 0) {
goto insert;
}
path->slots[0]--;
- leaf = btrfs_buffer_leaf(path->nodes[0]);
- btrfs_disk_key_to_cpu(&found_key, &leaf->items[path->slots[0]].key);
+ leaf = path->nodes[0];
+ btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
csum_offset = (offset - found_key.offset) >>
root->fs_info->sb->s_blocksize_bits;
if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY ||
found_key.objectid != objectid ||
csum_offset >= MAX_CSUM_ITEMS(root)) {
- WARN_ON(1);
goto insert;
}
- if (csum_offset >= btrfs_item_size(leaf->items + path->slots[0]) /
- sizeof(struct btrfs_csum_item)) {
- u32 diff = (csum_offset + 1) * sizeof(struct btrfs_csum_item);
- diff = diff - btrfs_item_size(leaf->items + path->slots[0]);
- WARN_ON(diff != sizeof(struct btrfs_csum_item));
+ if (csum_offset >= btrfs_item_size_nr(leaf, path->slots[0]) /
+ BTRFS_CRC32_SIZE) {
+ u32 diff = (csum_offset + 1) * BTRFS_CRC32_SIZE;
+ diff = diff - btrfs_item_size_nr(leaf, path->slots[0]);
+ if (diff != BTRFS_CRC32_SIZE)
+ goto insert;
ret = btrfs_extend_item(trans, root, path, diff);
BUG_ON(ret);
goto csum;
insert:
btrfs_release_path(root, path);
csum_offset = 0;
+ if (found_next) {
+ u64 tmp = min((u64)i_size_read(inode), next_offset);
+ tmp -= offset & ~((u64)root->sectorsize -1);
+ tmp >>= root->fs_info->sb->s_blocksize_bits;
+ tmp = max((u64)1, tmp);
+ tmp = min(tmp, (u64)MAX_CSUM_ITEMS(root));
+ ins_size = BTRFS_CRC32_SIZE * tmp;
+ } else {
+ ins_size = BTRFS_CRC32_SIZE;
+ }
ret = btrfs_insert_empty_item(trans, root, path, &file_key,
- sizeof(struct btrfs_csum_item));
+ ins_size);
+ if (ret < 0)
+ goto fail;
if (ret != 0) {
- printk("at insert for %Lu %u %Lu ret is %d\n", file_key.objectid, file_key.flags, file_key.offset, ret);
WARN_ON(1);
goto fail;
}
csum:
- item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
- struct btrfs_csum_item);
+ leaf = path->nodes[0];
+ item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
ret = 0;
- item += csum_offset;
+ item = (struct btrfs_csum_item *)((unsigned char *)item +
+ csum_offset * BTRFS_CRC32_SIZE);
found:
- btrfs_check_bounds(item->csum, BTRFS_CSUM_SIZE, path->nodes[0]->b_data, root->fs_info->sb->s_blocksize);
- ret = btrfs_csum_data(root, data, len, item->csum);
+ item_end = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
+ item_end = (struct btrfs_csum_item *)((unsigned char *)item_end +
+ btrfs_item_size_nr(leaf, path->slots[0]));
+ eb_token = NULL;
+next_bvec:
+
+ if (!eb_token ||
+ (unsigned long)item + BTRFS_CRC32_SIZE >= map_start + map_len) {
+ int err;
+
+ if (eb_token)
+ unmap_extent_buffer(leaf, eb_token, KM_USER1);
+ eb_token = NULL;
+ err = map_private_extent_buffer(leaf, (unsigned long)item,
+ BTRFS_CRC32_SIZE,
+ &eb_token, &eb_map,
+ &map_start, &map_len, KM_USER1);
+ if (err)
+ eb_token = NULL;
+ }
+ if (eb_token) {
+ memcpy(eb_token + ((unsigned long)item & (PAGE_CACHE_SIZE - 1)),
+ sums32, BTRFS_CRC32_SIZE);
+ } else {
+ write_extent_buffer(leaf, sums32, (unsigned long)item,
+ BTRFS_CRC32_SIZE);
+ }
+ bio_index++;
+ bvec++;
+ sums32++;
+ if (bio_index < bio->bi_vcnt) {
+ item = (struct btrfs_csum_item *)((char *)item +
+ BTRFS_CRC32_SIZE);
+ if (item < item_end && offset + PAGE_CACHE_SIZE ==
+ page_offset(bvec->bv_page)) {
+ offset = page_offset(bvec->bv_page);
+ goto next_bvec;
+ }
+ }
+ if (eb_token) {
+ unmap_extent_buffer(leaf, eb_token, KM_USER1);
+ eb_token = NULL;
+ }
btrfs_mark_buffer_dirty(path->nodes[0]);
+ if (bio_index < bio->bi_vcnt) {
+ btrfs_release_path(root, path);
+ goto again;
+ }
fail:
- btrfs_release_path(root, path);
btrfs_free_path(path);
return ret;
}
-int btrfs_csum_verify_file_block(struct btrfs_root *root,
- u64 objectid, u64 offset,
- char *data, size_t len)
+int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
+ struct btrfs_root *root, struct btrfs_path *path,
+ u64 isize)
{
+ struct btrfs_key key;
+ struct extent_buffer *leaf = path->nodes[0];
+ int slot = path->slots[0];
int ret;
- struct btrfs_key file_key;
- struct btrfs_path *path;
- struct btrfs_csum_item *item;
- char result[BTRFS_CSUM_SIZE];
+ u32 new_item_size;
+ u64 new_item_span;
+ u64 blocks;
- path = btrfs_alloc_path();
- BUG_ON(!path);
- btrfs_init_path(path);
- file_key.objectid = objectid;
- file_key.offset = offset;
- file_key.flags = 0;
- btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY);
- mutex_lock(&root->fs_info->fs_mutex);
-
- item = btrfs_lookup_csum(NULL, root, path, objectid, offset, 0);
- if (IS_ERR(item)) {
- ret = PTR_ERR(item);
- /* a csum that isn't present is a preallocated region. */
- if (ret == -ENOENT || ret == -EFBIG)
- ret = 1;
- goto fail;
- }
-
- ret = btrfs_csum_data(root, data, len, result);
- WARN_ON(ret);
- if (memcmp(result, item->csum, BTRFS_CSUM_SIZE))
- ret = 1;
-fail:
- btrfs_release_path(root, path);
- btrfs_free_path(path);
- mutex_unlock(&root->fs_info->fs_mutex);
+ btrfs_item_key_to_cpu(leaf, &key, slot);
+ if (isize <= key.offset)
+ return 0;
+ new_item_span = isize - key.offset;
+ blocks = (new_item_span + root->sectorsize - 1) >>
+ root->fs_info->sb->s_blocksize_bits;
+ new_item_size = blocks * BTRFS_CRC32_SIZE;
+ if (new_item_size >= btrfs_item_size_nr(leaf, slot))
+ return 0;
+ ret = btrfs_truncate_item(trans, root, path, new_item_size, 1);
+ BUG_ON(ret);
return ret;
}
git://ftp.safe.ca / safe / jmp / linux-2.6 / blobdiff