* Boston, MA 021110-1307, USA.
*/
+#include <linux/bio.h>
#include <linux/buffer_head.h>
#include <linux/fs.h>
#include <linux/pagemap.h>
#include "btrfs_inode.h"
#include "ioctl.h"
#include "print-tree.h"
+#include "volumes.h"
struct btrfs_iget_args {
u64 ino;
static struct address_space_operations btrfs_aops;
static struct address_space_operations btrfs_symlink_aops;
static struct file_operations btrfs_dir_file_operations;
-static struct extent_map_ops btrfs_extent_map_ops;
+static struct extent_io_ops btrfs_extent_io_ops;
static struct kmem_cache *btrfs_inode_cachep;
struct kmem_cache *btrfs_trans_handle_cachep;
u64 thresh;
int ret = 0;
- return 0;
-
if (for_del)
thresh = total * 90;
else
u64 num_bytes;
u64 cur_alloc_size;
u64 blocksize = root->sectorsize;
+ u64 orig_start = start;
+ u64 orig_num_bytes;
struct btrfs_key ins;
int ret;
num_bytes = max(blocksize, num_bytes);
ret = btrfs_drop_extents(trans, root, inode,
start, start + num_bytes, start, &alloc_hint);
+ orig_num_bytes = num_bytes;
if (alloc_hint == EXTENT_MAP_INLINE)
goto out;
ret = btrfs_insert_file_extent(trans, root, inode->i_ino,
start, ins.objectid, ins.offset,
ins.offset);
+ inode->i_blocks += ins.offset >> 9;
btrfs_check_file(root, inode);
num_bytes -= cur_alloc_size;
alloc_hint = ins.objectid + ins.offset;
start += cur_alloc_size;
}
+ btrfs_drop_extent_cache(inode, orig_start,
+ orig_start + orig_num_bytes - 1);
btrfs_add_ordered_inode(inode);
+ btrfs_update_inode(trans, root, inode);
out:
btrfs_end_transaction(trans, root);
return ret;
static int run_delalloc_range(struct inode *inode, u64 start, u64 end)
{
struct btrfs_root *root = BTRFS_I(inode)->root;
- u64 num_bytes;
int ret;
mutex_lock(&root->fs_info->fs_mutex);
if (btrfs_test_opt(root, NODATACOW) ||
else
ret = cow_file_range(inode, start, end);
- spin_lock(&root->fs_info->delalloc_lock);
- num_bytes = end + 1 - start;
- if (root->fs_info->delalloc_bytes < num_bytes) {
- printk("delalloc accounting error total %llu sub %llu\n",
- root->fs_info->delalloc_bytes, num_bytes);
- } else {
- root->fs_info->delalloc_bytes -= num_bytes;
- }
- spin_unlock(&root->fs_info->delalloc_lock);
-
mutex_unlock(&root->fs_info->fs_mutex);
return ret;
}
-int btrfs_writepage_io_hook(struct page *page, u64 start, u64 end)
+int btrfs_set_bit_hook(struct inode *inode, u64 start, u64 end,
+ unsigned long old, unsigned long bits)
+{
+ if (!(old & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) {
+ struct btrfs_root *root = BTRFS_I(inode)->root;
+ spin_lock(&root->fs_info->delalloc_lock);
+ BTRFS_I(inode)->delalloc_bytes += end - start + 1;
+ root->fs_info->delalloc_bytes += end - start + 1;
+ spin_unlock(&root->fs_info->delalloc_lock);
+ }
+ return 0;
+}
+
+int btrfs_clear_bit_hook(struct inode *inode, u64 start, u64 end,
+ unsigned long old, unsigned long bits)
+{
+ if ((old & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) {
+ struct btrfs_root *root = BTRFS_I(inode)->root;
+ spin_lock(&root->fs_info->delalloc_lock);
+ if (end - start + 1 > root->fs_info->delalloc_bytes) {
+ printk("warning: delalloc account %Lu %Lu\n",
+ end - start + 1, root->fs_info->delalloc_bytes);
+ root->fs_info->delalloc_bytes = 0;
+ BTRFS_I(inode)->delalloc_bytes = 0;
+ } else {
+ root->fs_info->delalloc_bytes -= end - start + 1;
+ BTRFS_I(inode)->delalloc_bytes -= end - start + 1;
+ }
+ spin_unlock(&root->fs_info->delalloc_lock);
+ }
+ return 0;
+}
+
+int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
+ size_t size, struct bio *bio)
+{
+ struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
+ struct btrfs_mapping_tree *map_tree;
+ u64 logical = bio->bi_sector << 9;
+ u64 length = 0;
+ u64 map_length;
+ struct bio_vec *bvec;
+ int i;
+ int ret;
+
+ bio_for_each_segment(bvec, bio, i) {
+ length += bvec->bv_len;
+ }
+ map_tree = &root->fs_info->mapping_tree;
+ map_length = length;
+ ret = btrfs_map_block(map_tree, READ, logical,
+ &map_length, NULL);
+
+ if (map_length < length + size) {
+ return 1;
+ }
+ return 0;
+}
+
+int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio)
{
- struct inode *inode = page->mapping->host;
struct btrfs_root *root = BTRFS_I(inode)->root;
struct btrfs_trans_handle *trans;
- char *kaddr;
int ret = 0;
- u64 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
- size_t offset = start - page_start;
+
+ if (!(rw & (1 << BIO_RW))) {
+ ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
+ BUG_ON(ret);
+ goto mapit;
+ }
+
if (btrfs_test_opt(root, NODATASUM) ||
- btrfs_test_flag(inode, NODATASUM))
- return 0;
+ btrfs_test_flag(inode, NODATASUM)) {
+ goto mapit;
+ }
+
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, inode->i_ino,
- start, kaddr + offset, end - start + 1);
- kunmap(page);
+ btrfs_csum_file_blocks(trans, root, inode, bio);
ret = btrfs_end_transaction(trans, root);
BUG_ON(ret);
mutex_unlock(&root->fs_info->fs_mutex);
- return ret;
+mapit:
+ return btrfs_map_bio(root, rw, bio);
}
int btrfs_readpage_io_hook(struct page *page, u64 start, u64 end)
int ret = 0;
struct inode *inode = page->mapping->host;
struct btrfs_root *root = BTRFS_I(inode)->root;
- struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+ struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
struct btrfs_csum_item *item;
struct btrfs_path *path = NULL;
u32 csum;
if (ret == -ENOENT || ret == -EFBIG)
ret = 0;
csum = 0;
+ printk("no csum found for inode %lu start %Lu\n", inode->i_ino, start);
goto out;
}
read_extent_buffer(path->nodes[0], &csum, (unsigned long)item,
BTRFS_CRC32_SIZE);
- set_state_private(em_tree, start, csum);
+ set_state_private(io_tree, start, csum);
out:
if (path)
btrfs_free_path(path);
return ret;
}
-int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end)
+int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
+ struct extent_state *state)
{
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;
+ struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
char *kaddr;
- u64 private;
+ u64 private = ~(u32)0;
int ret;
struct btrfs_root *root = BTRFS_I(inode)->root;
u32 csum = ~(u32)0;
unsigned long flags;
+
if (btrfs_test_opt(root, NODATASUM) ||
btrfs_test_flag(inode, NODATASUM))
return 0;
- ret = get_state_private(em_tree, start, &private);
+ if (state && state->start == start) {
+ private = state->private;
+ ret = 0;
+ } else {
+ ret = get_state_private(io_tree, start, &private);
+ }
local_irq_save(flags);
kaddr = kmap_atomic(page, KM_IRQ0);
if (ret) {
return 0;
zeroit:
- printk("btrfs csum failed ino %lu off %llu\n",
- page->mapping->host->i_ino, (unsigned long long)start);
+ printk("btrfs csum failed ino %lu off %llu csum %u private %Lu\n",
+ page->mapping->host->i_ino, (unsigned long long)start, csum,
+ private);
memset(kaddr + offset, 1, end - start + 1);
flush_dcache_page(page);
kunmap_atomic(kaddr, KM_IRQ0);
struct btrfs_path *path;
struct extent_buffer *leaf;
struct btrfs_inode_item *inode_item;
- struct btrfs_inode_timespec *tspec;
+ struct btrfs_timespec *tspec;
struct btrfs_root *root = BTRFS_I(inode)->root;
struct btrfs_key location;
u64 alloc_group_block;
BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
if (!BTRFS_I(inode)->block_group) {
BTRFS_I(inode)->block_group = btrfs_find_block_group(root,
- NULL, 0, 0, 0);
+ NULL, 0,
+ BTRFS_BLOCK_GROUP_METADATA, 0);
}
btrfs_free_path(path);
inode_item = NULL;
switch (inode->i_mode & S_IFMT) {
case S_IFREG:
inode->i_mapping->a_ops = &btrfs_aops;
- BTRFS_I(inode)->extent_tree.ops = &btrfs_extent_map_ops;
+ inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
+ BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
inode->i_fop = &btrfs_file_operations;
inode->i_op = &btrfs_file_inode_operations;
break;
case S_IFLNK:
inode->i_op = &btrfs_symlink_inode_operations;
inode->i_mapping->a_ops = &btrfs_symlink_aops;
+ inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
break;
default:
init_special_inode(inode, inode->i_mode, rdev);
return err;
}
-static int btrfs_free_inode(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct inode *inode)
-{
- struct btrfs_path *path;
- int ret;
-
- clear_inode(inode);
-
- path = btrfs_alloc_path();
- BUG_ON(!path);
- ret = btrfs_lookup_inode(trans, root, path,
- &BTRFS_I(inode)->location, -1);
- if (ret > 0)
- ret = -ENOENT;
- if (!ret)
- ret = btrfs_del_item(trans, root, path);
- btrfs_free_path(path);
- return ret;
-}
-
/*
* this can truncate away extent items, csum items and directory items.
* It starts at a high offset and removes keys until it can't find
*/
static int btrfs_truncate_in_trans(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
- struct inode *inode)
+ struct inode *inode,
+ u32 min_type)
{
int ret;
struct btrfs_path *path;
u64 root_owner = 0;
int found_extent;
int del_item;
+ int pending_del_nr = 0;
+ int pending_del_slot = 0;
int extent_type = -1;
btrfs_drop_extent_cache(inode, inode->i_size, (u64)-1);
key.offset = (u64)-1;
key.type = (u8)-1;
+ btrfs_init_path(path);
+search_again:
+ ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
+ if (ret < 0) {
+ goto error;
+ }
+ if (ret > 0) {
+ BUG_ON(path->slots[0] == 0);
+ path->slots[0]--;
+ }
+
while(1) {
- btrfs_init_path(path);
fi = NULL;
- ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
- if (ret < 0) {
- goto error;
- }
- if (ret > 0) {
- BUG_ON(path->slots[0] == 0);
- path->slots[0]--;
- }
leaf = path->nodes[0];
btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
found_type = btrfs_key_type(&found_key);
if (found_key.objectid != inode->i_ino)
break;
- if (found_type != BTRFS_CSUM_ITEM_KEY &&
- found_type != BTRFS_DIR_ITEM_KEY &&
- found_type != BTRFS_DIR_INDEX_KEY &&
- found_type != BTRFS_EXTENT_DATA_KEY)
+ if (found_type < min_type)
break;
item_end = found_key.offset;
found_type = BTRFS_INODE_ITEM_KEY;
} else if (found_type == BTRFS_EXTENT_ITEM_KEY) {
found_type = BTRFS_CSUM_ITEM_KEY;
+ } else if (found_type == BTRFS_EXTENT_DATA_KEY) {
+ found_type = BTRFS_XATTR_ITEM_KEY;
+ } else if (found_type == BTRFS_XATTR_ITEM_KEY) {
+ found_type = BTRFS_INODE_REF_KEY;
} else if (found_type) {
found_type--;
} else {
break;
}
btrfs_set_key_type(&key, found_type);
- btrfs_release_path(root, path);
- continue;
+ goto next;
}
if (found_key.offset >= inode->i_size)
del_item = 1;
btrfs_file_extent_num_bytes(leaf, fi);
extent_num_bytes = inode->i_size -
found_key.offset + root->sectorsize - 1;
+ extent_num_bytes = extent_num_bytes &
+ ~((u64)root->sectorsize - 1);
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;
- }
+ extent_num_bytes);
+ if (extent_start != 0)
+ dec_i_blocks(inode, num_dec);
btrfs_mark_buffer_dirty(leaf);
} else {
extent_num_bytes =
btrfs_file_extent_disk_num_bytes(leaf,
fi);
/* FIXME blocksize != 4096 */
- num_dec = btrfs_file_extent_num_bytes(leaf,
- fi) >> 9;
+ num_dec = btrfs_file_extent_num_bytes(leaf, fi);
if (extent_start != 0) {
found_extent = 1;
- inode->i_blocks -= num_dec;
+ dec_i_blocks(inode, num_dec);
}
root_gen = btrfs_header_generation(leaf);
root_owner = btrfs_header_owner(leaf);
}
- } 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);
+ } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
+ if (!del_item) {
+ u32 newsize = inode->i_size - found_key.offset;
+ dec_i_blocks(inode, item_end + 1 -
+ found_key.offset - newsize);
+ newsize =
+ btrfs_file_extent_calc_inline_size(newsize);
+ ret = btrfs_truncate_item(trans, root, path,
+ newsize, 1);
+ BUG_ON(ret);
+ } else {
+ dec_i_blocks(inode, item_end + 1 -
+ found_key.offset);
+ }
}
delete:
if (del_item) {
- ret = btrfs_del_item(trans, root, path);
- if (ret)
- goto error;
+ if (!pending_del_nr) {
+ /* no pending yet, add ourselves */
+ pending_del_slot = path->slots[0];
+ pending_del_nr = 1;
+ } else if (pending_del_nr &&
+ path->slots[0] + 1 == pending_del_slot) {
+ /* hop on the pending chunk */
+ pending_del_nr++;
+ pending_del_slot = path->slots[0];
+ } else {
+ printk("bad pending slot %d pending_del_nr %d pending_del_slot %d\n", path->slots[0], pending_del_nr, pending_del_slot);
+ }
} else {
break;
}
- btrfs_release_path(root, path);
if (found_extent) {
ret = btrfs_free_extent(trans, root, extent_start,
extent_num_bytes,
found_key.offset, 0);
BUG_ON(ret);
}
+next:
+ if (path->slots[0] == 0) {
+ if (pending_del_nr)
+ goto del_pending;
+ btrfs_release_path(root, path);
+ goto search_again;
+ }
+
+ path->slots[0]--;
+ if (pending_del_nr &&
+ path->slots[0] + 1 != pending_del_slot) {
+ struct btrfs_key debug;
+del_pending:
+ btrfs_item_key_to_cpu(path->nodes[0], &debug,
+ pending_del_slot);
+ ret = btrfs_del_items(trans, root, path,
+ pending_del_slot,
+ pending_del_nr);
+ BUG_ON(ret);
+ pending_del_nr = 0;
+ btrfs_release_path(root, path);
+ goto search_again;
+ }
}
ret = 0;
error:
+ if (pending_del_nr) {
+ ret = btrfs_del_items(trans, root, path, pending_del_slot,
+ pending_del_nr);
+ }
btrfs_release_path(root, path);
btrfs_free_path(path);
inode->i_sb->s_dirt = 1;
size_t zero_start)
{
char *kaddr;
- struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
- struct btrfs_root *root = BTRFS_I(inode)->root;
+ struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
u64 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
- u64 existing_delalloc;
- u64 delalloc_start;
int ret = 0;
WARN_ON(!PageLocked(page));
set_page_extent_mapped(page);
- lock_extent(em_tree, page_start, page_end, GFP_NOFS);
- delalloc_start = page_start;
- existing_delalloc = count_range_bits(&BTRFS_I(inode)->extent_tree,
- &delalloc_start, page_end,
- PAGE_CACHE_SIZE, EXTENT_DELALLOC);
- set_extent_delalloc(&BTRFS_I(inode)->extent_tree, page_start,
+ lock_extent(io_tree, page_start, page_end, GFP_NOFS);
+ set_extent_delalloc(&BTRFS_I(inode)->io_tree, page_start,
page_end, GFP_NOFS);
- spin_lock(&root->fs_info->delalloc_lock);
- root->fs_info->delalloc_bytes += PAGE_CACHE_SIZE - existing_delalloc;
- spin_unlock(&root->fs_info->delalloc_lock);
-
if (zero_start != PAGE_CACHE_SIZE) {
kaddr = kmap(page);
memset(kaddr + zero_start, 0, PAGE_CACHE_SIZE - zero_start);
kunmap(page);
}
set_page_dirty(page);
- unlock_extent(em_tree, page_start, page_end, GFP_NOFS);
+ unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
return ret;
}
attr->ia_valid & ATTR_SIZE && attr->ia_size > inode->i_size) {
struct btrfs_trans_handle *trans;
struct btrfs_root *root = BTRFS_I(inode)->root;
- struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+ struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
u64 mask = root->sectorsize - 1;
- u64 pos = (inode->i_size + mask) & ~mask;
- u64 block_end = attr->ia_size | mask;
- u64 hole_start;
+ u64 hole_start = (inode->i_size + mask) & ~mask;
+ u64 block_end = (attr->ia_size + mask) & ~mask;
u64 hole_size;
u64 alloc_hint = 0;
- if (attr->ia_size <= pos)
+ if (attr->ia_size <= hole_start)
goto out;
- if (pos != inode->i_size)
- hole_start = pos + root->sectorsize;
- else
- hole_start = pos;
-
mutex_lock(&root->fs_info->fs_mutex);
err = btrfs_check_free_space(root, 1, 0);
mutex_unlock(&root->fs_info->fs_mutex);
btrfs_truncate_page(inode->i_mapping, inode->i_size);
- lock_extent(em_tree, pos, block_end, GFP_NOFS);
+ lock_extent(io_tree, hole_start, block_end - 1, GFP_NOFS);
hole_size = block_end - hole_start;
mutex_lock(&root->fs_info->fs_mutex);
trans = btrfs_start_transaction(root, 1);
btrfs_set_trans_block_group(trans, inode);
err = btrfs_drop_extents(trans, root, inode,
- pos, block_end, pos,
+ hole_start, block_end, hole_start,
&alloc_hint);
if (alloc_hint != EXTENT_MAP_INLINE) {
inode->i_ino,
hole_start, 0, 0,
hole_size);
+ btrfs_drop_extent_cache(inode, hole_start,
+ hole_size - 1);
btrfs_check_file(root, inode);
}
btrfs_end_transaction(trans, root);
mutex_unlock(&root->fs_info->fs_mutex);
- unlock_extent(em_tree, pos, block_end, GFP_NOFS);
+ unlock_extent(io_tree, hole_start, block_end - 1, GFP_NOFS);
if (err)
return err;
}
trans = btrfs_start_transaction(root, 1);
btrfs_set_trans_block_group(trans, inode);
- ret = btrfs_truncate_in_trans(trans, root, inode);
- if (ret)
- goto no_delete_lock;
- ret = btrfs_delete_xattrs(trans, root, inode);
- if (ret)
- goto no_delete_lock;
- ret = btrfs_free_inode(trans, root, inode);
+ ret = btrfs_truncate_in_trans(trans, root, inode, 0);
if (ret)
goto no_delete_lock;
+
nr = trans->blocks_used;
+ clear_inode(inode);
btrfs_end_transaction(trans, root);
mutex_unlock(&root->fs_info->fs_mutex);
struct btrfs_iget_args *args = p;
inode->i_ino = args->ino;
BTRFS_I(inode)->root = args->root;
- extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
+ BTRFS_I(inode)->delalloc_bytes = 0;
+ extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
+ extent_io_tree_init(&BTRFS_I(inode)->io_tree,
inode->i_mapping, GFP_NOFS);
return 0;
}
di = (struct btrfs_dir_item *)((char *)di + di_len);
}
}
- filp->f_pos++;
+ if (key_type == BTRFS_DIR_INDEX_KEY)
+ filp->f_pos = INT_LIMIT(typeof(filp->f_pos));
+ else
+ filp->f_pos++;
nopos:
ret = 0;
err:
static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
+ const char *name, int name_len,
+ u64 ref_objectid,
u64 objectid,
struct btrfs_block_group_cache *group,
int mode)
{
struct inode *inode;
struct btrfs_inode_item *inode_item;
+ struct btrfs_block_group_cache *new_inode_group;
struct btrfs_key *location;
struct btrfs_path *path;
+ struct btrfs_inode_ref *ref;
+ struct btrfs_key key[2];
+ u32 sizes[2];
+ unsigned long ptr;
int ret;
int owner;
if (!inode)
return ERR_PTR(-ENOMEM);
- extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
+ extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
+ extent_io_tree_init(&BTRFS_I(inode)->io_tree,
inode->i_mapping, GFP_NOFS);
+ BTRFS_I(inode)->delalloc_bytes = 0;
BTRFS_I(inode)->root = root;
if (mode & S_IFDIR)
owner = 0;
else
owner = 1;
- group = btrfs_find_block_group(root, group, 0, 0, owner);
- BTRFS_I(inode)->block_group = group;
+ new_inode_group = btrfs_find_block_group(root, group, 0,
+ BTRFS_BLOCK_GROUP_METADATA, owner);
+ if (!new_inode_group) {
+ printk("find_block group failed\n");
+ new_inode_group = group;
+ }
+ BTRFS_I(inode)->block_group = new_inode_group;
BTRFS_I(inode)->flags = 0;
- ret = btrfs_insert_empty_inode(trans, root, path, objectid);
- if (ret)
+
+ key[0].objectid = objectid;
+ btrfs_set_key_type(&key[0], BTRFS_INODE_ITEM_KEY);
+ key[0].offset = 0;
+
+ key[1].objectid = objectid;
+ btrfs_set_key_type(&key[1], BTRFS_INODE_REF_KEY);
+ key[1].offset = ref_objectid;
+
+ sizes[0] = sizeof(struct btrfs_inode_item);
+ sizes[1] = name_len + sizeof(*ref);
+
+ ret = btrfs_insert_empty_items(trans, root, path, key, sizes, 2);
+ if (ret != 0)
goto fail;
+ if (objectid > root->highest_inode)
+ root->highest_inode = objectid;
+
inode->i_uid = current->fsuid;
inode->i_gid = current->fsgid;
inode->i_mode = mode;
inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
struct btrfs_inode_item);
fill_inode_item(path->nodes[0], inode_item, inode);
+
+ ref = btrfs_item_ptr(path->nodes[0], path->slots[0] + 1,
+ struct btrfs_inode_ref);
+ btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len);
+ ptr = (unsigned long)(ref + 1);
+ write_extent_buffer(path->nodes[0], name, ptr, name_len);
+
btrfs_mark_buffer_dirty(path->nodes[0]);
btrfs_free_path(path);
}
static int btrfs_add_link(struct btrfs_trans_handle *trans,
- struct dentry *dentry, struct inode *inode)
+ struct dentry *dentry, struct inode *inode,
+ int add_backref)
{
int ret;
struct btrfs_key key;
dentry->d_parent->d_inode->i_ino,
&key, btrfs_inode_type(inode));
if (ret == 0) {
- ret = btrfs_insert_inode_ref(trans, root,
- dentry->d_name.name,
- dentry->d_name.len,
- inode->i_ino,
- dentry->d_parent->d_inode->i_ino);
+ if (add_backref) {
+ ret = btrfs_insert_inode_ref(trans, root,
+ dentry->d_name.name,
+ dentry->d_name.len,
+ inode->i_ino,
+ dentry->d_parent->d_inode->i_ino);
+ }
parent_inode = dentry->d_parent->d_inode;
parent_inode->i_size += dentry->d_name.len * 2;
parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
}
static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
- struct dentry *dentry, struct inode *inode)
+ struct dentry *dentry, struct inode *inode,
+ int backref)
{
- int err = btrfs_add_link(trans, dentry, inode);
+ int err = btrfs_add_link(trans, dentry, inode, backref);
if (!err) {
d_instantiate(dentry, inode);
return 0;
goto out_unlock;
}
- inode = btrfs_new_inode(trans, root, objectid,
+ inode = btrfs_new_inode(trans, root, dentry->d_name.name,
+ dentry->d_name.len,
+ dentry->d_parent->d_inode->i_ino, objectid,
BTRFS_I(dir)->block_group, mode);
err = PTR_ERR(inode);
if (IS_ERR(inode))
goto out_unlock;
btrfs_set_trans_block_group(trans, inode);
- err = btrfs_add_nondir(trans, dentry, inode);
+ err = btrfs_add_nondir(trans, dentry, inode, 0);
if (err)
drop_inode = 1;
else {
goto out_unlock;
}
- inode = btrfs_new_inode(trans, root, objectid,
- BTRFS_I(dir)->block_group, mode);
+ inode = btrfs_new_inode(trans, root, dentry->d_name.name,
+ dentry->d_name.len,
+ dentry->d_parent->d_inode->i_ino,
+ objectid, BTRFS_I(dir)->block_group, mode);
err = PTR_ERR(inode);
if (IS_ERR(inode))
goto out_unlock;
btrfs_set_trans_block_group(trans, inode);
- err = btrfs_add_nondir(trans, dentry, inode);
+ err = btrfs_add_nondir(trans, dentry, inode, 0);
if (err)
drop_inode = 1;
else {
inode->i_mapping->a_ops = &btrfs_aops;
+ inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
inode->i_fop = &btrfs_file_operations;
inode->i_op = &btrfs_file_inode_operations;
- extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
+ extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
+ extent_io_tree_init(&BTRFS_I(inode)->io_tree,
inode->i_mapping, GFP_NOFS);
- BTRFS_I(inode)->extent_tree.ops = &btrfs_extent_map_ops;
+ BTRFS_I(inode)->delalloc_bytes = 0;
+ BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
}
dir->i_sb->s_dirt = 1;
btrfs_update_inode_block_group(trans, inode);
btrfs_set_trans_block_group(trans, dir);
atomic_inc(&inode->i_count);
- err = btrfs_add_nondir(trans, dentry, inode);
+ err = btrfs_add_nondir(trans, dentry, inode, 1);
if (err)
drop_inode = 1;
goto out_unlock;
}
- inode = btrfs_new_inode(trans, root, objectid,
+ inode = btrfs_new_inode(trans, root, dentry->d_name.name,
+ dentry->d_name.len,
+ dentry->d_parent->d_inode->i_ino, objectid,
BTRFS_I(dir)->block_group, S_IFDIR | mode);
if (IS_ERR(inode)) {
err = PTR_ERR(inode);
if (err)
goto out_fail;
- err = btrfs_add_link(trans, dentry, inode);
+ err = btrfs_add_link(trans, dentry, inode, 0);
if (err)
goto out_fail;
}
struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
- size_t page_offset, u64 start, u64 end,
+ size_t pg_offset, u64 start, u64 len,
int create)
{
int ret;
u64 extent_end = 0;
u64 objectid = inode->i_ino;
u32 found_type;
- int failed_insert = 0;
struct btrfs_path *path;
struct btrfs_root *root = BTRFS_I(inode)->root;
struct btrfs_file_extent_item *item;
struct btrfs_key found_key;
struct extent_map *em = NULL;
struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+ struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
struct btrfs_trans_handle *trans = NULL;
path = btrfs_alloc_path();
mutex_lock(&root->fs_info->fs_mutex);
again:
- em = lookup_extent_mapping(em_tree, start, end);
+ spin_lock(&em_tree->lock);
+ em = lookup_extent_mapping(em_tree, start, len);
+ spin_unlock(&em_tree->lock);
+
if (em) {
if (em->start > start) {
- printk("get_extent start %Lu em start %Lu\n",
- start, em->start);
+ printk("get_extent lookup [%Lu %Lu] em [%Lu %Lu]\n",
+ start, len, em->start, em->len);
WARN_ON(1);
}
- goto out;
+ if (em->block_start == EXTENT_MAP_INLINE && page)
+ free_extent_map(em);
+ else
+ goto out;
}
+ em = alloc_extent_map(GFP_NOFS);
if (!em) {
- em = alloc_extent_map(GFP_NOFS);
- if (!em) {
- err = -ENOMEM;
- goto out;
- }
- em->start = EXTENT_MAP_HOLE;
- em->end = EXTENT_MAP_HOLE;
+ err = -ENOMEM;
+ goto out;
}
+
+ em->start = EXTENT_MAP_HOLE;
+ em->len = (u64)-1;
em->bdev = inode->i_sb->s_bdev;
ret = btrfs_lookup_file_extent(trans, root, path,
objectid, start, trans != NULL);
if (start < extent_start || start >= extent_end) {
em->start = start;
if (start < extent_start) {
- if (end < extent_start)
+ if (start + len <= extent_start)
goto not_found;
- em->end = extent_end - 1;
+ em->len = extent_end - extent_start;
} else {
- em->end = end;
+ em->len = len;
}
goto not_found_em;
}
bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
if (bytenr == 0) {
em->start = extent_start;
- em->end = extent_end - 1;
+ em->len = extent_end - extent_start;
em->block_start = EXTENT_MAP_HOLE;
- em->block_end = EXTENT_MAP_HOLE;
goto insert;
}
bytenr += btrfs_file_extent_offset(leaf, item);
em->block_start = bytenr;
- em->block_end = em->block_start +
- btrfs_file_extent_num_bytes(leaf, item) - 1;
em->start = extent_start;
- em->end = extent_end - 1;
+ em->len = extent_end - extent_start;
goto insert;
} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
+ u64 page_start;
unsigned long ptr;
char *map;
size_t size;
size = btrfs_file_extent_inline_len(leaf, btrfs_item_nr(leaf,
path->slots[0]));
- extent_end = (extent_start + size - 1) |
- ((u64)root->sectorsize - 1);
+ extent_end = (extent_start + size + root->sectorsize - 1) &
+ ~((u64)root->sectorsize - 1);
if (start < extent_start || start >= extent_end) {
em->start = start;
if (start < extent_start) {
- if (end < extent_start)
+ if (start + len <= extent_start)
goto not_found;
- em->end = extent_end;
+ em->len = extent_end - extent_start;
} else {
- em->end = end;
+ em->len = len;
}
goto not_found_em;
}
em->block_start = EXTENT_MAP_INLINE;
- em->block_end = EXTENT_MAP_INLINE;
if (!page) {
em->start = extent_start;
- em->end = extent_start + size - 1;
+ em->len = size;
goto out;
}
- extent_offset = ((u64)page->index << PAGE_CACHE_SHIFT) -
- extent_start + page_offset;
- copy_size = min_t(u64, PAGE_CACHE_SIZE - page_offset,
+ page_start = page_offset(page) + pg_offset;
+ extent_offset = page_start - extent_start;
+ copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
size - extent_offset);
em->start = extent_start + extent_offset;
- em->end = (em->start + copy_size -1) |
- ((u64)root->sectorsize -1);
+ em->len = (copy_size + root->sectorsize - 1) &
+ ~((u64)root->sectorsize - 1);
map = kmap(page);
ptr = btrfs_file_extent_inline_start(item) + extent_offset;
if (create == 0 && !PageUptodate(page)) {
- read_extent_buffer(leaf, map + page_offset, ptr,
+ read_extent_buffer(leaf, map + pg_offset, ptr,
copy_size);
flush_dcache_page(page);
} else if (create && PageUptodate(page)) {
trans = btrfs_start_transaction(root, 1);
goto again;
}
- write_extent_buffer(leaf, map + page_offset, ptr,
+ write_extent_buffer(leaf, map + pg_offset, ptr,
copy_size);
btrfs_mark_buffer_dirty(leaf);
}
kunmap(page);
- set_extent_uptodate(em_tree, em->start, em->end, GFP_NOFS);
+ set_extent_uptodate(io_tree, em->start,
+ extent_map_end(em) - 1, GFP_NOFS);
goto insert;
} else {
printk("unkknown found_type %d\n", found_type);
}
not_found:
em->start = start;
- em->end = end;
+ em->len = len;
not_found_em:
em->block_start = EXTENT_MAP_HOLE;
- em->block_end = EXTENT_MAP_HOLE;
insert:
btrfs_release_path(root, path);
- if (em->start > start || em->end < start) {
- printk("bad extent! em: [%Lu %Lu] passed [%Lu %Lu]\n", em->start, em->end, start, end);
+ if (em->start > start || extent_map_end(em) <= start) {
+ printk("bad extent! em: [%Lu %Lu] passed [%Lu %Lu]\n", em->start, em->len, start, len);
err = -EIO;
goto out;
}
+
+ err = 0;
+ spin_lock(&em_tree->lock);
ret = add_extent_mapping(em_tree, em);
if (ret == -EEXIST) {
free_extent_map(em);
- em = NULL;
- if (0 && failed_insert == 1) {
- btrfs_drop_extent_cache(inode, start, end);
- }
- failed_insert++;
- if (failed_insert > 5) {
- printk("failing to insert %Lu %Lu\n", start, end);
+ em = lookup_extent_mapping(em_tree, start, len);
+ if (!em) {
err = -EIO;
- goto out;
+ printk("failing to insert %Lu %Lu\n", start, len);
}
- goto again;
}
- err = 0;
+ spin_unlock(&em_tree->lock);
out:
btrfs_free_path(path);
if (trans) {
int btrfs_readpage(struct file *file, struct page *page)
{
- struct extent_map_tree *tree;
- tree = &BTRFS_I(page->mapping->host)->extent_tree;
+ struct extent_io_tree *tree;
+ tree = &BTRFS_I(page->mapping->host)->io_tree;
return extent_read_full_page(tree, page, btrfs_get_extent);
}
static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
{
- struct extent_map_tree *tree;
+ struct extent_io_tree *tree;
if (current->flags & PF_MEMALLOC) {
unlock_page(page);
return 0;
}
- tree = &BTRFS_I(page->mapping->host)->extent_tree;
+ tree = &BTRFS_I(page->mapping->host)->io_tree;
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;
+ struct extent_io_tree *tree;
+ tree = &BTRFS_I(mapping->host)->io_tree;
return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
}
btrfs_readpages(struct file *file, struct address_space *mapping,
struct list_head *pages, unsigned nr_pages)
{
- struct extent_map_tree *tree;
- tree = &BTRFS_I(mapping->host)->extent_tree;
+ struct extent_io_tree *tree;
+ tree = &BTRFS_I(mapping->host)->io_tree;
return extent_readpages(tree, mapping, pages, nr_pages,
btrfs_get_extent);
}
-static int btrfs_releasepage(struct page *page, gfp_t unused_gfp_flags)
+static int btrfs_releasepage(struct page *page, gfp_t gfp_flags)
{
- struct extent_map_tree *tree;
+ struct extent_io_tree *tree;
+ struct extent_map_tree *map;
int ret;
- tree = &BTRFS_I(page->mapping->host)->extent_tree;
- ret = try_release_extent_mapping(tree, page);
+ tree = &BTRFS_I(page->mapping->host)->io_tree;
+ map = &BTRFS_I(page->mapping->host)->extent_tree;
+ ret = try_release_extent_mapping(map, tree, page, gfp_flags);
if (ret == 1) {
ClearPagePrivate(page);
set_page_private(page, 0);
static void btrfs_invalidatepage(struct page *page, unsigned long offset)
{
- struct extent_map_tree *tree;
+ struct extent_io_tree *tree;
- tree = &BTRFS_I(page->mapping->host)->extent_tree;
+ tree = &BTRFS_I(page->mapping->host)->io_tree;
extent_invalidatepage(tree, page, offset);
btrfs_releasepage(page, GFP_NOFS);
}
btrfs_set_trans_block_group(trans, inode);
/* FIXME, add redo link to tree so we don't leak on crash */
- ret = btrfs_truncate_in_trans(trans, root, inode);
+ ret = btrfs_truncate_in_trans(trans, root, inode,
+ BTRFS_EXTENT_DATA_KEY);
btrfs_update_inode(trans, root, inode);
nr = trans->blocks_used;
trans = btrfs_start_transaction(new_root, 1);
BUG_ON(!trans);
- inode = btrfs_new_inode(trans, new_root, new_dirid,
+ inode = btrfs_new_inode(trans, new_root, "..", 2, new_dirid,
+ new_dirid,
BTRFS_I(dir)->block_group, S_IFDIR | 0700);
if (IS_ERR(inode))
goto fail;
int btrfs_defrag_file(struct file *file) {
struct inode *inode = fdentry(file)->d_inode;
struct btrfs_root *root = BTRFS_I(inode)->root;
- struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+ struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
struct page *page;
unsigned long last_index;
unsigned long ra_index = 0;
u64 page_start;
u64 page_end;
- u64 delalloc_start;
- u64 existing_delalloc;
unsigned long i;
int ret;
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);
- delalloc_start = page_start;
- existing_delalloc =
- count_range_bits(&BTRFS_I(inode)->extent_tree,
- &delalloc_start, page_end,
- PAGE_CACHE_SIZE, EXTENT_DELALLOC);
- set_extent_delalloc(em_tree, page_start,
+ lock_extent(io_tree, page_start, page_end, GFP_NOFS);
+ set_extent_delalloc(io_tree, page_start,
page_end, GFP_NOFS);
- spin_lock(&root->fs_info->delalloc_lock);
- root->fs_info->delalloc_bytes += PAGE_CACHE_SIZE -
- existing_delalloc;
- spin_unlock(&root->fs_info->delalloc_lock);
-
- unlock_extent(em_tree, page_start, page_end, GFP_NOFS);
+ unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
set_page_dirty(page);
unlock_page(page);
page_cache_release(page);
struct inode *inode = dentry->d_inode;
generic_fillattr(inode, stat);
stat->blksize = PAGE_CACHE_SIZE;
+ stat->blocks = inode->i_blocks + (BTRFS_I(inode)->delalloc_bytes >> 9);
return 0;
}
if (ret)
goto out_fail;
}
- ret = btrfs_add_link(trans, new_dentry, old_inode);
+ ret = btrfs_add_link(trans, new_dentry, old_inode, 1);
if (ret)
goto out_fail;
goto out_unlock;
}
- inode = btrfs_new_inode(trans, root, objectid,
+ inode = btrfs_new_inode(trans, root, dentry->d_name.name,
+ dentry->d_name.len,
+ dentry->d_parent->d_inode->i_ino, objectid,
BTRFS_I(dir)->block_group, S_IFLNK|S_IRWXUGO);
err = PTR_ERR(inode);
if (IS_ERR(inode))
goto out_unlock;
btrfs_set_trans_block_group(trans, inode);
- err = btrfs_add_nondir(trans, dentry, inode);
+ err = btrfs_add_nondir(trans, dentry, inode, 0);
if (err)
drop_inode = 1;
else {
inode->i_mapping->a_ops = &btrfs_aops;
+ inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
inode->i_fop = &btrfs_file_operations;
inode->i_op = &btrfs_file_inode_operations;
- extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
+ extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
+ extent_io_tree_init(&BTRFS_I(inode)->io_tree,
inode->i_mapping, GFP_NOFS);
- BTRFS_I(inode)->extent_tree.ops = &btrfs_extent_map_ops;
+ BTRFS_I(inode)->delalloc_bytes = 0;
+ BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
}
dir->i_sb->s_dirt = 1;
btrfs_update_inode_block_group(trans, inode);
inode->i_op = &btrfs_symlink_inode_operations;
inode->i_mapping->a_ops = &btrfs_symlink_aops;
+ inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
inode->i_size = name_len - 1;
err = btrfs_update_inode(trans, root, inode);
if (err)
#endif
};
-static struct extent_map_ops btrfs_extent_map_ops = {
+static struct extent_io_ops btrfs_extent_io_ops = {
.fill_delalloc = run_delalloc_range,
- .writepage_io_hook = btrfs_writepage_io_hook,
+ .submit_bio_hook = btrfs_submit_bio_hook,
+ .merge_bio_hook = btrfs_merge_bio_hook,
.readpage_io_hook = btrfs_readpage_io_hook,
.readpage_end_io_hook = btrfs_readpage_end_io_hook,
+ .set_bit_hook = btrfs_set_bit_hook,
+ .clear_bit_hook = btrfs_clear_bit_hook,
};
static struct address_space_operations btrfs_aops = {