struct btrfs_trans_handle *trans;
struct btrfs_key ins;
u64 alloc_hint = 0;
- u64 num_blocks;
+ u64 num_bytes;
int ret;
- u64 blocksize = 1 << inode->i_blkbits;
+ u64 blocksize = root->sectorsize;
mutex_lock(&root->fs_info->fs_mutex);
trans = btrfs_start_transaction(root, 1);
btrfs_set_trans_block_group(trans, inode);
BUG_ON(!trans);
- num_blocks = (end - start + blocksize) & ~(blocksize - 1);
+ num_bytes = (end - start + blocksize) & ~(blocksize - 1);
ret = btrfs_drop_extents(trans, root, inode,
- start, start + num_blocks, &alloc_hint);
- num_blocks = num_blocks >> inode->i_blkbits;
- ret = btrfs_alloc_extent(trans, root, inode->i_ino, num_blocks, 0,
+ start, start + num_bytes, start, &alloc_hint);
+
+ if (alloc_hint == EXTENT_MAP_INLINE)
+ goto out;
+
+ ret = btrfs_alloc_extent(trans, root, inode->i_ino, num_bytes, 0,
alloc_hint, (u64)-1, &ins, 1);
if (ret) {
WARN_ON(1);
struct btrfs_trans_handle *trans;
char *kaddr;
int ret;
- u64 page_start = page->index << PAGE_CACHE_SHIFT;
+ u64 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
size_t offset = start - page_start;
mutex_lock(&root->fs_info->fs_mutex);
trans = btrfs_start_transaction(root, 1);
btrfs_set_trans_block_group(trans, inode);
kaddr = kmap(page);
- btrfs_csum_file_block(trans, root, inode->i_ino,
+ btrfs_csum_file_block(trans, root, inode, inode->i_ino,
start, kaddr + offset, end - start + 1);
kunmap(page);
ret = btrfs_end_transaction(trans, root);
struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
struct btrfs_csum_item *item;
struct btrfs_path *path = NULL;
- u64 private;
+ u32 csum;
mutex_lock(&root->fs_info->fs_mutex);
path = btrfs_alloc_path();
/* a csum that isn't present is a preallocated region. */
if (ret == -ENOENT || ret == -EFBIG)
ret = 0;
- private = 0;
+ csum = 0;
goto out;
}
- memcpy((char *)&private, &item->csum, BTRFS_CRC32_SIZE);
- set_state_private(em_tree, start, private);
+ read_extent_buffer(path->nodes[0], &csum, (unsigned long)item,
+ BTRFS_CRC32_SIZE);
+ set_state_private(em_tree, start, csum);
out:
if (path)
btrfs_free_path(path);
int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end)
{
- size_t offset = start - (page->index << PAGE_CACHE_SHIFT);
+ size_t offset = start - ((u64)page->index << PAGE_CACHE_SHIFT);
struct inode *inode = page->mapping->host;
struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
char *kaddr;
u64 private;
int ret;
+ struct btrfs_root *root = BTRFS_I(inode)->root;
+ u32 csum = ~(u32)0;
+ unsigned long flags;
ret = get_state_private(em_tree, start, &private);
+ local_irq_save(flags);
kaddr = kmap_atomic(page, KM_IRQ0);
if (ret) {
goto zeroit;
}
- /*
- struct btrfs_root *root = BTRFS_I(inode)->root;
- char csum[BTRFS_CRC32_SIZE];
- ret = btrfs_csum_data(root, kaddr + offset, end - start + 1, csum);
- BUG_ON(ret);
- if (memcmp(csum, &private, BTRFS_CRC32_SIZE)) {
+ csum = btrfs_csum_data(root, kaddr + offset, csum, end - start + 1);
+ btrfs_csum_final(csum, (char *)&csum);
+ if (csum != private) {
goto zeroit;
}
- */
kunmap_atomic(kaddr, KM_IRQ0);
+ local_irq_restore(flags);
return 0;
zeroit:
printk("btrfs csum failed ino %lu off %llu\n",
page->mapping->host->i_ino, (unsigned long long)start);
- memset(kaddr + offset, 1, end - start + 1); flush_dcache_page(page);
+ memset(kaddr + offset, 1, end - start + 1);
+ flush_dcache_page(page);
kunmap_atomic(kaddr, KM_IRQ0);
+ local_irq_restore(flags);
return 0;
}
char *goodnames = "..";
unsigned long nr;
+ if (inode->i_size > BTRFS_EMPTY_DIR_SIZE)
+ return -ENOTEMPTY;
+
path = btrfs_alloc_path();
BUG_ON(!path);
mutex_lock(&root->fs_info->fs_mutex);
out:
btrfs_release_path(root, path);
btrfs_free_path(path);
- mutex_unlock(&root->fs_info->fs_mutex);
nr = trans->blocks_used;
ret = btrfs_end_transaction(trans, root);
+ mutex_unlock(&root->fs_info->fs_mutex);
btrfs_btree_balance_dirty(root, nr);
if (ret && !err)
err = ret;
struct extent_buffer *leaf;
struct btrfs_file_extent_item *fi;
u64 extent_start = 0;
- u64 extent_num_blocks = 0;
+ u64 extent_num_bytes = 0;
u64 item_end = 0;
int found_extent;
int del_item;
+ int extent_type = -1;
btrfs_drop_extent_cache(inode, inode->i_size, (u64)-1);
path = btrfs_alloc_path();
if (found_type == BTRFS_EXTENT_DATA_KEY) {
fi = btrfs_item_ptr(leaf, path->slots[0],
struct btrfs_file_extent_item);
- if (btrfs_file_extent_type(leaf, fi) !=
- BTRFS_FILE_EXTENT_INLINE) {
+ extent_type = btrfs_file_extent_type(leaf, fi);
+ if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
item_end +=
- btrfs_file_extent_num_blocks(leaf, fi) <<
- inode->i_blkbits;
+ btrfs_file_extent_num_bytes(leaf, fi);
+ } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
+ struct btrfs_item *item = btrfs_item_nr(leaf,
+ path->slots[0]);
+ item_end += btrfs_file_extent_inline_len(leaf,
+ item);
}
}
if (found_type == BTRFS_CSUM_ITEM_KEY) {
inode->i_size);
BUG_ON(ret);
}
- if (item_end < inode->i_size) {
+ if (item_end <= inode->i_size) {
if (found_type == BTRFS_DIR_ITEM_KEY) {
found_type = BTRFS_INODE_ITEM_KEY;
} else if (found_type == BTRFS_EXTENT_ITEM_KEY) {
break;
}
btrfs_set_key_type(&key, found_type);
+ btrfs_release_path(root, path);
continue;
}
if (found_key.offset >= inode->i_size)
found_extent = 0;
/* FIXME, shrink the extent if the ref count is only 1 */
- if (found_type == BTRFS_EXTENT_DATA_KEY &&
- btrfs_file_extent_type(leaf, fi) !=
- BTRFS_FILE_EXTENT_INLINE) {
+ if (found_type != BTRFS_EXTENT_DATA_KEY)
+ goto delete;
+
+ if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
u64 num_dec;
- extent_start = btrfs_file_extent_disk_blocknr(leaf, fi);
+ extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
if (!del_item) {
- u64 orig_num_blocks =
- btrfs_file_extent_num_blocks(leaf, fi);
- extent_num_blocks = inode->i_size -
+ u64 orig_num_bytes =
+ btrfs_file_extent_num_bytes(leaf, fi);
+ extent_num_bytes = inode->i_size -
found_key.offset + root->sectorsize - 1;
- extent_num_blocks >>= inode->i_blkbits;
- btrfs_set_file_extent_num_blocks(leaf, fi,
- extent_num_blocks);
- num_dec = (orig_num_blocks -
- extent_num_blocks) << 3;
+ btrfs_set_file_extent_num_bytes(leaf, fi,
+ extent_num_bytes);
+ num_dec = (orig_num_bytes -
+ extent_num_bytes) >> 9;
if (extent_start != 0) {
inode->i_blocks -= num_dec;
}
btrfs_mark_buffer_dirty(leaf);
} else {
- extent_num_blocks =
- btrfs_file_extent_disk_num_blocks(leaf,
- fi);
+ extent_num_bytes =
+ btrfs_file_extent_disk_num_bytes(leaf,
+ fi);
/* FIXME blocksize != 4096 */
- num_dec = btrfs_file_extent_num_blocks(leaf,
- fi) << 3;
+ num_dec = btrfs_file_extent_num_bytes(leaf,
+ fi) >> 9;
if (extent_start != 0) {
found_extent = 1;
inode->i_blocks -= num_dec;
}
}
+ } else if (extent_type == BTRFS_FILE_EXTENT_INLINE &&
+ !del_item) {
+ u32 newsize = inode->i_size - found_key.offset;
+ newsize = btrfs_file_extent_calc_inline_size(newsize);
+ ret = btrfs_truncate_item(trans, root, path,
+ newsize, 1);
+ BUG_ON(ret);
}
+delete:
if (del_item) {
ret = btrfs_del_item(trans, root, path);
if (ret)
btrfs_release_path(root, path);
if (found_extent) {
ret = btrfs_free_extent(trans, root, extent_start,
- extent_num_blocks, 0);
+ extent_num_bytes, 0);
BUG_ON(ret);
}
}
char *kaddr;
int ret = 0;
struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
- u64 page_start = page->index << PAGE_CACHE_SHIFT;
+ u64 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
set_page_extent_mapped(page);
static int btrfs_truncate_page(struct address_space *mapping, loff_t from)
{
struct inode *inode = mapping->host;
- unsigned blocksize = 1 << inode->i_blkbits;
+ struct btrfs_root *root = BTRFS_I(inode)->root;
+ u32 blocksize = root->sectorsize;
pgoff_t index = from >> PAGE_CACHE_SHIFT;
unsigned offset = from & (PAGE_CACHE_SIZE-1);
struct page *page;
if ((offset & (blocksize - 1)) == 0)
goto out;
- down_read(&BTRFS_I(inode)->root->snap_sem);
+ down_read(&root->snap_sem);
ret = -ENOMEM;
page = grab_cache_page(mapping, index);
if (!page)
goto out;
}
}
- page_start = page->index << PAGE_CACHE_SHIFT;
+ page_start = (u64)page->index << PAGE_CACHE_SHIFT;
ret = btrfs_cow_one_page(inode, page, offset);
u64 pos = (inode->i_size + mask) & ~mask;
u64 block_end = attr->ia_size | mask;
u64 hole_size;
- u64 alloc_hint;
+ u64 alloc_hint = 0;
if (attr->ia_size <= pos)
goto out;
trans = btrfs_start_transaction(root, 1);
btrfs_set_trans_block_group(trans, inode);
err = btrfs_drop_extents(trans, root, inode,
- pos, pos + hole_size, &alloc_hint);
-
- hole_size >>= inode->i_blkbits;
+ pos, pos + hole_size, pos,
+ &alloc_hint);
- err = btrfs_insert_file_extent(trans, root, inode->i_ino,
- pos, 0, 0, hole_size);
+ if (alloc_hint != EXTENT_MAP_INLINE) {
+ err = btrfs_insert_file_extent(trans, root,
+ inode->i_ino,
+ pos, 0, 0, hole_size);
+ }
btrfs_end_transaction(trans, root);
mutex_unlock(&root->fs_info->fs_mutex);
unlock_extent(em_tree, pos, block_end, GFP_NOFS);
struct btrfs_dir_item *di;
struct btrfs_path *path;
struct btrfs_root *root = BTRFS_I(dir)->root;
- int ret;
+ int ret = 0;
path = btrfs_alloc_path();
BUG_ON(!path);
di = btrfs_lookup_dir_item(NULL, root, path, dir->i_ino, name,
namelen, 0);
+ if (IS_ERR(di))
+ ret = PTR_ERR(di);
if (!di || IS_ERR(di)) {
location->objectid = 0;
- ret = 0;
goto out;
}
btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
{
int ret;
int err = 0;
- u64 blocknr;
+ u64 bytenr;
u64 extent_start = 0;
u64 extent_end = 0;
u64 objectid = inode->i_ino;
em->end = EXTENT_MAP_HOLE;
}
em->bdev = inode->i_sb->s_bdev;
- ret = btrfs_lookup_file_extent(NULL, root, path,
- objectid, start, 0);
+ ret = btrfs_lookup_file_extent(trans, root, path,
+ objectid, start, trans != NULL);
if (ret < 0) {
err = ret;
goto out;
leaf = path->nodes[0];
item = btrfs_item_ptr(leaf, path->slots[0],
struct btrfs_file_extent_item);
-
- blocknr = btrfs_file_extent_disk_blocknr(leaf, item);
- blocknr += btrfs_file_extent_offset(leaf, item);
-
/* are we inside the extent that was found? */
btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
found_type = btrfs_key_type(&found_key);
extent_start = found_key.offset;
if (found_type == BTRFS_FILE_EXTENT_REG) {
extent_end = extent_start +
- (btrfs_file_extent_num_blocks(leaf, item) <<
- inode->i_blkbits);
+ btrfs_file_extent_num_bytes(leaf, item);
err = 0;
if (start < extent_start || start >= extent_end) {
em->start = start;
}
goto not_found_em;
}
- if (btrfs_file_extent_disk_blocknr(leaf, item) == 0) {
+ bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
+ if (bytenr == 0) {
em->start = extent_start;
em->end = extent_end - 1;
em->block_start = EXTENT_MAP_HOLE;
em->block_end = EXTENT_MAP_HOLE;
goto insert;
}
- em->block_start = blocknr << inode->i_blkbits;
+ bytenr += btrfs_file_extent_offset(leaf, item);
+ em->block_start = bytenr;
em->block_end = em->block_start +
- (btrfs_file_extent_num_blocks(leaf, item) <<
- inode->i_blkbits) - 1;
+ btrfs_file_extent_num_bytes(leaf, item) - 1;
em->start = extent_start;
em->end = extent_end - 1;
goto insert;
} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
unsigned long ptr;
char *map;
- u32 size;
+ size_t size;
+ size_t extent_offset;
+ size_t copy_size;
size = btrfs_file_extent_inline_len(leaf, btrfs_item_nr(leaf,
path->slots[0]));
-
- extent_end = extent_start | ((u64)root->sectorsize - 1);
+ extent_end = (extent_start + size - 1) |
+ ((u64)root->sectorsize - 1);
if (start < extent_start || start >= extent_end) {
em->start = start;
if (start < extent_start) {
}
goto not_found_em;
}
-
em->block_start = EXTENT_MAP_INLINE;
em->block_end = EXTENT_MAP_INLINE;
- em->start = extent_start;
- em->end = extent_end;
if (!page) {
- goto insert;
+ em->start = extent_start;
+ em->end = extent_start + size - 1;
+ goto out;
}
- ptr = btrfs_file_extent_inline_start(item);
+ extent_offset = ((u64)page->index << PAGE_CACHE_SHIFT) -
+ extent_start + page_offset;
+ copy_size = min_t(u64, PAGE_CACHE_SIZE - page_offset,
+ size - extent_offset);
+ em->start = extent_start + extent_offset;
+ em->end = (em->start + copy_size -1) |
+ ((u64)root->sectorsize -1);
map = kmap(page);
- read_extent_buffer(leaf, map + page_offset, ptr, size);
- memset(map + page_offset + size, 0,
- root->sectorsize - (page_offset + size));
- flush_dcache_page(page);
+ ptr = btrfs_file_extent_inline_start(item) + extent_offset;
+ if (create == 0 && !PageUptodate(page)) {
+ read_extent_buffer(leaf, map + page_offset, ptr,
+ copy_size);
+ flush_dcache_page(page);
+ } else if (create && PageUptodate(page)) {
+ if (!trans) {
+ kunmap(page);
+ free_extent_map(em);
+ em = NULL;
+ btrfs_release_path(root, path);
+ trans = btrfs_start_transaction(root, 1);
+ goto again;
+ }
+ write_extent_buffer(leaf, map + page_offset, ptr,
+ copy_size);
+ btrfs_mark_buffer_dirty(leaf);
+ }
kunmap(page);
- set_extent_uptodate(em_tree, extent_start,
- extent_end, GFP_NOFS);
+ set_extent_uptodate(em_tree, em->start, em->end, GFP_NOFS);
goto insert;
} else {
printk("unkknown found_type %d\n", found_type);
return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
}
+
+static int btrfs_writepages(struct address_space *mapping,
+ struct writeback_control *wbc)
+{
+ struct extent_map_tree *tree;
+ tree = &BTRFS_I(mapping->host)->extent_tree;
+ return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
+}
+
static int btrfs_releasepage(struct page *page, gfp_t unused_gfp_flags)
{
struct extent_map_tree *tree;
int ret;
- if (page->private != 1) {
- WARN_ON(1);
- return try_to_free_buffers(page);
- }
tree = &BTRFS_I(page->mapping->host)->extent_tree;
ret = try_release_extent_mapping(tree, page);
if (ret == 1) {
lock_page(page);
wait_on_page_writeback(page);
size = i_size_read(inode);
- page_start = page->index << PAGE_CACHE_SHIFT;
+ page_start = (u64)page->index << PAGE_CACHE_SHIFT;
if ((page->mapping != inode->i_mapping) ||
(page_start > size)) {
trans = btrfs_start_transaction(root, 1);
BUG_ON(!trans);
- leaf = btrfs_alloc_free_block(trans, root, 0, 0);
+ leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0, 0);
if (IS_ERR(leaf))
return PTR_ERR(leaf);
btrfs_set_header_nritems(leaf, 0);
btrfs_set_header_level(leaf, 0);
- btrfs_set_header_blocknr(leaf, extent_buffer_blocknr(leaf));
+ btrfs_set_header_bytenr(leaf, leaf->start);
btrfs_set_header_generation(leaf, trans->transid);
btrfs_set_header_owner(leaf, root->root_key.objectid);
write_extent_buffer(leaf, root->fs_info->fsid,
inode_item->nblocks = cpu_to_le64(1);
inode_item->mode = cpu_to_le32(S_IFDIR | 0755);
- btrfs_set_root_blocknr(&root_item, extent_buffer_blocknr(leaf));
+ btrfs_set_root_bytenr(&root_item, leaf->start);
+ btrfs_set_root_level(&root_item, 0);
btrfs_set_root_refs(&root_item, 1);
btrfs_set_root_used(&root_item, 0);
btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
btrfs_cow_block(trans, root, root->node, NULL, 0, &tmp);
- btrfs_set_root_blocknr(&new_root_item,
- extent_buffer_blocknr(root->node));
+ btrfs_set_root_bytenr(&new_root_item, root->node->start);
+ btrfs_set_root_level(&new_root_item, btrfs_header_level(root->node));
ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
&new_root_item);
goto out_unlock;
}
}
- page_start = page->index << PAGE_CACHE_SHIFT;
+ page_start = (u64)page->index << PAGE_CACHE_SHIFT;
page_end = page_start + PAGE_CACHE_SIZE - 1;
lock_extent(em_tree, page_start, page_end, GFP_NOFS);
kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
}
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
+static void init_once(struct kmem_cache * cachep, void *foo)
+#else
static void init_once(void * foo, struct kmem_cache * cachep,
unsigned long flags)
+#endif
{
struct btrfs_inode *ei = (struct btrfs_inode *) foo;
struct kmem_cache *btrfs_cache_create(const char *name, size_t size,
unsigned long extra_flags,
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
+ void (*ctor)(struct kmem_cache *, void *)
+#else
void (*ctor)(void *, struct kmem_cache *,
- unsigned long))
+ unsigned long)
+#endif
+ )
{
return kmem_cache_create(name, size, 0, (SLAB_RECLAIM_ACCOUNT |
SLAB_MEM_SPREAD | extra_flags), ctor
static struct address_space_operations btrfs_aops = {
.readpage = btrfs_readpage,
.writepage = btrfs_writepage,
+ .writepages = btrfs_writepages,
.sync_page = block_sync_page,
.prepare_write = btrfs_prepare_write,
.commit_write = btrfs_commit_write,
projects / karo-tx-linux.git / blobdiff