inode.c (5f56406aabdf5444d040c5955effc665b1d0dbaf) inode.c (d1310b2e0cd98eb1348553e69b73827b436dca7b)
1/*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,

--- 39 unchanged lines hidden (view full) ---

48static struct inode_operations btrfs_dir_inode_operations;
49static struct inode_operations btrfs_symlink_inode_operations;
50static struct inode_operations btrfs_dir_ro_inode_operations;
51static struct inode_operations btrfs_special_inode_operations;
52static struct inode_operations btrfs_file_inode_operations;
53static struct address_space_operations btrfs_aops;
54static struct address_space_operations btrfs_symlink_aops;
55static struct file_operations btrfs_dir_file_operations;
1/*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,

--- 39 unchanged lines hidden (view full) ---

48static struct inode_operations btrfs_dir_inode_operations;
49static struct inode_operations btrfs_symlink_inode_operations;
50static struct inode_operations btrfs_dir_ro_inode_operations;
51static struct inode_operations btrfs_special_inode_operations;
52static struct inode_operations btrfs_file_inode_operations;
53static struct address_space_operations btrfs_aops;
54static struct address_space_operations btrfs_symlink_aops;
55static struct file_operations btrfs_dir_file_operations;
56static struct extent_map_ops btrfs_extent_map_ops;
56static struct extent_io_ops btrfs_extent_io_ops;
57
58static struct kmem_cache *btrfs_inode_cachep;
59struct kmem_cache *btrfs_trans_handle_cachep;
60struct kmem_cache *btrfs_transaction_cachep;
61struct kmem_cache *btrfs_bit_radix_cachep;
62struct kmem_cache *btrfs_path_cachep;
63
64#define S_SHIFT 12

--- 34 unchanged lines hidden (view full) ---

99static int cow_file_range(struct inode *inode, u64 start, u64 end)
100{
101 struct btrfs_root *root = BTRFS_I(inode)->root;
102 struct btrfs_trans_handle *trans;
103 u64 alloc_hint = 0;
104 u64 num_bytes;
105 u64 cur_alloc_size;
106 u64 blocksize = root->sectorsize;
57
58static struct kmem_cache *btrfs_inode_cachep;
59struct kmem_cache *btrfs_trans_handle_cachep;
60struct kmem_cache *btrfs_transaction_cachep;
61struct kmem_cache *btrfs_bit_radix_cachep;
62struct kmem_cache *btrfs_path_cachep;
63
64#define S_SHIFT 12

--- 34 unchanged lines hidden (view full) ---

99static int cow_file_range(struct inode *inode, u64 start, u64 end)
100{
101 struct btrfs_root *root = BTRFS_I(inode)->root;
102 struct btrfs_trans_handle *trans;
103 u64 alloc_hint = 0;
104 u64 num_bytes;
105 u64 cur_alloc_size;
106 u64 blocksize = root->sectorsize;
107 u64 orig_start = start;
108 u64 orig_num_bytes;
107 struct btrfs_key ins;
108 int ret;
109
110 trans = btrfs_start_transaction(root, 1);
111 BUG_ON(!trans);
112 btrfs_set_trans_block_group(trans, inode);
113
114 num_bytes = (end - start + blocksize) & ~(blocksize - 1);
115 num_bytes = max(blocksize, num_bytes);
116 ret = btrfs_drop_extents(trans, root, inode,
117 start, start + num_bytes, start, &alloc_hint);
109 struct btrfs_key ins;
110 int ret;
111
112 trans = btrfs_start_transaction(root, 1);
113 BUG_ON(!trans);
114 btrfs_set_trans_block_group(trans, inode);
115
116 num_bytes = (end - start + blocksize) & ~(blocksize - 1);
117 num_bytes = max(blocksize, num_bytes);
118 ret = btrfs_drop_extents(trans, root, inode,
119 start, start + num_bytes, start, &alloc_hint);
120 orig_num_bytes = num_bytes;
118
119 if (alloc_hint == EXTENT_MAP_INLINE)
120 goto out;
121
122 while(num_bytes > 0) {
123 cur_alloc_size = min(num_bytes, root->fs_info->max_extent);
124 ret = btrfs_alloc_extent(trans, root, cur_alloc_size,
125 root->root_key.objectid,

--- 7 unchanged lines hidden (view full) ---

133 ret = btrfs_insert_file_extent(trans, root, inode->i_ino,
134 start, ins.objectid, ins.offset,
135 ins.offset);
136 btrfs_check_file(root, inode);
137 num_bytes -= cur_alloc_size;
138 alloc_hint = ins.objectid + ins.offset;
139 start += cur_alloc_size;
140 }
121
122 if (alloc_hint == EXTENT_MAP_INLINE)
123 goto out;
124
125 while(num_bytes > 0) {
126 cur_alloc_size = min(num_bytes, root->fs_info->max_extent);
127 ret = btrfs_alloc_extent(trans, root, cur_alloc_size,
128 root->root_key.objectid,

--- 7 unchanged lines hidden (view full) ---

136 ret = btrfs_insert_file_extent(trans, root, inode->i_ino,
137 start, ins.objectid, ins.offset,
138 ins.offset);
139 btrfs_check_file(root, inode);
140 num_bytes -= cur_alloc_size;
141 alloc_hint = ins.objectid + ins.offset;
142 start += cur_alloc_size;
143 }
144 btrfs_drop_extent_cache(inode, orig_start,
145 orig_start + orig_num_bytes - 1);
141 btrfs_add_ordered_inode(inode);
142out:
143 btrfs_end_transaction(trans, root);
144 return ret;
145}
146
147static int run_delalloc_nocow(struct inode *inode, u64 start, u64 end)
148{

--- 143 unchanged lines hidden (view full) ---

292 return ret;
293}
294
295int btrfs_readpage_io_hook(struct page *page, u64 start, u64 end)
296{
297 int ret = 0;
298 struct inode *inode = page->mapping->host;
299 struct btrfs_root *root = BTRFS_I(inode)->root;
146 btrfs_add_ordered_inode(inode);
147out:
148 btrfs_end_transaction(trans, root);
149 return ret;
150}
151
152static int run_delalloc_nocow(struct inode *inode, u64 start, u64 end)
153{

--- 143 unchanged lines hidden (view full) ---

297 return ret;
298}
299
300int btrfs_readpage_io_hook(struct page *page, u64 start, u64 end)
301{
302 int ret = 0;
303 struct inode *inode = page->mapping->host;
304 struct btrfs_root *root = BTRFS_I(inode)->root;
300 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
305 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
301 struct btrfs_csum_item *item;
302 struct btrfs_path *path = NULL;
303 u32 csum;
304 if (btrfs_test_opt(root, NODATASUM) ||
305 btrfs_test_flag(inode, NODATASUM))
306 return 0;
307 mutex_lock(&root->fs_info->fs_mutex);
308 path = btrfs_alloc_path();
309 item = btrfs_lookup_csum(NULL, root, path, inode->i_ino, start, 0);
310 if (IS_ERR(item)) {
311 ret = PTR_ERR(item);
312 /* a csum that isn't present is a preallocated region. */
313 if (ret == -ENOENT || ret == -EFBIG)
314 ret = 0;
315 csum = 0;
316 goto out;
317 }
318 read_extent_buffer(path->nodes[0], &csum, (unsigned long)item,
319 BTRFS_CRC32_SIZE);
306 struct btrfs_csum_item *item;
307 struct btrfs_path *path = NULL;
308 u32 csum;
309 if (btrfs_test_opt(root, NODATASUM) ||
310 btrfs_test_flag(inode, NODATASUM))
311 return 0;
312 mutex_lock(&root->fs_info->fs_mutex);
313 path = btrfs_alloc_path();
314 item = btrfs_lookup_csum(NULL, root, path, inode->i_ino, start, 0);
315 if (IS_ERR(item)) {
316 ret = PTR_ERR(item);
317 /* a csum that isn't present is a preallocated region. */
318 if (ret == -ENOENT || ret == -EFBIG)
319 ret = 0;
320 csum = 0;
321 goto out;
322 }
323 read_extent_buffer(path->nodes[0], &csum, (unsigned long)item,
324 BTRFS_CRC32_SIZE);
320 set_state_private(em_tree, start, csum);
325 set_state_private(io_tree, start, csum);
321out:
322 if (path)
323 btrfs_free_path(path);
324 mutex_unlock(&root->fs_info->fs_mutex);
325 return ret;
326}
327
328int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end)
329{
330 size_t offset = start - ((u64)page->index << PAGE_CACHE_SHIFT);
331 struct inode *inode = page->mapping->host;
326out:
327 if (path)
328 btrfs_free_path(path);
329 mutex_unlock(&root->fs_info->fs_mutex);
330 return ret;
331}
332
333int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end)
334{
335 size_t offset = start - ((u64)page->index << PAGE_CACHE_SHIFT);
336 struct inode *inode = page->mapping->host;
332 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
337 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
333 char *kaddr;
334 u64 private;
335 int ret;
336 struct btrfs_root *root = BTRFS_I(inode)->root;
337 u32 csum = ~(u32)0;
338 unsigned long flags;
338 char *kaddr;
339 u64 private;
340 int ret;
341 struct btrfs_root *root = BTRFS_I(inode)->root;
342 u32 csum = ~(u32)0;
343 unsigned long flags;
344
339 if (btrfs_test_opt(root, NODATASUM) ||
340 btrfs_test_flag(inode, NODATASUM))
341 return 0;
345 if (btrfs_test_opt(root, NODATASUM) ||
346 btrfs_test_flag(inode, NODATASUM))
347 return 0;
342 ret = get_state_private(em_tree, start, &private);
348
349 ret = get_state_private(io_tree, start, &private);
343 local_irq_save(flags);
344 kaddr = kmap_atomic(page, KM_IRQ0);
345 if (ret) {
346 goto zeroit;
347 }
348 csum = btrfs_csum_data(root, kaddr + offset, csum, end - start + 1);
349 btrfs_csum_final(csum, (char *)&csum);
350 if (csum != private) {

--- 72 unchanged lines hidden (view full) ---

423 btrfs_free_path(path);
424 inode_item = NULL;
425
426 mutex_unlock(&root->fs_info->fs_mutex);
427
428 switch (inode->i_mode & S_IFMT) {
429 case S_IFREG:
430 inode->i_mapping->a_ops = &btrfs_aops;
350 local_irq_save(flags);
351 kaddr = kmap_atomic(page, KM_IRQ0);
352 if (ret) {
353 goto zeroit;
354 }
355 csum = btrfs_csum_data(root, kaddr + offset, csum, end - start + 1);
356 btrfs_csum_final(csum, (char *)&csum);
357 if (csum != private) {

--- 72 unchanged lines hidden (view full) ---

430 btrfs_free_path(path);
431 inode_item = NULL;
432
433 mutex_unlock(&root->fs_info->fs_mutex);
434
435 switch (inode->i_mode & S_IFMT) {
436 case S_IFREG:
437 inode->i_mapping->a_ops = &btrfs_aops;
431 BTRFS_I(inode)->extent_tree.ops = &btrfs_extent_map_ops;
438 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
432 inode->i_fop = &btrfs_file_operations;
433 inode->i_op = &btrfs_file_inode_operations;
434 break;
435 case S_IFDIR:
436 inode->i_fop = &btrfs_dir_file_operations;
437 if (root == root->fs_info->tree_root)
438 inode->i_op = &btrfs_dir_ro_inode_operations;
439 else

--- 428 unchanged lines hidden (view full) ---

868 inode->i_sb->s_dirt = 1;
869 return ret;
870}
871
872static int btrfs_cow_one_page(struct inode *inode, struct page *page,
873 size_t zero_start)
874{
875 char *kaddr;
439 inode->i_fop = &btrfs_file_operations;
440 inode->i_op = &btrfs_file_inode_operations;
441 break;
442 case S_IFDIR:
443 inode->i_fop = &btrfs_dir_file_operations;
444 if (root == root->fs_info->tree_root)
445 inode->i_op = &btrfs_dir_ro_inode_operations;
446 else

--- 428 unchanged lines hidden (view full) ---

875 inode->i_sb->s_dirt = 1;
876 return ret;
877}
878
879static int btrfs_cow_one_page(struct inode *inode, struct page *page,
880 size_t zero_start)
881{
882 char *kaddr;
876 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
883 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
877 struct btrfs_root *root = BTRFS_I(inode)->root;
878 u64 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
879 u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
880 u64 existing_delalloc;
881 u64 delalloc_start;
882 int ret = 0;
883
884 WARN_ON(!PageLocked(page));
885 set_page_extent_mapped(page);
886
884 struct btrfs_root *root = BTRFS_I(inode)->root;
885 u64 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
886 u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
887 u64 existing_delalloc;
888 u64 delalloc_start;
889 int ret = 0;
890
891 WARN_ON(!PageLocked(page));
892 set_page_extent_mapped(page);
893
887 lock_extent(em_tree, page_start, page_end, GFP_NOFS);
894 lock_extent(io_tree, page_start, page_end, GFP_NOFS);
888 delalloc_start = page_start;
895 delalloc_start = page_start;
889 existing_delalloc = count_range_bits(&BTRFS_I(inode)->extent_tree,
896 existing_delalloc = count_range_bits(&BTRFS_I(inode)->io_tree,
890 &delalloc_start, page_end,
891 PAGE_CACHE_SIZE, EXTENT_DELALLOC);
897 &delalloc_start, page_end,
898 PAGE_CACHE_SIZE, EXTENT_DELALLOC);
892 set_extent_delalloc(&BTRFS_I(inode)->extent_tree, page_start,
899 set_extent_delalloc(&BTRFS_I(inode)->io_tree, page_start,
893 page_end, GFP_NOFS);
894
895 spin_lock(&root->fs_info->delalloc_lock);
896 root->fs_info->delalloc_bytes += PAGE_CACHE_SIZE - existing_delalloc;
897 spin_unlock(&root->fs_info->delalloc_lock);
898
899 if (zero_start != PAGE_CACHE_SIZE) {
900 kaddr = kmap(page);
901 memset(kaddr + zero_start, 0, PAGE_CACHE_SIZE - zero_start);
902 flush_dcache_page(page);
903 kunmap(page);
904 }
905 set_page_dirty(page);
900 page_end, GFP_NOFS);
901
902 spin_lock(&root->fs_info->delalloc_lock);
903 root->fs_info->delalloc_bytes += PAGE_CACHE_SIZE - existing_delalloc;
904 spin_unlock(&root->fs_info->delalloc_lock);
905
906 if (zero_start != PAGE_CACHE_SIZE) {
907 kaddr = kmap(page);
908 memset(kaddr + zero_start, 0, PAGE_CACHE_SIZE - zero_start);
909 flush_dcache_page(page);
910 kunmap(page);
911 }
912 set_page_dirty(page);
906 unlock_extent(em_tree, page_start, page_end, GFP_NOFS);
913 unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
907
908 return ret;
909}
910
911/*
912 * taken from block_truncate_page, but does cow as it zeros out
913 * any bytes left in the last page in the file.
914 */

--- 41 unchanged lines hidden (view full) ---

956 err = inode_change_ok(inode, attr);
957 if (err)
958 return err;
959
960 if (S_ISREG(inode->i_mode) &&
961 attr->ia_valid & ATTR_SIZE && attr->ia_size > inode->i_size) {
962 struct btrfs_trans_handle *trans;
963 struct btrfs_root *root = BTRFS_I(inode)->root;
914
915 return ret;
916}
917
918/*
919 * taken from block_truncate_page, but does cow as it zeros out
920 * any bytes left in the last page in the file.
921 */

--- 41 unchanged lines hidden (view full) ---

963 err = inode_change_ok(inode, attr);
964 if (err)
965 return err;
966
967 if (S_ISREG(inode->i_mode) &&
968 attr->ia_valid & ATTR_SIZE && attr->ia_size > inode->i_size) {
969 struct btrfs_trans_handle *trans;
970 struct btrfs_root *root = BTRFS_I(inode)->root;
964 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
971 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
965
966 u64 mask = root->sectorsize - 1;
967 u64 pos = (inode->i_size + mask) & ~mask;
968 u64 block_end = attr->ia_size | mask;
969 u64 hole_start;
970 u64 hole_size;
971 u64 alloc_hint = 0;
972

--- 8 unchanged lines hidden (view full) ---

981 mutex_lock(&root->fs_info->fs_mutex);
982 err = btrfs_check_free_space(root, 1, 0);
983 mutex_unlock(&root->fs_info->fs_mutex);
984 if (err)
985 goto fail;
986
987 btrfs_truncate_page(inode->i_mapping, inode->i_size);
988
972
973 u64 mask = root->sectorsize - 1;
974 u64 pos = (inode->i_size + mask) & ~mask;
975 u64 block_end = attr->ia_size | mask;
976 u64 hole_start;
977 u64 hole_size;
978 u64 alloc_hint = 0;
979

--- 8 unchanged lines hidden (view full) ---

988 mutex_lock(&root->fs_info->fs_mutex);
989 err = btrfs_check_free_space(root, 1, 0);
990 mutex_unlock(&root->fs_info->fs_mutex);
991 if (err)
992 goto fail;
993
994 btrfs_truncate_page(inode->i_mapping, inode->i_size);
995
989 lock_extent(em_tree, pos, block_end, GFP_NOFS);
996 lock_extent(io_tree, pos, block_end, GFP_NOFS);
990 hole_size = block_end - hole_start;
991
992 mutex_lock(&root->fs_info->fs_mutex);
993 trans = btrfs_start_transaction(root, 1);
994 btrfs_set_trans_block_group(trans, inode);
995 err = btrfs_drop_extents(trans, root, inode,
996 pos, block_end, pos,
997 &alloc_hint);
998
999 if (alloc_hint != EXTENT_MAP_INLINE) {
1000 err = btrfs_insert_file_extent(trans, root,
1001 inode->i_ino,
1002 hole_start, 0, 0,
1003 hole_size);
997 hole_size = block_end - hole_start;
998
999 mutex_lock(&root->fs_info->fs_mutex);
1000 trans = btrfs_start_transaction(root, 1);
1001 btrfs_set_trans_block_group(trans, inode);
1002 err = btrfs_drop_extents(trans, root, inode,
1003 pos, block_end, pos,
1004 &alloc_hint);
1005
1006 if (alloc_hint != EXTENT_MAP_INLINE) {
1007 err = btrfs_insert_file_extent(trans, root,
1008 inode->i_ino,
1009 hole_start, 0, 0,
1010 hole_size);
1011 btrfs_drop_extent_cache(inode, hole_start,
1012 hole_size - 1);
1004 btrfs_check_file(root, inode);
1005 }
1006 btrfs_end_transaction(trans, root);
1007 mutex_unlock(&root->fs_info->fs_mutex);
1013 btrfs_check_file(root, inode);
1014 }
1015 btrfs_end_transaction(trans, root);
1016 mutex_unlock(&root->fs_info->fs_mutex);
1008 unlock_extent(em_tree, pos, block_end, GFP_NOFS);
1017 unlock_extent(io_tree, pos, block_end, GFP_NOFS);
1009 if (err)
1010 return err;
1011 }
1012out:
1013 err = inode_setattr(inode, attr);
1014fail:
1015 return err;
1016}

--- 167 unchanged lines hidden (view full) ---

1184 return 0;
1185}
1186
1187static int btrfs_init_locked_inode(struct inode *inode, void *p)
1188{
1189 struct btrfs_iget_args *args = p;
1190 inode->i_ino = args->ino;
1191 BTRFS_I(inode)->root = args->root;
1018 if (err)
1019 return err;
1020 }
1021out:
1022 err = inode_setattr(inode, attr);
1023fail:
1024 return err;
1025}

--- 167 unchanged lines hidden (view full) ---

1193 return 0;
1194}
1195
1196static int btrfs_init_locked_inode(struct inode *inode, void *p)
1197{
1198 struct btrfs_iget_args *args = p;
1199 inode->i_ino = args->ino;
1200 BTRFS_I(inode)->root = args->root;
1192 extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
1201 extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
1202 extent_io_tree_init(&BTRFS_I(inode)->io_tree,
1193 inode->i_mapping, GFP_NOFS);
1194 return 0;
1195}
1196
1197static int btrfs_find_actor(struct inode *inode, void *opaque)
1198{
1199 struct btrfs_iget_args *args = opaque;
1200 return (args->ino == inode->i_ino &&

--- 279 unchanged lines hidden (view full) ---

1480
1481 path = btrfs_alloc_path();
1482 BUG_ON(!path);
1483
1484 inode = new_inode(root->fs_info->sb);
1485 if (!inode)
1486 return ERR_PTR(-ENOMEM);
1487
1203 inode->i_mapping, GFP_NOFS);
1204 return 0;
1205}
1206
1207static int btrfs_find_actor(struct inode *inode, void *opaque)
1208{
1209 struct btrfs_iget_args *args = opaque;
1210 return (args->ino == inode->i_ino &&

--- 279 unchanged lines hidden (view full) ---

1490
1491 path = btrfs_alloc_path();
1492 BUG_ON(!path);
1493
1494 inode = new_inode(root->fs_info->sb);
1495 if (!inode)
1496 return ERR_PTR(-ENOMEM);
1497
1488 extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
1498 extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
1499 extent_io_tree_init(&BTRFS_I(inode)->io_tree,
1489 inode->i_mapping, GFP_NOFS);
1490 BTRFS_I(inode)->root = root;
1491
1492 if (mode & S_IFDIR)
1493 owner = 0;
1494 else
1495 owner = 1;
1496 group = btrfs_find_block_group(root, group, 0, 0, owner);

--- 170 unchanged lines hidden (view full) ---

1667 btrfs_set_trans_block_group(trans, inode);
1668 err = btrfs_add_nondir(trans, dentry, inode);
1669 if (err)
1670 drop_inode = 1;
1671 else {
1672 inode->i_mapping->a_ops = &btrfs_aops;
1673 inode->i_fop = &btrfs_file_operations;
1674 inode->i_op = &btrfs_file_inode_operations;
1500 inode->i_mapping, GFP_NOFS);
1501 BTRFS_I(inode)->root = root;
1502
1503 if (mode & S_IFDIR)
1504 owner = 0;
1505 else
1506 owner = 1;
1507 group = btrfs_find_block_group(root, group, 0, 0, owner);

--- 170 unchanged lines hidden (view full) ---

1678 btrfs_set_trans_block_group(trans, inode);
1679 err = btrfs_add_nondir(trans, dentry, inode);
1680 if (err)
1681 drop_inode = 1;
1682 else {
1683 inode->i_mapping->a_ops = &btrfs_aops;
1684 inode->i_fop = &btrfs_file_operations;
1685 inode->i_op = &btrfs_file_inode_operations;
1675 extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
1686 extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
1687 extent_io_tree_init(&BTRFS_I(inode)->io_tree,
1676 inode->i_mapping, GFP_NOFS);
1688 inode->i_mapping, GFP_NOFS);
1677 BTRFS_I(inode)->extent_tree.ops = &btrfs_extent_map_ops;
1689 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
1678 }
1679 dir->i_sb->s_dirt = 1;
1680 btrfs_update_inode_block_group(trans, inode);
1681 btrfs_update_inode_block_group(trans, dir);
1682out_unlock:
1683 nr = trans->blocks_used;
1684 btrfs_end_transaction(trans, root);
1685fail:

--- 125 unchanged lines hidden (view full) ---

1811 if (drop_on_err)
1812 iput(inode);
1813 btrfs_btree_balance_dirty(root, nr);
1814 btrfs_throttle(root);
1815 return err;
1816}
1817
1818struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
1690 }
1691 dir->i_sb->s_dirt = 1;
1692 btrfs_update_inode_block_group(trans, inode);
1693 btrfs_update_inode_block_group(trans, dir);
1694out_unlock:
1695 nr = trans->blocks_used;
1696 btrfs_end_transaction(trans, root);
1697fail:

