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 kmem_cache *btrfs_inode_cachep;
struct kmem_cache *btrfs_trans_handle_cachep;
[S_IFLNK >> S_SHIFT] = BTRFS_FT_SYMLINK,
};
+static int run_delalloc_range(struct inode *inode, u64 start, u64 end)
+{
+ struct btrfs_root *root = BTRFS_I(inode)->root;
+ struct btrfs_trans_handle *trans;
+ struct btrfs_key ins;
+ u64 alloc_hint = 0;
+ u64 num_bytes;
+ int ret;
+ 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_bytes = (end - start + blocksize) & ~(blocksize - 1);
+ ret = btrfs_drop_extents(trans, root, inode,
+ 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);
+ goto out;
+ }
+ ret = btrfs_insert_file_extent(trans, root, inode->i_ino,
+ start, ins.objectid, ins.offset,
+ ins.offset);
+out:
+ btrfs_end_transaction(trans, root);
+ mutex_unlock(&root->fs_info->fs_mutex);
+ return ret;
+}
+
+int btrfs_writepage_io_hook(struct page *page, u64 start, u64 end)
+{
+ struct inode *inode = page->mapping->host;
+ struct btrfs_root *root = BTRFS_I(inode)->root;
+ struct btrfs_trans_handle *trans;
+ char *kaddr;
+ int ret;
+ 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, inode->i_ino,
+ start, kaddr + offset, end - start + 1);
+ kunmap(page);
+ ret = btrfs_end_transaction(trans, root);
+ BUG_ON(ret);
+ mutex_unlock(&root->fs_info->fs_mutex);
+ return ret;
+}
+
+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 btrfs_csum_item *item;
+ struct btrfs_path *path = NULL;
+ u32 csum;
+
+ mutex_lock(&root->fs_info->fs_mutex);
+ path = btrfs_alloc_path();
+ item = btrfs_lookup_csum(NULL, root, path, inode->i_ino, start, 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 = 0;
+ csum = 0;
+ goto out;
+ }
+ 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);
+ mutex_unlock(&root->fs_info->fs_mutex);
+ return ret;
+}
+
+int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end)
+{
+ 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;
+ }
+ 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);
+ kunmap_atomic(kaddr, KM_IRQ0);
+ local_irq_restore(flags);
+ return 0;
+}
+
void btrfs_read_locked_inode(struct inode *inode)
{
struct btrfs_path *path;
+ struct extent_buffer *leaf;
struct btrfs_inode_item *inode_item;
+ struct btrfs_inode_timespec *tspec;
struct btrfs_root *root = BTRFS_I(inode)->root;
struct btrfs_key location;
u64 alloc_group_block;
memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
- if (ret) {
- btrfs_free_path(path);
+ if (ret)
goto make_bad;
- }
- inode_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
- path->slots[0],
- struct btrfs_inode_item);
- inode->i_mode = btrfs_inode_mode(inode_item);
- inode->i_nlink = btrfs_inode_nlink(inode_item);
- inode->i_uid = btrfs_inode_uid(inode_item);
- inode->i_gid = btrfs_inode_gid(inode_item);
- inode->i_size = btrfs_inode_size(inode_item);
- inode->i_atime.tv_sec = btrfs_timespec_sec(&inode_item->atime);
- inode->i_atime.tv_nsec = btrfs_timespec_nsec(&inode_item->atime);
- inode->i_mtime.tv_sec = btrfs_timespec_sec(&inode_item->mtime);
- inode->i_mtime.tv_nsec = btrfs_timespec_nsec(&inode_item->mtime);
- inode->i_ctime.tv_sec = btrfs_timespec_sec(&inode_item->ctime);
- inode->i_ctime.tv_nsec = btrfs_timespec_nsec(&inode_item->ctime);
- inode->i_blocks = btrfs_inode_nblocks(inode_item);
- inode->i_generation = btrfs_inode_generation(inode_item);
+ leaf = path->nodes[0];
+ inode_item = btrfs_item_ptr(leaf, path->slots[0],
+ struct btrfs_inode_item);
+
+ inode->i_mode = btrfs_inode_mode(leaf, inode_item);
+ inode->i_nlink = btrfs_inode_nlink(leaf, inode_item);
+ inode->i_uid = btrfs_inode_uid(leaf, inode_item);
+ inode->i_gid = btrfs_inode_gid(leaf, inode_item);
+ inode->i_size = btrfs_inode_size(leaf, inode_item);
+
+ tspec = btrfs_inode_atime(inode_item);
+ inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, tspec);
+ inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
+
+ tspec = btrfs_inode_mtime(inode_item);
+ inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, tspec);
+ inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
+
+ tspec = btrfs_inode_ctime(inode_item);
+ inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, tspec);
+ inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
+
+ inode->i_blocks = btrfs_inode_nblocks(leaf, inode_item);
+ inode->i_generation = btrfs_inode_generation(leaf, inode_item);
inode->i_rdev = 0;
- rdev = btrfs_inode_rdev(inode_item);
- alloc_group_block = btrfs_inode_block_group(inode_item);
+ rdev = btrfs_inode_rdev(leaf, inode_item);
+
+ alloc_group_block = btrfs_inode_block_group(leaf, inode_item);
BTRFS_I(inode)->block_group = btrfs_lookup_block_group(root->fs_info,
alloc_group_block);
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_fop = &btrfs_file_operations;
inode->i_op = &btrfs_file_inode_operations;
break;
make_bad_inode(inode);
}
-static void fill_inode_item(struct btrfs_inode_item *item,
+static void fill_inode_item(struct extent_buffer *leaf,
+ struct btrfs_inode_item *item,
struct inode *inode)
{
- btrfs_set_inode_uid(item, inode->i_uid);
- btrfs_set_inode_gid(item, inode->i_gid);
- btrfs_set_inode_size(item, inode->i_size);
- btrfs_set_inode_mode(item, inode->i_mode);
- btrfs_set_inode_nlink(item, inode->i_nlink);
- btrfs_set_timespec_sec(&item->atime, inode->i_atime.tv_sec);
- btrfs_set_timespec_nsec(&item->atime, inode->i_atime.tv_nsec);
- btrfs_set_timespec_sec(&item->mtime, inode->i_mtime.tv_sec);
- btrfs_set_timespec_nsec(&item->mtime, inode->i_mtime.tv_nsec);
- btrfs_set_timespec_sec(&item->ctime, inode->i_ctime.tv_sec);
- btrfs_set_timespec_nsec(&item->ctime, inode->i_ctime.tv_nsec);
- btrfs_set_inode_nblocks(item, inode->i_blocks);
- btrfs_set_inode_generation(item, inode->i_generation);
- btrfs_set_inode_rdev(item, inode->i_rdev);
- btrfs_set_inode_block_group(item,
+ btrfs_set_inode_uid(leaf, item, inode->i_uid);
+ btrfs_set_inode_gid(leaf, item, inode->i_gid);
+ btrfs_set_inode_size(leaf, item, inode->i_size);
+ btrfs_set_inode_mode(leaf, item, inode->i_mode);
+ btrfs_set_inode_nlink(leaf, item, inode->i_nlink);
+
+ btrfs_set_timespec_sec(leaf, btrfs_inode_atime(item),
+ inode->i_atime.tv_sec);
+ btrfs_set_timespec_nsec(leaf, btrfs_inode_atime(item),
+ inode->i_atime.tv_nsec);
+
+ btrfs_set_timespec_sec(leaf, btrfs_inode_mtime(item),
+ inode->i_mtime.tv_sec);
+ btrfs_set_timespec_nsec(leaf, btrfs_inode_mtime(item),
+ inode->i_mtime.tv_nsec);
+
+ btrfs_set_timespec_sec(leaf, btrfs_inode_ctime(item),
+ inode->i_ctime.tv_sec);
+ btrfs_set_timespec_nsec(leaf, btrfs_inode_ctime(item),
+ inode->i_ctime.tv_nsec);
+
+ btrfs_set_inode_nblocks(leaf, item, inode->i_blocks);
+ btrfs_set_inode_generation(leaf, item, inode->i_generation);
+ btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
+ btrfs_set_inode_block_group(leaf, item,
BTRFS_I(inode)->block_group->key.objectid);
}
-static int btrfs_update_inode(struct btrfs_trans_handle *trans,
+int btrfs_update_inode(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct inode *inode)
{
struct btrfs_inode_item *inode_item;
struct btrfs_path *path;
+ struct extent_buffer *leaf;
int ret;
path = btrfs_alloc_path();
goto failed;
}
- inode_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
- path->slots[0],
+ leaf = path->nodes[0];
+ inode_item = btrfs_item_ptr(leaf, path->slots[0],
struct btrfs_inode_item);
- fill_inode_item(inode_item, inode);
- btrfs_mark_buffer_dirty(path->nodes[0]);
+ fill_inode_item(leaf, inode_item, inode);
+ btrfs_mark_buffer_dirty(leaf);
+ btrfs_set_inode_last_trans(trans, inode);
ret = 0;
failed:
btrfs_release_path(root, path);
const char *name = dentry->d_name.name;
int name_len = dentry->d_name.len;
int ret = 0;
- u64 objectid;
+ struct extent_buffer *leaf;
struct btrfs_dir_item *di;
+ struct btrfs_key key;
path = btrfs_alloc_path();
if (!path) {
ret = -ENOENT;
goto err;
}
- objectid = btrfs_disk_key_objectid(&di->location);
+ leaf = path->nodes[0];
+ btrfs_dir_item_key_to_cpu(leaf, di, &key);
ret = btrfs_delete_one_dir_name(trans, root, path, di);
if (ret)
goto err;
btrfs_release_path(root, path);
di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
- objectid, name, name_len, -1);
+ key.objectid, name, name_len, -1);
if (IS_ERR(di)) {
ret = PTR_ERR(di);
goto err;
struct btrfs_root *root;
struct btrfs_trans_handle *trans;
int ret;
+ unsigned long nr;
root = BTRFS_I(dir)->root;
mutex_lock(&root->fs_info->fs_mutex);
trans = btrfs_start_transaction(root, 1);
+
btrfs_set_trans_block_group(trans, dir);
ret = btrfs_unlink_trans(trans, root, dir, dentry);
+ nr = trans->blocks_used;
+
btrfs_end_transaction(trans, root);
mutex_unlock(&root->fs_info->fs_mutex);
- btrfs_btree_balance_dirty(root);
+ btrfs_btree_balance_dirty(root, nr);
+
return ret;
}
struct btrfs_trans_handle *trans;
struct btrfs_key found_key;
int found_type;
- struct btrfs_leaf *leaf;
+ struct extent_buffer *leaf;
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);
trans = btrfs_start_transaction(root, 1);
+
btrfs_set_trans_block_group(trans, dir);
key.objectid = inode->i_ino;
key.offset = (u64)-1;
- key.flags = (u32)-1;
+ key.type = (u8)-1;
while(1) {
ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
if (ret < 0) {
goto out;
}
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]);
found_type = btrfs_key_type(&found_key);
if (found_key.objectid != inode->i_ino) {
err = -ENOENT;
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);
- btrfs_btree_balance_dirty(root);
+ mutex_unlock(&root->fs_info->fs_mutex);
+ btrfs_btree_balance_dirty(root, nr);
if (ret && !err)
err = ret;
return err;
return ret;
}
-/*
- * truncates go from a high offset to a low offset. So, walk
- * from hi to lo in the node and issue readas. Stop when you find
- * keys from a different objectid
- */
-static void reada_truncate(struct btrfs_root *root, struct btrfs_path *path,
- u64 objectid)
-{
- struct btrfs_node *node;
- int i;
- int nritems;
- u64 item_objectid;
- u64 blocknr;
- int slot;
- int ret;
-
- if (!path->nodes[1])
- return;
- node = btrfs_buffer_node(path->nodes[1]);
- slot = path->slots[1];
- if (slot == 0)
- return;
- nritems = btrfs_header_nritems(&node->header);
- for (i = slot - 1; i >= 0; i--) {
- item_objectid = btrfs_disk_key_objectid(&node->ptrs[i].key);
- if (item_objectid != objectid)
- break;
- blocknr = btrfs_node_blockptr(node, i);
- ret = readahead_tree_block(root, blocknr);
- if (ret)
- break;
- }
-}
-
/*
* 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
int ret;
struct btrfs_path *path;
struct btrfs_key key;
- struct btrfs_disk_key *found_key;
+ struct btrfs_key found_key;
u32 found_type;
- struct btrfs_leaf *leaf;
+ 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();
+ path->reada = -1;
BUG_ON(!path);
+
/* FIXME, add redo link to tree so we don't leak on crash */
key.objectid = inode->i_ino;
key.offset = (u64)-1;
- key.flags = (u32)-1;
+ key.type = (u8)-1;
+
while(1) {
btrfs_init_path(path);
fi = NULL;
BUG_ON(path->slots[0] == 0);
path->slots[0]--;
}
- reada_truncate(root, path, inode->i_ino);
- leaf = btrfs_buffer_leaf(path->nodes[0]);
- found_key = &leaf->items[path->slots[0]].key;
- found_type = btrfs_disk_key_type(found_key);
+ leaf = path->nodes[0];
+ btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
+ found_type = btrfs_key_type(&found_key);
- if (btrfs_disk_key_objectid(found_key) != inode->i_ino)
+ 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)
break;
- item_end = btrfs_disk_key_offset(found_key);
+ item_end = found_key.offset;
if (found_type == BTRFS_EXTENT_DATA_KEY) {
- fi = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
- path->slots[0],
+ fi = btrfs_item_ptr(leaf, path->slots[0],
struct btrfs_file_extent_item);
- if (btrfs_file_extent_type(fi) !=
- BTRFS_FILE_EXTENT_INLINE) {
- item_end += btrfs_file_extent_num_blocks(fi) <<
- inode->i_blkbits;
+ extent_type = btrfs_file_extent_type(leaf, fi);
+ if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
+ item_end +=
+ 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 (found_type) {
- btrfs_set_key_type(&key, found_type - 1);
- continue;
+ 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) {
+ found_type = BTRFS_CSUM_ITEM_KEY;
+ } else if (found_type) {
+ found_type--;
+ } else {
+ break;
}
- break;
+ btrfs_set_key_type(&key, found_type);
+ btrfs_release_path(root, path);
+ continue;
}
- if (btrfs_disk_key_offset(found_key) >= inode->i_size)
+ if (found_key.offset >= inode->i_size)
del_item = 1;
else
del_item = 0;
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(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_bytenr(leaf, fi);
if (!del_item) {
- u64 orig_num_blocks =
- btrfs_file_extent_num_blocks(fi);
- extent_num_blocks = inode->i_size -
- btrfs_disk_key_offset(found_key) +
- root->blocksize - 1;
- extent_num_blocks >>= inode->i_blkbits;
- btrfs_set_file_extent_num_blocks(fi,
- extent_num_blocks);
- inode->i_blocks -= (orig_num_blocks -
- extent_num_blocks) << 3;
- btrfs_mark_buffer_dirty(path->nodes[0]);
+ u64 orig_num_bytes =
+ btrfs_file_extent_num_bytes(leaf, fi);
+ extent_num_bytes = inode->i_size -
+ found_key.offset + 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;
+ }
+ btrfs_mark_buffer_dirty(leaf);
} else {
- extent_start =
- btrfs_file_extent_disk_blocknr(fi);
- extent_num_blocks =
- btrfs_file_extent_disk_num_blocks(fi);
+ extent_num_bytes =
+ btrfs_file_extent_disk_num_bytes(leaf,
+ fi);
/* FIXME blocksize != 4096 */
- num_dec = btrfs_file_extent_num_blocks(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);
}
}
return ret;
}
+static int btrfs_cow_one_page(struct inode *inode, struct page *page,
+ size_t zero_start)
+{
+ char *kaddr;
+ int ret = 0;
+ struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+ u64 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
+ u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
+
+ set_page_extent_mapped(page);
+
+ lock_extent(em_tree, page_start, page_end, GFP_NOFS);
+ set_extent_delalloc(&BTRFS_I(inode)->extent_tree, page_start,
+ page_end, GFP_NOFS);
+ if (zero_start != PAGE_CACHE_SIZE) {
+ kaddr = kmap(page);
+ memset(kaddr + zero_start, 0, PAGE_CACHE_SIZE - zero_start);
+ flush_dcache_page(page);
+ kunmap(page);
+ }
+ set_page_dirty(page);
+ unlock_extent(em_tree, page_start, page_end, GFP_NOFS);
+
+ return ret;
+}
+
/*
* taken from block_truncate_page, but does cow as it zeros out
* any bytes left in the last page in the file.
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;
- char *kaddr;
int ret = 0;
- struct btrfs_root *root = BTRFS_I(inode)->root;
- u64 alloc_hint = 0;
- struct btrfs_key ins;
- struct btrfs_trans_handle *trans;
+ u64 page_start;
if ((offset & (blocksize - 1)) == 0)
goto out;
+ down_read(&root->snap_sem);
ret = -ENOMEM;
page = grab_cache_page(mapping, index);
if (!page)
goto out;
-
if (!PageUptodate(page)) {
ret = btrfs_readpage(NULL, page);
lock_page(page);
goto out;
}
}
- mutex_lock(&root->fs_info->fs_mutex);
- trans = btrfs_start_transaction(root, 1);
- btrfs_set_trans_block_group(trans, inode);
+ page_start = (u64)page->index << PAGE_CACHE_SHIFT;
- ret = btrfs_drop_extents(trans, root, inode,
- page->index << PAGE_CACHE_SHIFT,
- (page->index + 1) << PAGE_CACHE_SHIFT,
- &alloc_hint);
- if (ret)
- goto out;
- ret = btrfs_alloc_extent(trans, root, inode->i_ino, 1,
- alloc_hint, (u64)-1, &ins, 1);
- if (ret)
- goto out;
- ret = btrfs_insert_file_extent(trans, root, inode->i_ino,
- page->index << PAGE_CACHE_SHIFT,
- ins.objectid, 1, 1);
- if (ret)
- goto out;
- SetPageChecked(page);
- kaddr = kmap(page);
- memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);
- flush_dcache_page(page);
- ret = btrfs_csum_file_block(trans, root, inode->i_ino,
- page->index << PAGE_CACHE_SHIFT,
- kaddr, PAGE_CACHE_SIZE);
- kunmap(page);
- btrfs_end_transaction(trans, root);
- mutex_unlock(&root->fs_info->fs_mutex);
+ ret = btrfs_cow_one_page(inode, page, offset);
- set_page_dirty(page);
unlock_page(page);
page_cache_release(page);
+ up_read(&BTRFS_I(inode)->root->snap_sem);
out:
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;
- u64 mask = root->blocksize - 1;
+ struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+
+ u64 mask = root->sectorsize - 1;
u64 pos = (inode->i_size + mask) & ~mask;
+ u64 block_end = attr->ia_size | mask;
u64 hole_size;
+ u64 alloc_hint = 0;
if (attr->ia_size <= pos)
goto out;
btrfs_truncate_page(inode->i_mapping, inode->i_size);
+ lock_extent(em_tree, pos, block_end, GFP_NOFS);
hole_size = (attr->ia_size - pos + mask) & ~mask;
- hole_size >>= inode->i_blkbits;
mutex_lock(&root->fs_info->fs_mutex);
trans = btrfs_start_transaction(root, 1);
btrfs_set_trans_block_group(trans, inode);
- err = btrfs_insert_file_extent(trans, root, inode->i_ino,
- pos, 0, 0, hole_size);
+ err = btrfs_drop_extents(trans, root, inode,
+ pos, pos + hole_size, pos,
+ &alloc_hint);
+
+ 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);
if (err)
return err;
}
{
struct btrfs_trans_handle *trans;
struct btrfs_root *root = BTRFS_I(inode)->root;
+ unsigned long nr;
int ret;
truncate_inode_pages(&inode->i_data, 0);
if (is_bad_inode(inode)) {
goto no_delete;
}
+
inode->i_size = 0;
mutex_lock(&root->fs_info->fs_mutex);
trans = btrfs_start_transaction(root, 1);
+
btrfs_set_trans_block_group(trans, inode);
ret = btrfs_truncate_in_trans(trans, root, inode);
if (ret)
ret = btrfs_free_inode(trans, root, inode);
if (ret)
goto no_delete_lock;
+ nr = trans->blocks_used;
+
btrfs_end_transaction(trans, root);
mutex_unlock(&root->fs_info->fs_mutex);
- btrfs_btree_balance_dirty(root);
+ btrfs_btree_balance_dirty(root, nr);
return;
no_delete_lock:
+ nr = trans->blocks_used;
btrfs_end_transaction(trans, root);
mutex_unlock(&root->fs_info->fs_mutex);
- btrfs_btree_balance_dirty(root);
+ btrfs_btree_balance_dirty(root, nr);
no_delete:
clear_inode(inode);
}
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_disk_key_to_cpu(location, &di->location);
+ btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
out:
btrfs_release_path(root, path);
btrfs_free_path(path);
*/
static int fixup_tree_root_location(struct btrfs_root *root,
struct btrfs_key *location,
- struct btrfs_root **sub_root)
+ struct btrfs_root **sub_root,
+ struct dentry *dentry)
{
struct btrfs_path *path;
struct btrfs_root_item *ri;
BUG_ON(!path);
mutex_lock(&root->fs_info->fs_mutex);
- *sub_root = btrfs_read_fs_root(root->fs_info, location);
+ *sub_root = btrfs_read_fs_root(root->fs_info, location,
+ dentry->d_name.name,
+ dentry->d_name.len);
if (IS_ERR(*sub_root))
return PTR_ERR(*sub_root);
ri = &(*sub_root)->root_item;
location->objectid = btrfs_root_dirid(ri);
- location->flags = 0;
btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
location->offset = 0;
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,
+ inode->i_mapping, GFP_NOFS);
return 0;
}
if (dentry->d_name.len > BTRFS_NAME_LEN)
return ERR_PTR(-ENAMETOOLONG);
+
mutex_lock(&root->fs_info->fs_mutex);
ret = btrfs_inode_by_name(dir, dentry, &location);
mutex_unlock(&root->fs_info->fs_mutex);
+
if (ret < 0)
return ERR_PTR(ret);
+
inode = NULL;
if (location.objectid) {
- ret = fixup_tree_root_location(root, &location, &sub_root);
+ ret = fixup_tree_root_location(root, &location, &sub_root,
+ dentry);
if (ret < 0)
return ERR_PTR(ret);
if (ret > 0)
return d_splice_alias(inode, dentry);
}
-/*
- * readahead one full node of leaves as long as their keys include
- * the objectid supplied
- */
-static void reada_leaves(struct btrfs_root *root, struct btrfs_path *path,
- u64 objectid)
-{
- struct btrfs_node *node;
- int i;
- u32 nritems;
- u64 item_objectid;
- u64 blocknr;
- int slot;
- int ret;
-
- if (!path->nodes[1])
- return;
- node = btrfs_buffer_node(path->nodes[1]);
- slot = path->slots[1];
- nritems = btrfs_header_nritems(&node->header);
- for (i = slot + 1; i < nritems; i++) {
- item_objectid = btrfs_disk_key_objectid(&node->ptrs[i].key);
- if (item_objectid != objectid)
- break;
- blocknr = btrfs_node_blockptr(node, i);
- ret = readahead_tree_block(root, blocknr);
- if (ret)
- break;
- }
-}
static unsigned char btrfs_filetype_table[] = {
DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
};
struct btrfs_item *item;
struct btrfs_dir_item *di;
struct btrfs_key key;
+ struct btrfs_key found_key;
struct btrfs_path *path;
int ret;
u32 nritems;
- struct btrfs_leaf *leaf;
+ struct extent_buffer *leaf;
int slot;
int advance;
unsigned char d_type;
u32 di_total;
u32 di_len;
int key_type = BTRFS_DIR_INDEX_KEY;
+ char tmp_name[32];
+ char *name_ptr;
+ int name_len;
/* FIXME, use a real flag for deciding about the key type */
if (root->fs_info->tree_root == root)
key_type = BTRFS_DIR_ITEM_KEY;
+
mutex_lock(&root->fs_info->fs_mutex);
key.objectid = inode->i_ino;
- key.flags = 0;
btrfs_set_key_type(&key, key_type);
key.offset = filp->f_pos;
+
path = btrfs_alloc_path();
+ path->reada = 2;
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
if (ret < 0)
goto err;
advance = 0;
- reada_leaves(root, path, inode->i_ino);
while(1) {
- leaf = btrfs_buffer_leaf(path->nodes[0]);
- nritems = btrfs_header_nritems(&leaf->header);
+ leaf = path->nodes[0];
+ nritems = btrfs_header_nritems(leaf);
slot = path->slots[0];
if (advance || slot >= nritems) {
if (slot >= nritems -1) {
- reada_leaves(root, path, inode->i_ino);
ret = btrfs_next_leaf(root, path);
if (ret)
break;
- leaf = btrfs_buffer_leaf(path->nodes[0]);
- nritems = btrfs_header_nritems(&leaf->header);
+ leaf = path->nodes[0];
+ nritems = btrfs_header_nritems(leaf);
slot = path->slots[0];
} else {
slot++;
}
}
advance = 1;
- item = leaf->items + slot;
- if (btrfs_disk_key_objectid(&item->key) != key.objectid)
+ item = btrfs_item_nr(leaf, slot);
+ btrfs_item_key_to_cpu(leaf, &found_key, slot);
+
+ if (found_key.objectid != key.objectid)
break;
- if (btrfs_disk_key_type(&item->key) != key_type)
+ if (btrfs_key_type(&found_key) != key_type)
break;
- if (btrfs_disk_key_offset(&item->key) < filp->f_pos)
+ if (found_key.offset < filp->f_pos)
continue;
- filp->f_pos = btrfs_disk_key_offset(&item->key);
+
+ filp->f_pos = found_key.offset;
advance = 1;
di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
di_cur = 0;
- di_total = btrfs_item_size(leaf->items + slot);
+ di_total = btrfs_item_size(leaf, item);
while(di_cur < di_total) {
- d_type = btrfs_filetype_table[btrfs_dir_type(di)];
- over = filldir(dirent, (const char *)(di + 1),
- btrfs_dir_name_len(di),
- btrfs_disk_key_offset(&item->key),
- btrfs_disk_key_objectid(&di->location),
+ struct btrfs_key location;
+
+ name_len = btrfs_dir_name_len(leaf, di);
+ if (name_len < 32) {
+ name_ptr = tmp_name;
+ } else {
+ name_ptr = kmalloc(name_len, GFP_NOFS);
+ BUG_ON(!name_ptr);
+ }
+ read_extent_buffer(leaf, name_ptr,
+ (unsigned long)(di + 1), name_len);
+
+ d_type = btrfs_filetype_table[btrfs_dir_type(leaf, di)];
+ btrfs_dir_item_key_to_cpu(leaf, di, &location);
+
+ over = filldir(dirent, name_ptr, name_len,
+ found_key.offset,
+ location.objectid,
d_type);
+
+ if (name_ptr != tmp_name)
+ kfree(name_ptr);
+
if (over)
goto nopos;
- di_len = btrfs_dir_name_len(di) + sizeof(*di);
+ di_len = btrfs_dir_name_len(leaf, di) + sizeof(*di);
di_cur += di_len;
di = (struct btrfs_dir_item *)((char *)di + di_len);
}
int mode)
{
struct inode *inode;
- struct btrfs_inode_item inode_item;
+ struct btrfs_inode_item *inode_item;
struct btrfs_key *location;
+ struct btrfs_path *path;
int ret;
int owner;
+ path = btrfs_alloc_path();
+ BUG_ON(!path);
+
inode = new_inode(root->fs_info->sb);
if (!inode)
return ERR_PTR(-ENOMEM);
+ extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
+ inode->i_mapping, GFP_NOFS);
BTRFS_I(inode)->root = root;
+
if (mode & S_IFDIR)
owner = 0;
else
group = btrfs_find_block_group(root, group, 0, 0, owner);
BTRFS_I(inode)->block_group = group;
+ ret = btrfs_insert_empty_inode(trans, root, path, objectid);
+ if (ret)
+ goto fail;
+
inode->i_uid = current->fsuid;
inode->i_gid = current->fsgid;
inode->i_mode = mode;
inode->i_ino = objectid;
inode->i_blocks = 0;
inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
- fill_inode_item(&inode_item, inode);
+ inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
+ struct btrfs_inode_item);
+ fill_inode_item(path->nodes[0], inode_item, inode);
+ btrfs_mark_buffer_dirty(path->nodes[0]);
+ btrfs_free_path(path);
+
location = &BTRFS_I(inode)->location;
location->objectid = objectid;
- location->flags = 0;
location->offset = 0;
btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
- ret = btrfs_insert_inode(trans, root, objectid, &inode_item);
- if (ret)
- return ERR_PTR(ret);
insert_inode_hash(inode);
return inode;
+fail:
+ btrfs_free_path(path);
+ return ERR_PTR(ret);
}
static inline u8 btrfs_inode_type(struct inode *inode)
struct btrfs_key key;
struct btrfs_root *root = BTRFS_I(dentry->d_parent->d_inode)->root;
struct inode *parent_inode;
+
key.objectid = inode->i_ino;
- key.flags = 0;
btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
key.offset = 0;
int err;
int drop_inode = 0;
u64 objectid;
+ unsigned long nr;
if (!new_valid_dev(rdev))
return -EINVAL;
else {
inode->i_op = &btrfs_special_inode_operations;
init_special_inode(inode, inode->i_mode, rdev);
+ btrfs_update_inode(trans, root, inode);
}
dir->i_sb->s_dirt = 1;
btrfs_update_inode_block_group(trans, inode);
btrfs_update_inode_block_group(trans, dir);
out_unlock:
+ nr = trans->blocks_used;
btrfs_end_transaction(trans, root);
mutex_unlock(&root->fs_info->fs_mutex);
inode_dec_link_count(inode);
iput(inode);
}
- btrfs_btree_balance_dirty(root);
+ btrfs_btree_balance_dirty(root, nr);
return err;
}
struct inode *inode;
int err;
int drop_inode = 0;
+ unsigned long nr;
u64 objectid;
mutex_lock(&root->fs_info->fs_mutex);
inode->i_mapping->a_ops = &btrfs_aops;
inode->i_fop = &btrfs_file_operations;
inode->i_op = &btrfs_file_inode_operations;
+ extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
+ inode->i_mapping, GFP_NOFS);
+ BTRFS_I(inode)->extent_tree.ops = &btrfs_extent_map_ops;
}
dir->i_sb->s_dirt = 1;
btrfs_update_inode_block_group(trans, inode);
btrfs_update_inode_block_group(trans, dir);
out_unlock:
+ nr = trans->blocks_used;
btrfs_end_transaction(trans, root);
mutex_unlock(&root->fs_info->fs_mutex);
inode_dec_link_count(inode);
iput(inode);
}
- btrfs_btree_balance_dirty(root);
+ btrfs_btree_balance_dirty(root, nr);
return err;
}
struct btrfs_trans_handle *trans;
struct btrfs_root *root = BTRFS_I(dir)->root;
struct inode *inode = old_dentry->d_inode;
+ unsigned long nr;
int err;
int drop_inode = 0;
inc_nlink(inode);
mutex_lock(&root->fs_info->fs_mutex);
trans = btrfs_start_transaction(root, 1);
+
btrfs_set_trans_block_group(trans, dir);
atomic_inc(&inode->i_count);
err = btrfs_add_nondir(trans, dentry, inode);
+
if (err)
drop_inode = 1;
+
dir->i_sb->s_dirt = 1;
btrfs_update_inode_block_group(trans, dir);
err = btrfs_update_inode(trans, root, inode);
+
if (err)
drop_inode = 1;
+ nr = trans->blocks_used;
btrfs_end_transaction(trans, root);
mutex_unlock(&root->fs_info->fs_mutex);
inode_dec_link_count(inode);
iput(inode);
}
- btrfs_btree_balance_dirty(root);
+ btrfs_btree_balance_dirty(root, nr);
return err;
}
key.objectid = objectid;
key.offset = 0;
- key.flags = 0;
btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
ret = btrfs_insert_dir_item(trans, root, buf, 1, objectid,
&key, BTRFS_FT_DIR);
if (ret)
goto error;
+
key.objectid = dirid;
ret = btrfs_insert_dir_item(trans, root, buf, 2, objectid,
&key, BTRFS_FT_DIR);
int err = 0;
int drop_on_err = 0;
u64 objectid;
+ unsigned long nr = 1;
mutex_lock(&root->fs_info->fs_mutex);
trans = btrfs_start_transaction(root, 1);
btrfs_set_trans_block_group(trans, dir);
+
if (IS_ERR(trans)) {
err = PTR_ERR(trans);
goto out_unlock;
err = PTR_ERR(inode);
goto out_fail;
}
+
drop_on_err = 1;
inode->i_op = &btrfs_dir_inode_operations;
inode->i_fop = &btrfs_dir_file_operations;
err = btrfs_update_inode(trans, root, inode);
if (err)
goto out_fail;
+
err = btrfs_add_link(trans, dentry, inode);
if (err)
goto out_fail;
+
d_instantiate(dentry, inode);
drop_on_err = 0;
dir->i_sb->s_dirt = 1;
btrfs_update_inode_block_group(trans, dir);
out_fail:
+ nr = trans->blocks_used;
btrfs_end_transaction(trans, root);
+
out_unlock:
mutex_unlock(&root->fs_info->fs_mutex);
if (drop_on_err)
iput(inode);
- btrfs_btree_balance_dirty(root);
+ btrfs_btree_balance_dirty(root, nr);
return err;
}
-/*
- * FIBMAP and others want to pass in a fake buffer head. They need to
- * use BTRFS_GET_BLOCK_NO_DIRECT to make sure we don't try to memcpy
- * any packed file data into the fake bh
- */
-#define BTRFS_GET_BLOCK_NO_CREATE 0
-#define BTRFS_GET_BLOCK_CREATE 1
-#define BTRFS_GET_BLOCK_NO_DIRECT 2
-
-/*
- * FIXME create==1 doe not work.
- */
-static int btrfs_get_block_lock(struct inode *inode, sector_t iblock,
- struct buffer_head *result, int create)
+struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
+ size_t page_offset, u64 start, u64 end,
+ int create)
{
int ret;
int err = 0;
- u64 blocknr;
+ u64 bytenr;
u64 extent_start = 0;
u64 extent_end = 0;
u64 objectid = inode->i_ino;
u32 found_type;
- u64 alloc_hint = 0;
+ int failed_insert = 0;
struct btrfs_path *path;
struct btrfs_root *root = BTRFS_I(inode)->root;
struct btrfs_file_extent_item *item;
- struct btrfs_leaf *leaf;
- struct btrfs_disk_key *found_key;
+ struct extent_buffer *leaf;
+ struct btrfs_key found_key;
+ struct extent_map *em = NULL;
+ struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
struct btrfs_trans_handle *trans = NULL;
path = btrfs_alloc_path();
BUG_ON(!path);
- if (create & BTRFS_GET_BLOCK_CREATE) {
- /*
- * danger!, this only works if the page is properly up
- * to date somehow
- */
- trans = btrfs_start_transaction(root, 1);
- if (!trans) {
+ mutex_lock(&root->fs_info->fs_mutex);
+
+again:
+ em = lookup_extent_mapping(em_tree, start, end);
+ if (em) {
+ goto out;
+ }
+ if (!em) {
+ em = alloc_extent_map(GFP_NOFS);
+ if (!em) {
err = -ENOMEM;
goto out;
}
- ret = btrfs_drop_extents(trans, root, inode,
- iblock << inode->i_blkbits,
- (iblock + 1) << inode->i_blkbits,
- &alloc_hint);
- BUG_ON(ret);
+ em->start = EXTENT_MAP_HOLE;
+ em->end = EXTENT_MAP_HOLE;
}
-
- ret = btrfs_lookup_file_extent(NULL, root, path,
- objectid,
- iblock << inode->i_blkbits, 0);
+ em->bdev = inode->i_sb->s_bdev;
+ ret = btrfs_lookup_file_extent(trans, root, path,
+ objectid, start, trans != NULL);
if (ret < 0) {
err = ret;
goto out;
}
if (ret != 0) {
- if (path->slots[0] == 0) {
- btrfs_release_path(root, path);
+ if (path->slots[0] == 0)
goto not_found;
- }
path->slots[0]--;
}
- 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);
- leaf = btrfs_buffer_leaf(path->nodes[0]);
- blocknr = btrfs_file_extent_disk_blocknr(item);
- blocknr += btrfs_file_extent_offset(item);
-
/* are we inside the extent that was found? */
- found_key = &leaf->items[path->slots[0]].key;
- found_type = btrfs_disk_key_type(found_key);
- if (btrfs_disk_key_objectid(found_key) != objectid ||
+ btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
+ found_type = btrfs_key_type(&found_key);
+ if (found_key.objectid != objectid ||
found_type != BTRFS_EXTENT_DATA_KEY) {
- extent_end = 0;
- extent_start = 0;
goto not_found;
}
- found_type = btrfs_file_extent_type(item);
- extent_start = btrfs_disk_key_offset(&leaf->items[path->slots[0]].key);
+
+ found_type = btrfs_file_extent_type(leaf, item);
+ extent_start = found_key.offset;
if (found_type == BTRFS_FILE_EXTENT_REG) {
- extent_start = extent_start >> inode->i_blkbits;
- extent_end = extent_start + btrfs_file_extent_num_blocks(item);
+ extent_end = extent_start +
+ btrfs_file_extent_num_bytes(leaf, item);
err = 0;
- if (btrfs_file_extent_disk_blocknr(item) == 0)
- goto out;
- if (iblock >= extent_start && iblock < extent_end) {
- btrfs_map_bh_to_logical(root, result, blocknr +
- iblock - extent_start);
- goto out;
+ if (start < extent_start || start >= extent_end) {
+ em->start = start;
+ if (start < extent_start) {
+ if (end < extent_start)
+ goto not_found;
+ em->end = extent_end - 1;
+ } else {
+ em->end = end;
+ }
+ 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->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;
+ goto insert;
} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
- char *ptr;
+ 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 + size - 1) |
+ ((u64)root->sectorsize - 1);
+ if (start < extent_start || start >= extent_end) {
+ em->start = start;
+ if (start < extent_start) {
+ if (end < extent_start)
+ goto not_found;
+ em->end = extent_end;
+ } else {
+ em->end = end;
+ }
+ goto not_found_em;
+ }
+ em->block_start = EXTENT_MAP_INLINE;
+ em->block_end = EXTENT_MAP_INLINE;
- if (create & BTRFS_GET_BLOCK_NO_DIRECT) {
- err = -EINVAL;
+ if (!page) {
+ em->start = extent_start;
+ em->end = extent_start + size - 1;
goto out;
}
- size = btrfs_file_extent_inline_len(leaf->items +
- path->slots[0]);
- extent_end = (extent_start + size) >> inode->i_blkbits;
- extent_start >>= inode->i_blkbits;
- if (iblock < extent_start || iblock > extent_end) {
- goto not_found;
+
+ 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);
+ 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);
}
- ptr = btrfs_file_extent_inline_start(item);
- map = kmap(result->b_page);
- memcpy(map, ptr, size);
- memset(map + size, 0, PAGE_CACHE_SIZE - size);
- flush_dcache_page(result->b_page);
- kunmap(result->b_page);
- set_buffer_uptodate(result);
- SetPageChecked(result->b_page);
- btrfs_map_bh_to_logical(root, result, 0);
+ kunmap(page);
+ set_extent_uptodate(em_tree, em->start, em->end, GFP_NOFS);
+ goto insert;
+ } else {
+ printk("unkknown found_type %d\n", found_type);
+ WARN_ON(1);
}
not_found:
- if (create & BTRFS_GET_BLOCK_CREATE) {
- struct btrfs_key ins;
- ret = btrfs_alloc_extent(trans, root, inode->i_ino,
- 1, alloc_hint, (u64)-1,
- &ins, 1);
- if (ret) {
- err = ret;
- goto out;
- }
- ret = btrfs_insert_file_extent(trans, root, inode->i_ino,
- iblock << inode->i_blkbits,
- ins.objectid, ins.offset,
- ins.offset);
- if (ret) {
- err = ret;
+ em->start = start;
+ em->end = end;
+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);
+ err = -EIO;
+ goto out;
+ }
+ ret = add_extent_mapping(em_tree, em);
+ if (ret == -EEXIST) {
+ free_extent_map(em);
+ em = NULL;
+ failed_insert++;
+ if (failed_insert > 5) {
+ printk("failing to insert %Lu %Lu\n", start, end);
+ err = -EIO;
goto out;
}
- btrfs_map_bh_to_logical(root, result, ins.objectid);
+ goto again;
}
+ err = 0;
out:
+ btrfs_free_path(path);
if (trans) {
ret = btrfs_end_transaction(trans, root);
if (!err)
err = ret;
}
- btrfs_free_path(path);
- return err;
-}
-
-int btrfs_get_block(struct inode *inode, sector_t iblock,
- struct buffer_head *result, int create)
-{
- int err;
- struct btrfs_root *root = BTRFS_I(inode)->root;
- mutex_lock(&root->fs_info->fs_mutex);
- err = btrfs_get_block_lock(inode, iblock, result, create);
mutex_unlock(&root->fs_info->fs_mutex);
- return err;
-}
-
-static int btrfs_get_block_csum(struct inode *inode, sector_t iblock,
- struct buffer_head *result, int create)
-{
- int ret;
- struct btrfs_root *root = BTRFS_I(inode)->root;
- struct page *page = result->b_page;
- u64 offset = (page->index << PAGE_CACHE_SHIFT) + bh_offset(result);
- struct btrfs_csum_item *item;
- struct btrfs_path *path = NULL;
-
- mutex_lock(&root->fs_info->fs_mutex);
- ret = btrfs_get_block_lock(inode, iblock, result, create);
- if (ret)
- goto out;
-
- path = btrfs_alloc_path();
- item = btrfs_lookup_csum(NULL, root, path, inode->i_ino, 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 = 0;
- result->b_private = NULL;
- goto out;
+ if (err) {
+ free_extent_map(em);
+ WARN_ON(1);
+ return ERR_PTR(err);
}
- memcpy((char *)&result->b_private, &item->csum, BTRFS_CRC32_SIZE);
-out:
- if (path)
- btrfs_free_path(path);
- mutex_unlock(&root->fs_info->fs_mutex);
- return ret;
+ return em;
}
-static int btrfs_get_block_bmap(struct inode *inode, sector_t iblock,
- struct buffer_head *result, int create)
+static sector_t btrfs_bmap(struct address_space *mapping, sector_t iblock)
{
- struct btrfs_root *root = BTRFS_I(inode)->root;
- mutex_lock(&root->fs_info->fs_mutex);
- btrfs_get_block_lock(inode, iblock, result, BTRFS_GET_BLOCK_NO_DIRECT);
- mutex_unlock(&root->fs_info->fs_mutex);
- return 0;
-}
-
-static sector_t btrfs_bmap(struct address_space *as, sector_t block)
-{
- return generic_block_bmap(as, block, btrfs_get_block_bmap);
+ return extent_bmap(mapping, iblock, btrfs_get_extent);
}
static int btrfs_prepare_write(struct file *file, struct page *page,
unsigned from, unsigned to)
{
- return block_prepare_write(page, from, to, btrfs_get_block);
-}
-
-static void buffer_io_error(struct buffer_head *bh)
-{
- char b[BDEVNAME_SIZE];
-
- printk(KERN_ERR "Buffer I/O error on device %s, logical block %Lu\n",
- bdevname(bh->b_bdev, b),
- (unsigned long long)bh->b_blocknr);
-}
-
-/*
- * I/O completion handler for block_read_full_page() - pages
- * which come unlocked at the end of I/O.
- */
-static void btrfs_end_buffer_async_read(struct buffer_head *bh, int uptodate)
-{
- unsigned long flags;
- struct buffer_head *first;
- struct buffer_head *tmp;
- struct page *page;
- int page_uptodate = 1;
- struct inode *inode;
- int ret;
-
- BUG_ON(!buffer_async_read(bh));
-
- page = bh->b_page;
- inode = page->mapping->host;
- if (uptodate) {
- void *kaddr;
- struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
- if (bh->b_private) {
- char csum[BTRFS_CRC32_SIZE];
- kaddr = kmap_atomic(page, KM_IRQ0);
- ret = btrfs_csum_data(root, kaddr + bh_offset(bh),
- bh->b_size, csum);
- BUG_ON(ret);
- if (memcmp(csum, &bh->b_private, BTRFS_CRC32_SIZE)) {
- u64 offset;
- offset = (page->index << PAGE_CACHE_SHIFT) +
- bh_offset(bh);
- printk("btrfs csum failed ino %lu off %llu\n",
- page->mapping->host->i_ino,
- (unsigned long long)offset);
- memset(kaddr + bh_offset(bh), 1, bh->b_size);
- flush_dcache_page(page);
- }
- kunmap_atomic(kaddr, KM_IRQ0);
- }
- set_buffer_uptodate(bh);
- } else {
- clear_buffer_uptodate(bh);
- if (printk_ratelimit())
- buffer_io_error(bh);
- SetPageError(page);
- }
-
- /*
- * Be _very_ careful from here on. Bad things can happen if
- * two buffer heads end IO at almost the same time and both
- * decide that the page is now completely done.
- */
- first = page_buffers(page);
- local_irq_save(flags);
- bit_spin_lock(BH_Uptodate_Lock, &first->b_state);
- clear_buffer_async_read(bh);
- unlock_buffer(bh);
- tmp = bh;
- do {
- if (!buffer_uptodate(tmp))
- page_uptodate = 0;
- if (buffer_async_read(tmp)) {
- BUG_ON(!buffer_locked(tmp));
- goto still_busy;
- }
- tmp = tmp->b_this_page;
- } while (tmp != bh);
- bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);
- local_irq_restore(flags);
-
- /*
- * If none of the buffers had errors and they are all
- * uptodate then we can set the page uptodate.
- */
- if (page_uptodate && !PageError(page))
- SetPageUptodate(page);
- unlock_page(page);
- return;
-
-still_busy:
- bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);
- local_irq_restore(flags);
- return;
+ return extent_prepare_write(&BTRFS_I(page->mapping->host)->extent_tree,
+ page->mapping->host, page, from, to,
+ btrfs_get_extent);
}
-/*
- * Generic "read page" function for block devices that have the normal
- * get_block functionality. This is most of the block device filesystems.
- * Reads the page asynchronously --- the unlock_buffer() and
- * set/clear_buffer_uptodate() functions propagate buffer state into the
- * page struct once IO has completed.
- */
int btrfs_readpage(struct file *file, struct page *page)
{
- struct inode *inode = page->mapping->host;
- sector_t iblock, lblock;
- struct buffer_head *bh, *head, *arr[MAX_BUF_PER_PAGE];
- unsigned int blocksize;
- int nr, i;
- int fully_mapped = 1;
-
- BUG_ON(!PageLocked(page));
- blocksize = 1 << inode->i_blkbits;
- if (!page_has_buffers(page))
- create_empty_buffers(page, blocksize, 0);
- head = page_buffers(page);
-
- iblock = (sector_t)page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
- lblock = (i_size_read(inode)+blocksize-1) >> inode->i_blkbits;
- bh = head;
- nr = 0;
- i = 0;
-
- do {
- if (buffer_uptodate(bh))
- continue;
-
- if (!buffer_mapped(bh)) {
- int err = 0;
-
- fully_mapped = 0;
- if (iblock < lblock) {
- WARN_ON(bh->b_size != blocksize);
- err = btrfs_get_block_csum(inode, iblock,
- bh, 0);
- if (err)
- SetPageError(page);
- }
- if (!buffer_mapped(bh)) {
- void *kaddr = kmap_atomic(page, KM_USER0);
- memset(kaddr + i * blocksize, 0, blocksize);
- flush_dcache_page(page);
- kunmap_atomic(kaddr, KM_USER0);
- if (!err)
- set_buffer_uptodate(bh);
- continue;
- }
- /*
- * get_block() might have updated the buffer
- * synchronously
- */
- if (buffer_uptodate(bh))
- continue;
- }
- arr[nr++] = bh;
- } while (i++, iblock++, (bh = bh->b_this_page) != head);
-
- if (fully_mapped)
- SetPageMappedToDisk(page);
-
- if (!nr) {
- /*
- * All buffers are uptodate - we can set the page uptodate
- * as well. But not if get_block() returned an error.
- */
- if (!PageError(page))
- SetPageUptodate(page);
- unlock_page(page);
- return 0;
- }
-
- /* Stage two: lock the buffers */
- for (i = 0; i < nr; i++) {
- bh = arr[i];
- lock_buffer(bh);
- bh->b_end_io = btrfs_end_buffer_async_read;
- set_buffer_async_read(bh);
- }
-
- /*
- * Stage 3: start the IO. Check for uptodateness
- * inside the buffer lock in case another process reading
- * the underlying blockdev brought it uptodate (the sct fix).
- */
- for (i = 0; i < nr; i++) {
- bh = arr[i];
- if (buffer_uptodate(bh))
- btrfs_end_buffer_async_read(bh, 1);
- else
- submit_bh(READ, bh);
- }
- return 0;
+ struct extent_map_tree *tree;
+ tree = &BTRFS_I(page->mapping->host)->extent_tree;
+ return extent_read_full_page(tree, page, btrfs_get_extent);
}
-
-/*
- * Aside from a tiny bit of packed file data handling, this is the
- * same as the generic code.
- *
- * While block_write_full_page is writing back the dirty buffers under
- * the page lock, whoever dirtied the buffers may decide to clean them
- * again at any time. We handle that by only looking at the buffer
- * state inside lock_buffer().
- *
- * If block_write_full_page() is called for regular writeback
- * (wbc->sync_mode == WB_SYNC_NONE) then it will redirty a page which has a
- * locked buffer. This only can happen if someone has written the buffer
- * directly, with submit_bh(). At the address_space level PageWriteback
- * prevents this contention from occurring.
- */
-static int __btrfs_write_full_page(struct inode *inode, struct page *page,
- struct writeback_control *wbc)
+static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
{
- int err;
- sector_t block;
- sector_t last_block;
- struct buffer_head *bh, *head;
- const unsigned blocksize = 1 << inode->i_blkbits;
- int nr_underway = 0;
- struct btrfs_root *root = BTRFS_I(inode)->root;
-
- BUG_ON(!PageLocked(page));
+ struct extent_map_tree *tree;
- last_block = (i_size_read(inode) - 1) >> inode->i_blkbits;
- /* no csumming allowed when from PF_MEMALLOC */
if (current->flags & PF_MEMALLOC) {
redirty_page_for_writepage(wbc, page);
unlock_page(page);
return 0;
}
+ tree = &BTRFS_I(page->mapping->host)->extent_tree;
+ return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
+}
- if (!page_has_buffers(page)) {
- create_empty_buffers(page, blocksize,
- (1 << BH_Dirty)|(1 << BH_Uptodate));
- }
-
- /*
- * Be very careful. We have no exclusion from __set_page_dirty_buffers
- * here, and the (potentially unmapped) buffers may become dirty at
- * any time. If a buffer becomes dirty here after we've inspected it
- * then we just miss that fact, and the page stays dirty.
- *
- * Buffers outside i_size may be dirtied by __set_page_dirty_buffers;
- * handle that here by just cleaning them.
- */
-
- block = (sector_t)page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
- head = page_buffers(page);
- bh = head;
-
- /*
- * Get all the dirty buffers mapped to disk addresses and
- * handle any aliases from the underlying blockdev's mapping.
- */
- do {
- if (block > last_block) {
- /*
- * mapped buffers outside i_size will occur, because
- * this page can be outside i_size when there is a
- * truncate in progress.
- */
- /*
- * The buffer was zeroed by block_write_full_page()
- */
- clear_buffer_dirty(bh);
- set_buffer_uptodate(bh);
- } else if (!buffer_mapped(bh) && buffer_dirty(bh)) {
- WARN_ON(bh->b_size != blocksize);
- err = btrfs_get_block(inode, block, bh, 0);
- if (err) {
- goto recover;
- }
- if (buffer_new(bh)) {
- /* blockdev mappings never come here */
- clear_buffer_new(bh);
- }
- }
- bh = bh->b_this_page;
- block++;
- } while (bh != head);
- do {
- if (!buffer_mapped(bh))
- continue;
- /*
- * If it's a fully non-blocking write attempt and we cannot
- * lock the buffer then redirty the page. Note that this can
- * potentially cause a busy-wait loop from pdflush and kswapd
- * activity, but those code paths have their own higher-level
- * throttling.
- */
- if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) {
- lock_buffer(bh);
- } else if (test_set_buffer_locked(bh)) {
- redirty_page_for_writepage(wbc, page);
- continue;
- }
- if (test_clear_buffer_dirty(bh) && bh->b_blocknr != 0) {
- struct btrfs_trans_handle *trans;
- int ret;
- u64 off = page->index << PAGE_CACHE_SHIFT;
- char *kaddr;
-
- off += bh_offset(bh);
- 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,
- off, kaddr + bh_offset(bh),
- bh->b_size);
- kunmap(page);
- ret = btrfs_end_transaction(trans, root);
- BUG_ON(ret);
- mutex_unlock(&root->fs_info->fs_mutex);
- mark_buffer_async_write(bh);
- } else {
- unlock_buffer(bh);
- }
- } while ((bh = bh->b_this_page) != head);
+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);
+}
- /*
- * The page and its buffers are protected by PageWriteback(), so we can
- * drop the bh refcounts early.
- */
- BUG_ON(PageWriteback(page));
- set_page_writeback(page);
-
- do {
- struct buffer_head *next = bh->b_this_page;
- if (buffer_async_write(bh)) {
- submit_bh(WRITE, bh);
- nr_underway++;
- }
- bh = next;
- } while (bh != head);
- unlock_page(page);
+static int btrfs_releasepage(struct page *page, gfp_t unused_gfp_flags)
+{
+ struct extent_map_tree *tree;
+ int ret;
- err = 0;
-done:
- if (nr_underway == 0) {
- /*
- * The page was marked dirty, but the buffers were
- * clean. Someone wrote them back by hand with
- * ll_rw_block/submit_bh. A rare case.
- */
- int uptodate = 1;
- do {
- if (!buffer_uptodate(bh)) {
- uptodate = 0;
- break;
- }
- bh = bh->b_this_page;
- } while (bh != head);
- if (uptodate)
- SetPageUptodate(page);
- end_page_writeback(page);
+ tree = &BTRFS_I(page->mapping->host)->extent_tree;
+ ret = try_release_extent_mapping(tree, page);
+ if (ret == 1) {
+ ClearPagePrivate(page);
+ set_page_private(page, 0);
+ page_cache_release(page);
}
- return err;
-
-recover:
- /*
- * ENOSPC, or some other error. We may already have added some
- * blocks to the file, so we need to write these out to avoid
- * exposing stale data.
- * The page is currently locked and not marked for writeback
- */
- bh = head;
- /* Recovery: lock and submit the mapped buffers */
- do {
- if (buffer_mapped(bh) && buffer_dirty(bh)) {
- lock_buffer(bh);
- mark_buffer_async_write(bh);
- } else {
- /*
- * The buffer may have been set dirty during
- * attachment to a dirty page.
- */
- clear_buffer_dirty(bh);
- }
- } while ((bh = bh->b_this_page) != head);
- SetPageError(page);
- BUG_ON(PageWriteback(page));
- set_page_writeback(page);
- do {
- struct buffer_head *next = bh->b_this_page;
- if (buffer_async_write(bh)) {
- clear_buffer_dirty(bh);
- submit_bh(WRITE, bh);
- nr_underway++;
- }
- bh = next;
- } while (bh != head);
- unlock_page(page);
- goto done;
+ return ret;
}
-static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
+static void btrfs_invalidatepage(struct page *page, unsigned long offset)
{
- struct inode * const inode = page->mapping->host;
- loff_t i_size = i_size_read(inode);
- const pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
- unsigned offset;
- void *kaddr;
-
- /* Is the page fully inside i_size? */
- if (page->index < end_index)
- return __btrfs_write_full_page(inode, page, wbc);
-
- /* Is the page fully outside i_size? (truncate in progress) */
- offset = i_size & (PAGE_CACHE_SIZE-1);
- if (page->index >= end_index+1 || !offset) {
- /*
- * The page may have dirty, unmapped buffers. For example,
- * they may have been added in ext3_writepage(). Make them
- * freeable here, so the page does not leak.
- */
- block_invalidatepage(page, 0);
- unlock_page(page);
- return 0; /* don't care */
- }
+ struct extent_map_tree *tree;
- /*
- * The page straddles i_size. It must be zeroed out on each and every
- * writepage invokation because it may be mmapped. "A file is mapped
- * in multiples of the page size. For a file that is not a multiple of
- * the page size, the remaining memory is zeroed when mapped, and
- * writes to that region are not written out to the file."
- */
- kaddr = kmap_atomic(page, KM_USER0);
- memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);
- flush_dcache_page(page);
- kunmap_atomic(kaddr, KM_USER0);
- return __btrfs_write_full_page(inode, page, wbc);
+ tree = &BTRFS_I(page->mapping->host)->extent_tree;
+ extent_invalidatepage(tree, page, offset);
+ btrfs_releasepage(page, GFP_NOFS);
}
/*
unsigned long end;
loff_t size;
int ret = -EINVAL;
+ u64 page_start;
+ down_read(&BTRFS_I(inode)->root->snap_sem);
lock_page(page);
wait_on_page_writeback(page);
size = i_size_read(inode);
+ page_start = (u64)page->index << PAGE_CACHE_SHIFT;
+
if ((page->mapping != inode->i_mapping) ||
- ((page->index << PAGE_CACHE_SHIFT) > size)) {
+ (page_start > size)) {
/* page got truncated out from underneath us */
goto out_unlock;
}
/* page is wholly or partially inside EOF */
- if (((page->index + 1) << PAGE_CACHE_SHIFT) > size)
+ if (page_start + PAGE_CACHE_SIZE > size)
end = size & ~PAGE_CACHE_MASK;
else
end = PAGE_CACHE_SIZE;
- ret = btrfs_prepare_write(NULL, page, 0, end);
- if (!ret)
- ret = btrfs_commit_write(NULL, page, 0, end);
+ ret = btrfs_cow_one_page(inode, page, end);
out_unlock:
+ up_read(&BTRFS_I(inode)->root->snap_sem);
unlock_page(page);
return ret;
}
struct btrfs_root *root = BTRFS_I(inode)->root;
int ret;
struct btrfs_trans_handle *trans;
+ unsigned long nr;
if (!S_ISREG(inode->i_mode))
return;
/* FIXME, add redo link to tree so we don't leak on crash */
ret = btrfs_truncate_in_trans(trans, root, inode);
btrfs_update_inode(trans, root, inode);
+ nr = trans->blocks_used;
+
ret = btrfs_end_transaction(trans, root);
BUG_ON(ret);
mutex_unlock(&root->fs_info->fs_mutex);
- btrfs_btree_balance_dirty(root);
+ btrfs_btree_balance_dirty(root, nr);
}
int btrfs_commit_write(struct file *file, struct page *page,
unsigned from, unsigned to)
{
- struct inode *inode = page->mapping->host;
- struct buffer_head *bh;
- loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
-
- SetPageUptodate(page);
- bh = page_buffers(page);
- set_buffer_uptodate(bh);
- if (buffer_mapped(bh) && bh->b_blocknr != 0) {
- set_page_dirty(page);
- }
- if (pos > inode->i_size) {
- i_size_write(inode, pos);
- mark_inode_dirty(inode);
- }
- return 0;
+ return extent_commit_write(&BTRFS_I(page->mapping->host)->extent_tree,
+ page->mapping->host, page, from, to);
}
static int create_subvol(struct btrfs_root *root, char *name, int namelen)
struct btrfs_key key;
struct btrfs_root_item root_item;
struct btrfs_inode_item *inode_item;
- struct buffer_head *subvol;
- struct btrfs_leaf *leaf;
+ struct extent_buffer *leaf;
struct btrfs_root *new_root;
struct inode *inode;
struct inode *dir;
int err;
u64 objectid;
u64 new_dirid = BTRFS_FIRST_FREE_OBJECTID;
+ unsigned long nr = 1;
mutex_lock(&root->fs_info->fs_mutex);
trans = btrfs_start_transaction(root, 1);
BUG_ON(!trans);
- subvol = btrfs_alloc_free_block(trans, root, 0);
- if (IS_ERR(subvol))
- return PTR_ERR(subvol);
- leaf = btrfs_buffer_leaf(subvol);
- btrfs_set_header_nritems(&leaf->header, 0);
- btrfs_set_header_level(&leaf->header, 0);
- btrfs_set_header_blocknr(&leaf->header, bh_blocknr(subvol));
- btrfs_set_header_generation(&leaf->header, trans->transid);
- btrfs_set_header_owner(&leaf->header, root->root_key.objectid);
- memcpy(leaf->header.fsid, root->fs_info->disk_super->fsid,
- sizeof(leaf->header.fsid));
- btrfs_mark_buffer_dirty(subvol);
+ 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_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,
+ (unsigned long)btrfs_header_fsid(leaf),
+ BTRFS_FSID_SIZE);
+ btrfs_mark_buffer_dirty(leaf);
inode_item = &root_item.inode;
memset(inode_item, 0, sizeof(*inode_item));
- btrfs_set_inode_generation(inode_item, 1);
- btrfs_set_inode_size(inode_item, 3);
- btrfs_set_inode_nlink(inode_item, 1);
- btrfs_set_inode_nblocks(inode_item, 1);
- btrfs_set_inode_mode(inode_item, S_IFDIR | 0755);
-
- btrfs_set_root_blocknr(&root_item, bh_blocknr(subvol));
+ inode_item->generation = cpu_to_le64(1);
+ inode_item->size = cpu_to_le64(3);
+ inode_item->nlink = cpu_to_le32(1);
+ inode_item->nblocks = cpu_to_le64(1);
+ inode_item->mode = cpu_to_le32(S_IFDIR | 0755);
+
+ 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);
+
memset(&root_item.drop_progress, 0, sizeof(root_item.drop_progress));
root_item.drop_level = 0;
- brelse(subvol);
- subvol = NULL;
+
+ free_extent_buffer(leaf);
+ leaf = NULL;
ret = btrfs_find_free_objectid(trans, root->fs_info->tree_root,
0, &objectid);
key.objectid = objectid;
key.offset = 1;
- key.flags = 0;
btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
&root_item);
if (ret)
goto fail_commit;
- new_root = btrfs_read_fs_root(root->fs_info, &key);
+ new_root = btrfs_read_fs_root(root->fs_info, &key, name, namelen);
BUG_ON(!new_root);
trans = btrfs_start_transaction(new_root, 1);
if (ret)
goto fail;
fail:
+ nr = trans->blocks_used;
err = btrfs_commit_transaction(trans, root);
if (err && !ret)
ret = err;
fail_commit:
mutex_unlock(&root->fs_info->fs_mutex);
- btrfs_btree_balance_dirty(root);
+ btrfs_btree_balance_dirty(root, nr);
return ret;
}
struct btrfs_trans_handle *trans;
struct btrfs_key key;
struct btrfs_root_item new_root_item;
+ struct extent_buffer *tmp;
int ret;
int err;
u64 objectid;
+ unsigned long nr;
if (!root->ref_cows)
return -EINVAL;
+ down_write(&root->snap_sem);
+ freeze_bdev(root->fs_info->sb->s_bdev);
+ thaw_bdev(root->fs_info->sb->s_bdev, root->fs_info->sb);
+
mutex_lock(&root->fs_info->fs_mutex);
trans = btrfs_start_transaction(root, 1);
BUG_ON(!trans);
key.objectid = objectid;
key.offset = 1;
- key.flags = 0;
btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
- btrfs_set_root_blocknr(&new_root_item, bh_blocknr(root->node));
+
+ btrfs_cow_block(trans, root, root->node, NULL, 0, &tmp);
+ 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);
ret = btrfs_inc_root_ref(trans, root);
if (ret)
goto fail;
-
fail:
+ nr = trans->blocks_used;
err = btrfs_commit_transaction(trans, root);
+
if (err && !ret)
ret = err;
+
mutex_unlock(&root->fs_info->fs_mutex);
- btrfs_btree_balance_dirty(root);
+ up_write(&root->snap_sem);
+ btrfs_btree_balance_dirty(root, nr);
return ret;
}
-int btrfs_ioctl(struct inode *inode, struct file *filp, unsigned int
- cmd, unsigned long arg)
+static unsigned long force_ra(struct address_space *mapping,
+ struct file_ra_state *ra, struct file *file,
+ pgoff_t offset, pgoff_t last_index)
+{
+ pgoff_t req_size;
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
+ req_size = last_index - offset + 1;
+ offset = page_cache_readahead(mapping, ra, file, offset, req_size);
+ return offset;
+#else
+ req_size = min(last_index - offset + 1, (pgoff_t)128);
+ page_cache_sync_readahead(mapping, ra, file, offset, req_size);
+ return offset + req_size;
+#endif
+}
+
+int btrfs_defrag_file(struct file *file) {
+ struct inode *inode = file->f_path.dentry->d_inode;
+ struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+ struct page *page;
+ unsigned long last_index;
+ unsigned long ra_index = 0;
+ u64 page_start;
+ u64 page_end;
+ unsigned long i;
+
+ mutex_lock(&inode->i_mutex);
+ last_index = inode->i_size >> PAGE_CACHE_SHIFT;
+ for (i = 0; i <= last_index; i++) {
+ if (i == ra_index) {
+ ra_index = force_ra(inode->i_mapping, &file->f_ra,
+ file, ra_index, last_index);
+ }
+ page = grab_cache_page(inode->i_mapping, i);
+ if (!page)
+ goto out_unlock;
+ if (!PageUptodate(page)) {
+ btrfs_readpage(NULL, page);
+ lock_page(page);
+ if (!PageUptodate(page)) {
+ unlock_page(page);
+ page_cache_release(page);
+ goto out_unlock;
+ }
+ }
+ 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);
+ set_extent_delalloc(em_tree, page_start,
+ page_end, GFP_NOFS);
+ unlock_extent(em_tree, page_start, page_end, GFP_NOFS);
+ set_page_dirty(page);
+ unlock_page(page);
+ page_cache_release(page);
+ balance_dirty_pages_ratelimited_nr(inode->i_mapping, 1);
+ }
+
+out_unlock:
+ mutex_unlock(&inode->i_mutex);
+ return 0;
+}
+
+static int btrfs_ioctl_snap_create(struct btrfs_root *root, void __user *arg)
{
- struct btrfs_root *root = BTRFS_I(inode)->root;
struct btrfs_ioctl_vol_args vol_args;
- int ret = 0;
struct btrfs_dir_item *di;
- int namelen;
struct btrfs_path *path;
+ int namelen;
u64 root_dirid;
- switch (cmd) {
- case BTRFS_IOC_SNAP_CREATE:
- if (copy_from_user(&vol_args,
- (struct btrfs_ioctl_vol_args __user *)arg,
- sizeof(vol_args)))
- return -EFAULT;
- namelen = strlen(vol_args.name);
- if (namelen > BTRFS_VOL_NAME_MAX)
- return -EINVAL;
- if (strchr(vol_args.name, '/'))
- return -EINVAL;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- root_dirid = root->fs_info->sb->s_root->d_inode->i_ino,
+ if (copy_from_user(&vol_args, arg, sizeof(vol_args)))
+ return -EFAULT;
+
+ namelen = strlen(vol_args.name);
+ if (namelen > BTRFS_VOL_NAME_MAX)
+ return -EINVAL;
+ if (strchr(vol_args.name, '/'))
+ return -EINVAL;
+
+ path = btrfs_alloc_path();
+ if (!path)
+ return -ENOMEM;
+
+ root_dirid = root->fs_info->sb->s_root->d_inode->i_ino,
+ mutex_lock(&root->fs_info->fs_mutex);
+ di = btrfs_lookup_dir_item(NULL, root->fs_info->tree_root,
+ path, root_dirid,
+ vol_args.name, namelen, 0);
+ mutex_unlock(&root->fs_info->fs_mutex);
+ btrfs_free_path(path);
+ if (di && !IS_ERR(di))
+ return -EEXIST;
+ if (IS_ERR(di))
+ return PTR_ERR(di);
+
+ if (root == root->fs_info->tree_root)
+ return create_subvol(root, vol_args.name, namelen);
+ return create_snapshot(root, vol_args.name, namelen);
+}
+
+static int btrfs_ioctl_defrag(struct file *file)
+{
+ struct inode *inode = file->f_path.dentry->d_inode;
+ struct btrfs_root *root = BTRFS_I(inode)->root;
+
+ switch (inode->i_mode & S_IFMT) {
+ case S_IFDIR:
mutex_lock(&root->fs_info->fs_mutex);
- di = btrfs_lookup_dir_item(NULL, root->fs_info->tree_root,
- path, root_dirid,
- vol_args.name, namelen, 0);
+ btrfs_defrag_root(root, 0);
+ btrfs_defrag_root(root->fs_info->extent_root, 0);
mutex_unlock(&root->fs_info->fs_mutex);
- btrfs_free_path(path);
- if (di && !IS_ERR(di))
- return -EEXIST;
- if (IS_ERR(di))
- return PTR_ERR(di);
-
- if (root == root->fs_info->tree_root)
- ret = create_subvol(root, vol_args.name, namelen);
- else
- ret = create_snapshot(root, vol_args.name, namelen);
break;
- default:
- return -ENOTTY;
+ case S_IFREG:
+ btrfs_defrag_file(file);
+ break;
}
- return ret;
+
+ return 0;
}
-#ifdef CONFIG_COMPAT
-long btrfs_compat_ioctl(struct file *file, unsigned int cmd,
- unsigned long arg)
+long btrfs_ioctl(struct file *file, unsigned int
+ cmd, unsigned long arg)
{
- struct inode *inode = file->f_path.dentry->d_inode;
- int ret;
- lock_kernel();
- ret = btrfs_ioctl(inode, file, cmd, (unsigned long) compat_ptr(arg));
- unlock_kernel();
- return ret;
+ struct btrfs_root *root = BTRFS_I(file->f_path.dentry->d_inode)->root;
+ switch (cmd) {
+ case BTRFS_IOC_SNAP_CREATE:
+ return btrfs_ioctl_snap_create(root, (void __user *)arg);
+ case BTRFS_IOC_DEFRAG:
+ return btrfs_ioctl_defrag(file);
+ }
+
+ return -ENOTTY;
}
-#endif
/*
* Called inside transaction, so use GFP_NOFS
ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
if (!ei)
return NULL;
+ ei->last_trans = 0;
return &ei->vfs_inode;
}
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;
kmem_cache_destroy(btrfs_path_cachep);
}
-static struct kmem_cache *cache_create(const char *name, size_t size,
+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
int btrfs_init_cachep(void)
{
- btrfs_inode_cachep = cache_create("btrfs_inode_cache",
+ btrfs_inode_cachep = btrfs_cache_create("btrfs_inode_cache",
sizeof(struct btrfs_inode),
0, init_once);
if (!btrfs_inode_cachep)
goto fail;
- btrfs_trans_handle_cachep = cache_create("btrfs_trans_handle_cache",
- sizeof(struct btrfs_trans_handle),
- 0, NULL);
+ btrfs_trans_handle_cachep =
+ btrfs_cache_create("btrfs_trans_handle_cache",
+ sizeof(struct btrfs_trans_handle),
+ 0, NULL);
if (!btrfs_trans_handle_cachep)
goto fail;
- btrfs_transaction_cachep = cache_create("btrfs_transaction_cache",
+ btrfs_transaction_cachep = btrfs_cache_create("btrfs_transaction_cache",
sizeof(struct btrfs_transaction),
0, NULL);
if (!btrfs_transaction_cachep)
goto fail;
- btrfs_path_cachep = cache_create("btrfs_path_cache",
- sizeof(struct btrfs_transaction),
+ btrfs_path_cachep = btrfs_cache_create("btrfs_path_cache",
+ sizeof(struct btrfs_path),
0, NULL);
if (!btrfs_path_cachep)
goto fail;
- btrfs_bit_radix_cachep = cache_create("btrfs_radix", 256,
+ btrfs_bit_radix_cachep = btrfs_cache_create("btrfs_radix", 256,
SLAB_DESTROY_BY_RCU, NULL);
if (!btrfs_bit_radix_cachep)
goto fail;
new_inode->i_size > BTRFS_EMPTY_DIR_SIZE) {
return -ENOTEMPTY;
}
+
mutex_lock(&root->fs_info->fs_mutex);
trans = btrfs_start_transaction(root, 1);
+
btrfs_set_trans_block_group(trans, new_dir);
path = btrfs_alloc_path();
if (!path) {
old_dir->i_ctime = old_dir->i_mtime = ctime;
new_dir->i_ctime = new_dir->i_mtime = ctime;
old_inode->i_ctime = ctime;
+
if (S_ISDIR(old_inode->i_mode) && old_dir != new_dir) {
struct btrfs_key *location = &BTRFS_I(new_dir)->location;
- u64 old_parent_oid;
+ struct btrfs_key old_parent_key;
di = btrfs_lookup_dir_item(trans, root, path, old_inode->i_ino,
"..", 2, -1);
if (IS_ERR(di)) {
ret = -ENOENT;
goto out_fail;
}
- old_parent_oid = btrfs_disk_key_objectid(&di->location);
+ btrfs_dir_item_key_to_cpu(path->nodes[0], di, &old_parent_key);
ret = btrfs_del_item(trans, root, path);
if (ret) {
goto out_fail;
di = btrfs_lookup_dir_index_item(trans, root, path,
old_inode->i_ino,
- old_parent_oid,
+ old_parent_key.objectid,
"..", 2, -1);
if (IS_ERR(di)) {
ret = PTR_ERR(di);
ret = btrfs_unlink_trans(trans, root, new_dir, new_dentry);
if (ret)
goto out_fail;
- if (S_ISDIR(new_inode->i_mode))
- clear_nlink(new_inode);
- else
- drop_nlink(new_inode);
- ret = btrfs_update_inode(trans, root, new_inode);
- if (ret)
- goto out_fail;
}
ret = btrfs_add_link(trans, new_dentry, old_inode);
if (ret)
u64 objectid;
int name_len;
int datasize;
- char *ptr;
+ unsigned long ptr;
struct btrfs_file_extent_item *ei;
+ struct extent_buffer *leaf;
+ unsigned long nr;
name_len = strlen(symname) + 1;
if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
inode->i_mapping->a_ops = &btrfs_aops;
inode->i_fop = &btrfs_file_operations;
inode->i_op = &btrfs_file_inode_operations;
+ extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
+ inode->i_mapping, GFP_NOFS);
+ BTRFS_I(inode)->extent_tree.ops = &btrfs_extent_map_ops;
}
dir->i_sb->s_dirt = 1;
btrfs_update_inode_block_group(trans, inode);
BUG_ON(!path);
key.objectid = inode->i_ino;
key.offset = 0;
- key.flags = 0;
btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
datasize = btrfs_file_extent_calc_inline_size(name_len);
err = btrfs_insert_empty_item(trans, root, path, &key,
drop_inode = 1;
goto out_unlock;
}
- ei = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
- path->slots[0], struct btrfs_file_extent_item);
- btrfs_set_file_extent_generation(ei, trans->transid);
- btrfs_set_file_extent_type(ei,
+ leaf = path->nodes[0];
+ ei = btrfs_item_ptr(leaf, path->slots[0],
+ struct btrfs_file_extent_item);
+ btrfs_set_file_extent_generation(leaf, ei, trans->transid);
+ btrfs_set_file_extent_type(leaf, ei,
BTRFS_FILE_EXTENT_INLINE);
ptr = btrfs_file_extent_inline_start(ei);
- btrfs_memcpy(root, path->nodes[0]->b_data,
- ptr, symname, name_len);
- btrfs_mark_buffer_dirty(path->nodes[0]);
+ write_extent_buffer(leaf, symname, ptr, name_len);
+ btrfs_mark_buffer_dirty(leaf);
btrfs_free_path(path);
+
inode->i_op = &btrfs_symlink_inode_operations;
inode->i_mapping->a_ops = &btrfs_symlink_aops;
inode->i_size = name_len - 1;
drop_inode = 1;
out_unlock:
+ nr = trans->blocks_used;
btrfs_end_transaction(trans, root);
mutex_unlock(&root->fs_info->fs_mutex);
if (drop_inode) {
inode_dec_link_count(inode);
iput(inode);
}
- btrfs_btree_balance_dirty(root);
+ btrfs_btree_balance_dirty(root, nr);
return err;
}
.llseek = generic_file_llseek,
.read = generic_read_dir,
.readdir = btrfs_readdir,
- .ioctl = btrfs_ioctl,
+ .unlocked_ioctl = btrfs_ioctl,
#ifdef CONFIG_COMPAT
- .compat_ioctl = btrfs_compat_ioctl,
+ .compat_ioctl = btrfs_ioctl,
#endif
};
+static struct extent_map_ops btrfs_extent_map_ops = {
+ .fill_delalloc = run_delalloc_range,
+ .writepage_io_hook = btrfs_writepage_io_hook,
+ .readpage_io_hook = btrfs_readpage_io_hook,
+ .readpage_end_io_hook = btrfs_readpage_end_io_hook,
+};
+
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,
.bmap = btrfs_bmap,
+ .invalidatepage = btrfs_invalidatepage,
+ .releasepage = btrfs_releasepage,
+ .set_page_dirty = __set_page_dirty_nobuffers,
};
static struct address_space_operations btrfs_symlink_aops = {
.readpage = btrfs_readpage,
.writepage = btrfs_writepage,
+ .invalidatepage = btrfs_invalidatepage,
+ .releasepage = btrfs_releasepage,
};
static struct inode_operations btrfs_file_inode_operations = {