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);
int err = 0;
int i;
struct inode *inode = fdentry(file)->d_inode;
- struct extent_map *em;
- struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+ 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 +
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 > 8192 ||
+ 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;
last_end += PAGE_CACHE_SIZE - 1;
if (start_pos < isize) {
u64 delalloc_start = start_pos;
- existing_delalloc = count_range_bits(em_tree,
+ existing_delalloc = count_range_bits(io_tree,
&delalloc_start,
end_of_last_block, (u64)-1,
EXTENT_DELALLOC);
}
- set_extent_delalloc(em_tree, start_pos, end_of_last_block,
+ set_extent_delalloc(io_tree, start_pos, end_of_last_block,
GFP_NOFS);
- spin_lock(&root->fs_info->delalloc_lock);
- root->fs_info->delalloc_bytes += (end_of_last_block + 1 -
- start_pos) - existing_delalloc;
- spin_unlock(&root->fs_info->delalloc_lock);
btrfs_add_ordered_inode(inode);
} else {
u64 aligned_end;
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);
+ 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) {
}
}
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);
}
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,
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;
}
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;
}