--- 125 unchanged lines hidden (view full) ---

1823 if (drop_on_err)
1824 iput(inode);
1825 btrfs_btree_balance_dirty(root, nr);
1826 btrfs_throttle(root);
1827 return err;
1828}
1829
1830struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
1819 size_t page_offset, u64 start, u64 end,
1831 size_t page_offset, u64 start, u64 len,
1820 int create)
1821{
1822 int ret;
1823 int err = 0;
1824 u64 bytenr;
1825 u64 extent_start = 0;
1826 u64 extent_end = 0;
1827 u64 objectid = inode->i_ino;
1828 u32 found_type;
1832 int create)
1833{
1834 int ret;
1835 int err = 0;
1836 u64 bytenr;
1837 u64 extent_start = 0;
1838 u64 extent_end = 0;
1839 u64 objectid = inode->i_ino;
1840 u32 found_type;
1829 int failed_insert = 0;
1830 struct btrfs_path *path;
1831 struct btrfs_root *root = BTRFS_I(inode)->root;
1832 struct btrfs_file_extent_item *item;
1833 struct extent_buffer *leaf;
1834 struct btrfs_key found_key;
1835 struct extent_map *em = NULL;
1836 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
1841 struct btrfs_path *path;
1842 struct btrfs_root *root = BTRFS_I(inode)->root;
1843 struct btrfs_file_extent_item *item;
1844 struct extent_buffer *leaf;
1845 struct btrfs_key found_key;
1846 struct extent_map *em = NULL;
1847 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
1848 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1837 struct btrfs_trans_handle *trans = NULL;
1838
1839 path = btrfs_alloc_path();
1840 BUG_ON(!path);
1841 mutex_lock(&root->fs_info->fs_mutex);
1842
1843again:
1849 struct btrfs_trans_handle *trans = NULL;
1850
1851 path = btrfs_alloc_path();
1852 BUG_ON(!path);
1853 mutex_lock(&root->fs_info->fs_mutex);
1854
1855again:
1844 em = lookup_extent_mapping(em_tree, start, end);
1856 spin_lock(&em_tree->lock);
1857 em = lookup_extent_mapping(em_tree, start, len);
1858 spin_unlock(&em_tree->lock);
1859
1845 if (em) {
1846 if (em->start > start) {
1860 if (em) {
1861 if (em->start > start) {
1847 printk("get_extent start %Lu em start %Lu\n",
1848 start, em->start);
1862 printk("get_extent lookup [%Lu %Lu] em [%Lu %Lu]\n",
1863 start, len, em->start, em->len);
1849 WARN_ON(1);
1850 }
1851 goto out;
1852 }
1864 WARN_ON(1);
1865 }
1866 goto out;
1867 }
1868 em = alloc_extent_map(GFP_NOFS);
1853 if (!em) {
1869 if (!em) {
1854 em = alloc_extent_map(GFP_NOFS);
1855 if (!em) {
1856 err = -ENOMEM;
1857 goto out;
1858 }
1859 em->start = EXTENT_MAP_HOLE;
1860 em->end = EXTENT_MAP_HOLE;
1870 err = -ENOMEM;
1871 goto out;
1861 }
1872 }
1873
1874 em->start = EXTENT_MAP_HOLE;
1875 em->len = (u64)-1;
1862 em->bdev = inode->i_sb->s_bdev;
1863 ret = btrfs_lookup_file_extent(trans, root, path,
1864 objectid, start, trans != NULL);
1865 if (ret < 0) {
1866 err = ret;
1867 goto out;
1868 }
1869

--- 18 unchanged lines hidden (view full) ---

1888 extent_start = found_key.offset;
1889 if (found_type == BTRFS_FILE_EXTENT_REG) {
1890 extent_end = extent_start +
1891 btrfs_file_extent_num_bytes(leaf, item);
1892 err = 0;
1893 if (start < extent_start || start >= extent_end) {
1894 em->start = start;
1895 if (start < extent_start) {
1876 em->bdev = inode->i_sb->s_bdev;
1877 ret = btrfs_lookup_file_extent(trans, root, path,
1878 objectid, start, trans != NULL);
1879 if (ret < 0) {
1880 err = ret;
1881 goto out;
1882 }
1883

--- 18 unchanged lines hidden (view full) ---

1902 extent_start = found_key.offset;
1903 if (found_type == BTRFS_FILE_EXTENT_REG) {
1904 extent_end = extent_start +
1905 btrfs_file_extent_num_bytes(leaf, item);
1906 err = 0;
1907 if (start < extent_start || start >= extent_end) {
1908 em->start = start;
1909 if (start < extent_start) {
1896 if (end < extent_start)
1910 if (start + len <= extent_start)
1897 goto not_found;
1911 goto not_found;
1898 em->end = extent_end - 1;
1912 em->len = extent_end - extent_start;
1899 } else {
1913 } else {
1900 em->end = end;
1914 em->len = len;
1901 }
1902 goto not_found_em;
1903 }
1904 bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
1905 if (bytenr == 0) {
1906 em->start = extent_start;
1915 }
1916 goto not_found_em;
1917 }
1918 bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
1919 if (bytenr == 0) {
1920 em->start = extent_start;
1907 em->end = extent_end - 1;
1921 em->len = extent_end - extent_start;
1908 em->block_start = EXTENT_MAP_HOLE;
1922 em->block_start = EXTENT_MAP_HOLE;
1909 em->block_end = EXTENT_MAP_HOLE;
1910 goto insert;
1911 }
1912 bytenr += btrfs_file_extent_offset(leaf, item);
1913 em->block_start = bytenr;
1923 goto insert;
1924 }
1925 bytenr += btrfs_file_extent_offset(leaf, item);
1926 em->block_start = bytenr;
1914 em->block_end = em->block_start +
1915 btrfs_file_extent_num_bytes(leaf, item) - 1;
1916 em->start = extent_start;
1927 em->start = extent_start;
1917 em->end = extent_end - 1;
1928 em->len = extent_end - extent_start;
1918 goto insert;
1919 } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
1920 unsigned long ptr;
1921 char *map;
1922 size_t size;
1923 size_t extent_offset;
1924 size_t copy_size;
1925
1926 size = btrfs_file_extent_inline_len(leaf, btrfs_item_nr(leaf,
1927 path->slots[0]));
1929 goto insert;
1930 } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
1931 unsigned long ptr;
1932 char *map;
1933 size_t size;
1934 size_t extent_offset;
1935 size_t copy_size;
1936
1937 size = btrfs_file_extent_inline_len(leaf, btrfs_item_nr(leaf,
1938 path->slots[0]));
1928 extent_end = (extent_start + size - 1) |
1929 ((u64)root->sectorsize - 1);
1939 extent_end = (extent_start + size + root->sectorsize - 1) &
1940 ~((u64)root->sectorsize - 1);
1930 if (start < extent_start || start >= extent_end) {
1931 em->start = start;
1932 if (start < extent_start) {
1941 if (start < extent_start || start >= extent_end) {
1942 em->start = start;
1943 if (start < extent_start) {
1933 if (end < extent_start)
1944 if (start + len <= extent_start)
1934 goto not_found;
1945 goto not_found;
1935 em->end = extent_end;
1946 em->len = extent_end - extent_start;
1936 } else {
1947 } else {
1937 em->end = end;
1948 em->len = len;
1938 }
1939 goto not_found_em;
1940 }
1941 em->block_start = EXTENT_MAP_INLINE;
1949 }
1950 goto not_found_em;
1951 }
1952 em->block_start = EXTENT_MAP_INLINE;
1942 em->block_end = EXTENT_MAP_INLINE;
1943
1944 if (!page) {
1945 em->start = extent_start;
1953
1954 if (!page) {
1955 em->start = extent_start;
1946 em->end = extent_start + size - 1;
1956 em->len = size;
1947 goto out;
1948 }
1949
1950 extent_offset = ((u64)page->index << PAGE_CACHE_SHIFT) -
1951 extent_start + page_offset;
1952 copy_size = min_t(u64, PAGE_CACHE_SIZE - page_offset,
1953 size - extent_offset);
1954 em->start = extent_start + extent_offset;
1957 goto out;
1958 }
1959
1960 extent_offset = ((u64)page->index << PAGE_CACHE_SHIFT) -
1961 extent_start + page_offset;
1962 copy_size = min_t(u64, PAGE_CACHE_SIZE - page_offset,
1963 size - extent_offset);
1964 em->start = extent_start + extent_offset;
1955 em->end = (em->start + copy_size -1) |
1956 ((u64)root->sectorsize -1);
1965 em->len = copy_size;
1957 map = kmap(page);
1958 ptr = btrfs_file_extent_inline_start(item) + extent_offset;
1959 if (create == 0 && !PageUptodate(page)) {
1960 read_extent_buffer(leaf, map + page_offset, ptr,
1961 copy_size);
1962 flush_dcache_page(page);
1963 } else if (create && PageUptodate(page)) {
1964 if (!trans) {

--- 4 unchanged lines hidden (view full) ---

1969 trans = btrfs_start_transaction(root, 1);
1970 goto again;
1971 }
1972 write_extent_buffer(leaf, map + page_offset, ptr,
1973 copy_size);
1974 btrfs_mark_buffer_dirty(leaf);
1975 }
1976 kunmap(page);
1966 map = kmap(page);
1967 ptr = btrfs_file_extent_inline_start(item) + extent_offset;
1968 if (create == 0 && !PageUptodate(page)) {
1969 read_extent_buffer(leaf, map + page_offset, ptr,
1970 copy_size);
1971 flush_dcache_page(page);
1972 } else if (create && PageUptodate(page)) {
1973 if (!trans) {

--- 4 unchanged lines hidden (view full) ---

1978 trans = btrfs_start_transaction(root, 1);
1979 goto again;
1980 }
1981 write_extent_buffer(leaf, map + page_offset, ptr,
1982 copy_size);
1983 btrfs_mark_buffer_dirty(leaf);
1984 }
1985 kunmap(page);
1977 set_extent_uptodate(em_tree, em->start, em->end, GFP_NOFS);
1986 set_extent_uptodate(io_tree, em->start,
1987 extent_map_end(em) - 1, GFP_NOFS);
1978 goto insert;
1979 } else {
1980 printk("unkknown found_type %d\n", found_type);
1981 WARN_ON(1);
1982 }
1983not_found:
1984 em->start = start;
1988 goto insert;
1989 } else {
1990 printk("unkknown found_type %d\n", found_type);
1991 WARN_ON(1);
1992 }
1993not_found:
1994 em->start = start;
1985 em->end = end;
1995 em->len = len;
1986not_found_em:
1987 em->block_start = EXTENT_MAP_HOLE;
1996not_found_em:
1997 em->block_start = EXTENT_MAP_HOLE;
1988 em->block_end = EXTENT_MAP_HOLE;
1989insert:
1990 btrfs_release_path(root, path);
1998insert:
1999 btrfs_release_path(root, path);
1991 if (em->start > start || em->end < start) {
1992 printk("bad extent! em: [%Lu %Lu] passed [%Lu %Lu]\n", em->start, em->end, start, end);
2000 if (em->start > start || extent_map_end(em) <= start) {
2001 printk("bad extent! em: [%Lu %Lu] passed [%Lu %Lu]\n", em->start, em->len, start, len);
1993 err = -EIO;
1994 goto out;
1995 }
2002 err = -EIO;
2003 goto out;
2004 }
2005
2006 err = 0;
2007 spin_lock(&em_tree->lock);
1996 ret = add_extent_mapping(em_tree, em);
1997 if (ret == -EEXIST) {
1998 free_extent_map(em);
2008 ret = add_extent_mapping(em_tree, em);
2009 if (ret == -EEXIST) {
2010 free_extent_map(em);
1999 em = NULL;
2000 if (0 && failed_insert == 1) {
2001 btrfs_drop_extent_cache(inode, start, end);
2002 }
2003 failed_insert++;
2004 if (failed_insert > 5) {
2005 printk("failing to insert %Lu %Lu\n", start, end);
2011 em = lookup_extent_mapping(em_tree, start, len);
2012 if (!em) {
2006 err = -EIO;
2013 err = -EIO;
2007 goto out;
2014 printk("failing to insert %Lu %Lu\n", start, len);
2008 }
2015 }
2009 goto again;
2010 }
2016 }
2011 err = 0;
2017 spin_unlock(&em_tree->lock);
2012out:
2013 btrfs_free_path(path);
2014 if (trans) {
2015 ret = btrfs_end_transaction(trans, root);
2016 if (!err)
2017 err = ret;
2018 }
2019 mutex_unlock(&root->fs_info->fs_mutex);

