#include "disk-io.h"
#include "transaction.h"
#include "btrfs_inode.h"
+#include "ordered-data.h"
#include "ioctl.h"
#include "print-tree.h"
}
}
-static int insert_inline_extent(struct btrfs_trans_handle *trans,
+static int noinline insert_inline_extent(struct btrfs_trans_handle *trans,
struct btrfs_root *root, struct inode *inode,
u64 offset, size_t size,
struct page **pages, size_t page_offset,
leaf = path->nodes[0];
ei = btrfs_item_ptr(leaf, path->slots[0],
struct btrfs_file_extent_item);
+ inode->i_blocks += (offset + size - found_end) >> 9;
}
if (found_end < offset) {
ptr = btrfs_file_extent_inline_start(ei) + found_size;
insert:
btrfs_release_path(root, path);
datasize = offset + size - key.offset;
+ inode->i_blocks += datasize >> 9;
datasize = btrfs_file_extent_calc_inline_size(datasize);
ret = btrfs_insert_empty_item(trans, root, path, &key,
datasize);
return err;
}
-static int dirty_and_release_pages(struct btrfs_trans_handle *trans,
+static int noinline dirty_and_release_pages(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct file *file,
struct page **pages,
{
int err = 0;
int i;
- struct inode *inode = file->f_path.dentry->d_inode;
- struct extent_map *em;
- struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+ struct inode *inode = fdentry(file)->d_inode;
+ struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
u64 hint_byte;
u64 num_bytes;
u64 start_pos;
u64 end_pos = pos + write_bytes;
u64 inline_size;
loff_t isize = i_size_read(inode);
- em = alloc_extent_map(GFP_NOFS);
- if (!em)
- return -ENOMEM;
-
- em->bdev = inode->i_sb->s_bdev;
start_pos = pos & ~((u64)root->sectorsize - 1);
num_bytes = (write_bytes + pos - start_pos +
root->sectorsize - 1) & ~((u64)root->sectorsize - 1);
- down_read(&BTRFS_I(inode)->root->snap_sem);
end_of_last_block = start_pos + num_bytes - 1;
- lock_extent(em_tree, start_pos, end_of_last_block, GFP_NOFS);
+ lock_extent(io_tree, start_pos, end_of_last_block, GFP_NOFS);
mutex_lock(&root->fs_info->fs_mutex);
trans = btrfs_start_transaction(root, 1);
if (!trans) {
goto out_unlock;
}
btrfs_set_trans_block_group(trans, inode);
- inode->i_blocks += num_bytes >> 9;
hint_byte = 0;
if ((end_of_last_block & 4095) == 0) {
printk("strange end of last %Lu %zu %Lu\n", start_pos, write_bytes, end_of_last_block);
}
- set_extent_uptodate(em_tree, start_pos, end_of_last_block, GFP_NOFS);
+ set_extent_uptodate(io_tree, start_pos, end_of_last_block, GFP_NOFS);
/* FIXME...EIEIO, ENOSPC and more */
-
/* insert any holes we need to create */
- if (inode->i_size < start_pos) {
+ if (isize < end_pos) {
u64 last_pos_in_file;
u64 hole_size;
u64 mask = root->sectorsize - 1;
last_pos_in_file = (isize + mask) & ~mask;
- hole_size = (start_pos - last_pos_in_file + mask) & ~mask;
-
- if (last_pos_in_file < start_pos) {
+ hole_size = (end_pos - last_pos_in_file + mask) & ~mask;
+ if (last_pos_in_file < end_pos) {
err = btrfs_drop_extents(trans, root, inode,
last_pos_in_file,
last_pos_in_file + hole_size,
inode->i_ino,
last_pos_in_file,
0, 0, hole_size);
+ btrfs_drop_extent_cache(inode, last_pos_in_file,
+ last_pos_in_file + hole_size -1);
+ btrfs_check_file(root, inode);
}
if (err)
goto failed;
*/
inline_size = end_pos;
if (isize >= BTRFS_MAX_INLINE_DATA_SIZE(root) ||
- inline_size > 32768 ||
+ inline_size > root->fs_info->max_inline ||
+ (inline_size & (root->sectorsize -1)) == 0 ||
inline_size >= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
u64 last_end;
+ u64 existing_delalloc = 0;
for (i = 0; i < num_pages; i++) {
struct page *p = pages[i];
last_end = (u64)(pages[num_pages -1]->index) <<
PAGE_CACHE_SHIFT;
last_end += PAGE_CACHE_SIZE - 1;
- set_extent_delalloc(em_tree, start_pos, end_of_last_block,
+ if (start_pos < isize) {
+ u64 delalloc_start = start_pos;
+ existing_delalloc = count_range_bits(io_tree,
+ &delalloc_start,
+ end_of_last_block, (u64)-1,
+ EXTENT_DELALLOC);
+ }
+ set_extent_delalloc(io_tree, start_pos, end_of_last_block,
GFP_NOFS);
+ btrfs_add_ordered_inode(inode);
} else {
u64 aligned_end;
/* step one, delete the existing extents in this range */
inline_size -= start_pos;
err = insert_inline_extent(trans, root, inode, start_pos,
inline_size, pages, 0, num_pages);
+ btrfs_drop_extent_cache(inode, start_pos, aligned_end - 1);
BUG_ON(err);
}
if (end_pos > isize) {
err = btrfs_end_transaction(trans, root);
out_unlock:
mutex_unlock(&root->fs_info->fs_mutex);
- unlock_extent(em_tree, start_pos, end_of_last_block, GFP_NOFS);
- free_extent_map(em);
- up_read(&BTRFS_I(inode)->root->snap_sem);
+ unlock_extent(io_tree, start_pos, end_of_last_block, GFP_NOFS);
return err;
}
{
struct extent_map *em;
struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+ u64 len = end - start + 1;
+ if (end == (u64)-1)
+ len = (u64)-1;
while(1) {
- em = lookup_extent_mapping(em_tree, start, end);
- if (!em)
+ spin_lock(&em_tree->lock);
+ em = lookup_extent_mapping(em_tree, start, len);
+ if (!em) {
+ spin_unlock(&em_tree->lock);
break;
+ }
remove_extent_mapping(em_tree, em);
+ spin_unlock(&em_tree->lock);
+
/* once for us */
free_extent_map(em);
/* once for the tree*/
return 0;
}
+int btrfs_check_file(struct btrfs_root *root, struct inode *inode)
+{
+ return 0;
+#if 0
+ struct btrfs_path *path;
+ struct btrfs_key found_key;
+ struct extent_buffer *leaf;
+ struct btrfs_file_extent_item *extent;
+ u64 last_offset = 0;
+ int nritems;
+ int slot;
+ int found_type;
+ int ret;
+ int err = 0;
+ u64 extent_end = 0;
+
+ path = btrfs_alloc_path();
+ ret = btrfs_lookup_file_extent(NULL, root, path, inode->i_ino,
+ last_offset, 0);
+ while(1) {
+ nritems = btrfs_header_nritems(path->nodes[0]);
+ if (path->slots[0] >= nritems) {
+ ret = btrfs_next_leaf(root, path);
+ if (ret)
+ goto out;
+ nritems = btrfs_header_nritems(path->nodes[0]);
+ }
+ slot = path->slots[0];
+ leaf = path->nodes[0];
+ btrfs_item_key_to_cpu(leaf, &found_key, slot);
+ if (found_key.objectid != inode->i_ino)
+ break;
+ if (found_key.type != BTRFS_EXTENT_DATA_KEY)
+ goto out;
+
+ if (found_key.offset < last_offset) {
+ WARN_ON(1);
+ btrfs_print_leaf(root, leaf);
+ printk("inode %lu found offset %Lu expected %Lu\n",
+ inode->i_ino, found_key.offset, last_offset);
+ err = 1;
+ goto out;
+ }
+ extent = btrfs_item_ptr(leaf, slot,
+ struct btrfs_file_extent_item);
+ found_type = btrfs_file_extent_type(leaf, extent);
+ if (found_type == BTRFS_FILE_EXTENT_REG) {
+ extent_end = found_key.offset +
+ btrfs_file_extent_num_bytes(leaf, extent);
+ } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
+ struct btrfs_item *item;
+ item = btrfs_item_nr(leaf, slot);
+ extent_end = found_key.offset +
+ btrfs_file_extent_inline_len(leaf, item);
+ extent_end = (extent_end + root->sectorsize - 1) &
+ ~((u64)root->sectorsize -1 );
+ }
+ last_offset = extent_end;
+ path->slots[0]++;
+ }
+ if (0 && last_offset < inode->i_size) {
+ WARN_ON(1);
+ btrfs_print_leaf(root, leaf);
+ printk("inode %lu found offset %Lu size %Lu\n", inode->i_ino,
+ last_offset, inode->i_size);
+ err = 1;
+
+ }
+out:
+ btrfs_free_path(path);
+ return err;
+#endif
+}
+
/*
* this is very complex, but the basic idea is to drop all extents
* in the range start - end. hint_block is filled in with a block number
slot = path->slots[0];
ret = 0;
btrfs_item_key_to_cpu(leaf, &key, slot);
- if (key.offset >= end || key.objectid != inode->i_ino) {
+ if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY &&
+ key.offset >= end) {
goto out;
}
- if (btrfs_key_type(&key) > BTRFS_EXTENT_DATA_KEY) {
+ if (btrfs_key_type(&key) > BTRFS_EXTENT_DATA_KEY ||
+ key.objectid != inode->i_ino) {
goto out;
}
if (recow) {
search_start = (extent_end + mask) & ~mask;
} else
search_start = extent_end;
- if (end < extent_end && start > key.offset && found_inline) {
+ if (end <= extent_end && start >= key.offset && found_inline) {
*hint_byte = EXTENT_MAP_INLINE;
+ continue;
}
if (end < extent_end && end >= key.offset) {
if (found_extent) {
}
}
bookend = 1;
- if (found_inline && start <= key.offset &&
- inline_limit < extent_end)
+ if (found_inline && start <= key.offset)
keep = 1;
}
/* truncate existing extent */
extent);
if (btrfs_file_extent_disk_bytenr(leaf,
extent)) {
- inode->i_blocks -=
- (old_num - new_num) >> 9;
+ dec_i_blocks(inode, old_num - new_num);
}
btrfs_set_file_extent_num_bytes(leaf, extent,
new_num);
u32 new_size;
new_size = btrfs_file_extent_calc_inline_size(
inline_limit - key.offset);
+ dec_i_blocks(inode, (extent_end - key.offset) -
+ (inline_limit - key.offset));
btrfs_truncate_item(trans, root, path,
new_size, 1);
}
u64 disk_num_bytes = 0;
u64 extent_num_bytes = 0;
u64 root_gen;
+ u64 root_owner;
- if (leaf != root->node) {
- root_gen =
- btrfs_header_generation(path->nodes[1]);
- } else {
- root_gen = btrfs_header_generation(leaf);
- }
+ root_gen = btrfs_header_generation(leaf);
+ root_owner = btrfs_header_owner(leaf);
if (found_extent) {
disk_bytenr =
btrfs_file_extent_disk_bytenr(leaf,
btrfs_release_path(root, path);
extent = NULL;
if (found_extent && disk_bytenr != 0) {
- inode->i_blocks -= extent_num_bytes >> 9;
+ dec_i_blocks(inode, extent_num_bytes);
ret = btrfs_free_extent(trans, root,
disk_bytenr,
disk_num_bytes,
- root->root_key.objectid,
+ root_owner,
root_gen, inode->i_ino,
key.offset, 0);
}
if (!bookend)
continue;
}
- if (bookend && found_inline && start <= key.offset &&
- inline_limit < extent_end && key.offset <= inline_limit) {
+ if (bookend && found_inline && start <= key.offset) {
u32 new_size;
new_size = btrfs_file_extent_calc_inline_size(
- extent_end - inline_limit);
+ extent_end - end);
+ dec_i_blocks(inode, (extent_end - key.offset) -
+ (extent_end - end));
btrfs_truncate_item(trans, root, path, new_size, 0);
}
/* create bookend, splitting the extent in two */
}
out:
btrfs_free_path(path);
+ btrfs_check_file(root, inode);
return ret;
}
/*
* this gets pages into the page cache and locks them down
*/
-static int prepare_pages(struct btrfs_root *root,
- struct file *file,
- struct page **pages,
- size_t num_pages,
- loff_t pos,
- unsigned long first_index,
- unsigned long last_index,
- size_t write_bytes)
+static int prepare_pages(struct btrfs_root *root, struct file *file,
+ struct page **pages, size_t num_pages,
+ loff_t pos, unsigned long first_index,
+ unsigned long last_index, size_t write_bytes)
{
int i;
unsigned long index = pos >> PAGE_CACHE_SHIFT;
- struct inode *inode = file->f_path.dentry->d_inode;
+ struct inode *inode = fdentry(file)->d_inode;
int err = 0;
u64 start_pos;
err = -ENOMEM;
BUG_ON(1);
}
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
+ ClearPageDirty(pages[i]);
+#else
cancel_dirty_page(pages[i], PAGE_CACHE_SIZE);
+#endif
wait_on_page_writeback(pages[i]);
set_page_extent_mapped(pages[i]);
WARN_ON(!PageLocked(pages[i]));
}
+ if (start_pos < inode->i_size) {
+ u64 last_pos;
+ last_pos = (index + num_pages) << PAGE_CACHE_SHIFT;
+ clear_extent_bits(&BTRFS_I(inode)->io_tree, start_pos,
+ last_pos - 1, EXTENT_DIRTY | EXTENT_DELALLOC,
+ GFP_NOFS);
+ }
return 0;
}
ssize_t num_written = 0;
ssize_t err = 0;
int ret = 0;
- struct inode *inode = file->f_path.dentry->d_inode;
+ struct inode *inode = fdentry(file)->d_inode;
struct btrfs_root *root = BTRFS_I(inode)->root;
struct page **pages = NULL;
int nrptrs;
current->backing_dev_info = inode->i_mapping->backing_dev_info;
err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
if (err)
- goto out;
+ goto out_nolock;
if (count == 0)
- goto out;
- err = remove_suid(file->f_path.dentry);
+ goto out_nolock;
+ err = remove_suid(fdentry(file));
if (err)
- goto out;
+ goto out_nolock;
file_update_time(file);
pages = kmalloc(nrptrs * sizeof(struct page *), GFP_KERNEL);
WARN_ON(num_pages > nrptrs);
memset(pages, 0, sizeof(pages));
+
+ mutex_lock(&root->fs_info->fs_mutex);
+ ret = btrfs_check_free_space(root, write_bytes, 0);
+ mutex_unlock(&root->fs_info->fs_mutex);
+ if (ret)
+ goto out;
+
ret = prepare_pages(root, file, pages, num_pages,
pos, first_index, last_index,
write_bytes);
balance_dirty_pages_ratelimited_nr(inode->i_mapping, num_pages);
if (num_pages < (root->leafsize >> PAGE_CACHE_SHIFT) + 1)
btrfs_btree_balance_dirty(root, 1);
+ btrfs_throttle(root);
cond_resched();
}
- mutex_unlock(&inode->i_mutex);
out:
+ mutex_unlock(&inode->i_mutex);
+
+out_nolock:
kfree(pages);
if (pinned[0])
page_cache_release(pinned[0]);
.llseek = generic_file_llseek,
.read = do_sync_read,
.aio_read = generic_file_aio_read,
+ .splice_read = generic_file_splice_read,
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
+ .sendfile = generic_file_sendfile,
+#endif
.write = btrfs_file_write,
.mmap = btrfs_file_mmap,
.open = generic_file_open,