--- 7 unchanged lines hidden (view full) ---

2027
2028static sector_t btrfs_bmap(struct address_space *mapping, sector_t iblock)
2029{
2030 return extent_bmap(mapping, iblock, btrfs_get_extent);
2031}
2032
2033int btrfs_readpage(struct file *file, struct page *page)
2034{
2018out:
2019 btrfs_free_path(path);
2020 if (trans) {
2021 ret = btrfs_end_transaction(trans, root);
2022 if (!err)
2023 err = ret;
2024 }
2025 mutex_unlock(&root->fs_info->fs_mutex);

--- 7 unchanged lines hidden (view full) ---

2033
2034static sector_t btrfs_bmap(struct address_space *mapping, sector_t iblock)
2035{
2036 return extent_bmap(mapping, iblock, btrfs_get_extent);
2037}
2038
2039int btrfs_readpage(struct file *file, struct page *page)
2040{
2035 struct extent_map_tree *tree;
2036 tree = &BTRFS_I(page->mapping->host)->extent_tree;
2041 struct extent_io_tree *tree;
2042 tree = &BTRFS_I(page->mapping->host)->io_tree;
2037 return extent_read_full_page(tree, page, btrfs_get_extent);
2038}
2039
2040static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
2041{
2043 return extent_read_full_page(tree, page, btrfs_get_extent);
2044}
2045
2046static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
2047{
2042 struct extent_map_tree *tree;
2048 struct extent_io_tree *tree;
2043
2044
2045 if (current->flags & PF_MEMALLOC) {
2046 redirty_page_for_writepage(wbc, page);
2047 unlock_page(page);
2048 return 0;
2049 }
2049
2050
2051 if (current->flags & PF_MEMALLOC) {
2052 redirty_page_for_writepage(wbc, page);
2053 unlock_page(page);
2054 return 0;
2055 }
2050 tree = &BTRFS_I(page->mapping->host)->extent_tree;
2056 tree = &BTRFS_I(page->mapping->host)->io_tree;
2051 return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
2052}
2053
2054static int btrfs_writepages(struct address_space *mapping,
2055 struct writeback_control *wbc)
2056{
2057 return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
2058}
2059
2060static int btrfs_writepages(struct address_space *mapping,
2061 struct writeback_control *wbc)
2062{
2057 struct extent_map_tree *tree;
2058 tree = &BTRFS_I(mapping->host)->extent_tree;
2063 struct extent_io_tree *tree;
2064 tree = &BTRFS_I(mapping->host)->io_tree;
2059 return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
2060}
2061
2062static int
2063btrfs_readpages(struct file *file, struct address_space *mapping,
2064 struct list_head *pages, unsigned nr_pages)
2065{
2065 return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
2066}
2067
2068static int
2069btrfs_readpages(struct file *file, struct address_space *mapping,
2070 struct list_head *pages, unsigned nr_pages)
2071{
2066 struct extent_map_tree *tree;
2067 tree = &BTRFS_I(mapping->host)->extent_tree;
2072 struct extent_io_tree *tree;
2073 tree = &BTRFS_I(mapping->host)->io_tree;
2068 return extent_readpages(tree, mapping, pages, nr_pages,
2069 btrfs_get_extent);
2070}
2071
2072static int btrfs_releasepage(struct page *page, gfp_t unused_gfp_flags)
2073{
2074 return extent_readpages(tree, mapping, pages, nr_pages,
2075 btrfs_get_extent);
2076}
2077
2078static int btrfs_releasepage(struct page *page, gfp_t unused_gfp_flags)
2079{
2074 struct extent_map_tree *tree;
2080 struct extent_io_tree *tree;
2081 struct extent_map_tree *map;
2075 int ret;
2076
2082 int ret;
2083
2077 tree = &BTRFS_I(page->mapping->host)->extent_tree;
2078 ret = try_release_extent_mapping(tree, page);
2084 tree = &BTRFS_I(page->mapping->host)->io_tree;
2085 map = &BTRFS_I(page->mapping->host)->extent_tree;
2086 ret = try_release_extent_mapping(map, tree, page);
2079 if (ret == 1) {
2080 ClearPagePrivate(page);
2081 set_page_private(page, 0);
2082 page_cache_release(page);
2083 }
2084 return ret;
2085}
2086
2087static void btrfs_invalidatepage(struct page *page, unsigned long offset)
2088{
2087 if (ret == 1) {
2088 ClearPagePrivate(page);
2089 set_page_private(page, 0);
2090 page_cache_release(page);
2091 }
2092 return ret;
2093}
2094
2095static void btrfs_invalidatepage(struct page *page, unsigned long offset)
2096{
2089 struct extent_map_tree *tree;
2097 struct extent_io_tree *tree;
2090
2098
2091 tree = &BTRFS_I(page->mapping->host)->extent_tree;
2099 tree = &BTRFS_I(page->mapping->host)->io_tree;
2092 extent_invalidatepage(tree, page, offset);
2093 btrfs_releasepage(page, GFP_NOFS);
2094}
2095
2096/*
2097 * btrfs_page_mkwrite() is not allowed to change the file size as it gets
2098 * called from a page fault handler when a page is first dirtied. Hence we must
2099 * be careful to check for EOF conditions here. We set the page up correctly

--- 269 unchanged lines hidden (view full) ---

2369 page_cache_sync_readahead(mapping, ra, file, offset, req_size);
2370 return offset + req_size;
2371#endif
2372}
2373
2374int btrfs_defrag_file(struct file *file) {
2375 struct inode *inode = fdentry(file)->d_inode;
2376 struct btrfs_root *root = BTRFS_I(inode)->root;
2100 extent_invalidatepage(tree, page, offset);
2101 btrfs_releasepage(page, GFP_NOFS);
2102}
2103
2104/*
2105 * btrfs_page_mkwrite() is not allowed to change the file size as it gets
2106 * called from a page fault handler when a page is first dirtied. Hence we must
2107 * be careful to check for EOF conditions here. We set the page up correctly

--- 269 unchanged lines hidden (view full) ---

2377 page_cache_sync_readahead(mapping, ra, file, offset, req_size);
2378 return offset + req_size;
2379#endif
2380}
2381
2382int btrfs_defrag_file(struct file *file) {
2383 struct inode *inode = fdentry(file)->d_inode;
2384 struct btrfs_root *root = BTRFS_I(inode)->root;
2377 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
2385 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
2378 struct page *page;
2379 unsigned long last_index;
2380 unsigned long ra_index = 0;
2381 u64 page_start;
2382 u64 page_end;
2383 u64 delalloc_start;
2384 u64 existing_delalloc;
2385 unsigned long i;

--- 23 unchanged lines hidden (view full) ---

2409 unlock_page(page);
2410 page_cache_release(page);
2411 goto out_unlock;
2412 }
2413 }
2414 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
2415 page_end = page_start + PAGE_CACHE_SIZE - 1;
2416
2386 struct page *page;
2387 unsigned long last_index;
2388 unsigned long ra_index = 0;
2389 u64 page_start;
2390 u64 page_end;
2391 u64 delalloc_start;
2392 u64 existing_delalloc;
2393 unsigned long i;

--- 23 unchanged lines hidden (view full) ---

2417 unlock_page(page);
2418 page_cache_release(page);
2419 goto out_unlock;
2420 }
2421 }
2422 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
2423 page_end = page_start + PAGE_CACHE_SIZE - 1;
2424
2417 lock_extent(em_tree, page_start, page_end, GFP_NOFS);
2425 lock_extent(io_tree, page_start, page_end, GFP_NOFS);
2418 delalloc_start = page_start;
2419 existing_delalloc =
2426 delalloc_start = page_start;
2427 existing_delalloc =
2420 count_range_bits(&BTRFS_I(inode)->extent_tree,
2428 count_range_bits(&BTRFS_I(inode)->io_tree,
2421 &delalloc_start, page_end,
2422 PAGE_CACHE_SIZE, EXTENT_DELALLOC);
2429 &delalloc_start, page_end,
2430 PAGE_CACHE_SIZE, EXTENT_DELALLOC);
2423 set_extent_delalloc(em_tree, page_start,
2431 set_extent_delalloc(io_tree, page_start,
2424 page_end, GFP_NOFS);
2425
2426 spin_lock(&root->fs_info->delalloc_lock);
2427 root->fs_info->delalloc_bytes += PAGE_CACHE_SIZE -
2428 existing_delalloc;
2429 spin_unlock(&root->fs_info->delalloc_lock);
2430
2432 page_end, GFP_NOFS);
2433
2434 spin_lock(&root->fs_info->delalloc_lock);
2435 root->fs_info->delalloc_bytes += PAGE_CACHE_SIZE -
2436 existing_delalloc;
2437 spin_unlock(&root->fs_info->delalloc_lock);
2438
2431 unlock_extent(em_tree, page_start, page_end, GFP_NOFS);
2439 unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
2432 set_page_dirty(page);
2433 unlock_page(page);
2434 page_cache_release(page);
2435 balance_dirty_pages_ratelimited_nr(inode->i_mapping, 1);
2436 }
2437
2438out_unlock:
2439 mutex_unlock(&inode->i_mutex);

--- 397 unchanged lines hidden (view full) ---

2837 btrfs_set_trans_block_group(trans, inode);
2838 err = btrfs_add_nondir(trans, dentry, inode);
2839 if (err)
2840 drop_inode = 1;
2841 else {
2842 inode->i_mapping->a_ops = &btrfs_aops;
2843 inode->i_fop = &btrfs_file_operations;
2844 inode->i_op = &btrfs_file_inode_operations;
2440 set_page_dirty(page);
2441 unlock_page(page);
2442 page_cache_release(page);
2443 balance_dirty_pages_ratelimited_nr(inode->i_mapping, 1);
2444 }
2445
2446out_unlock:
2447 mutex_unlock(&inode->i_mutex);

--- 397 unchanged lines hidden (view full) ---

2845 btrfs_set_trans_block_group(trans, inode);
2846 err = btrfs_add_nondir(trans, dentry, inode);
2847 if (err)
2848 drop_inode = 1;
2849 else {
2850 inode->i_mapping->a_ops = &btrfs_aops;
2851 inode->i_fop = &btrfs_file_operations;
2852 inode->i_op = &btrfs_file_inode_operations;
2845 extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
2853 extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
2854 extent_io_tree_init(&BTRFS_I(inode)->io_tree,
2846 inode->i_mapping, GFP_NOFS);
2855 inode->i_mapping, GFP_NOFS);
2847 BTRFS_I(inode)->extent_tree.ops = &btrfs_extent_map_ops;
2856 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
2848 }
2849 dir->i_sb->s_dirt = 1;
2850 btrfs_update_inode_block_group(trans, inode);
2851 btrfs_update_inode_block_group(trans, dir);
2852 if (drop_inode)
2853 goto out_unlock;
2854
2855 path = btrfs_alloc_path();

--- 73 unchanged lines hidden (view full) ---

2929 .read = generic_read_dir,
2930 .readdir = btrfs_readdir,
2931 .unlocked_ioctl = btrfs_ioctl,
2932#ifdef CONFIG_COMPAT
2933 .compat_ioctl = btrfs_ioctl,
2934#endif
2935};
2936
2857 }
2858 dir->i_sb->s_dirt = 1;
2859 btrfs_update_inode_block_group(trans, inode);
2860 btrfs_update_inode_block_group(trans, dir);
2861 if (drop_inode)
2862 goto out_unlock;
2863
2864 path = btrfs_alloc_path();

--- 73 unchanged lines hidden (view full) ---

2938 .read = generic_read_dir,
2939 .readdir = btrfs_readdir,
2940 .unlocked_ioctl = btrfs_ioctl,
2941#ifdef CONFIG_COMPAT
2942 .compat_ioctl = btrfs_ioctl,
2943#endif
2944};
2945
2937static struct extent_map_ops btrfs_extent_map_ops = {
2946static struct extent_io_ops btrfs_extent_io_ops = {
2938 .fill_delalloc = run_delalloc_range,
2939 .writepage_io_hook = btrfs_writepage_io_hook,
2940 .readpage_io_hook = btrfs_readpage_io_hook,
2941 .readpage_end_io_hook = btrfs_readpage_end_io_hook,
2942};
2943
2944static struct address_space_operations btrfs_aops = {
2945 .readpage = btrfs_readpage,

--- 38 unchanged lines hidden --- 		2947 .fill_delalloc = run_delalloc_range,
2948 .writepage_io_hook = btrfs_writepage_io_hook,
2949 .readpage_io_hook = btrfs_readpage_io_hook,
2950 .readpage_end_io_hook = btrfs_readpage_end_io_hook,
2951};
2952
2953static struct address_space_operations btrfs_aops = {
2954 .readpage = btrfs_readpage,

--- 38 unchanged lines hidden ---