summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2017-03-02 19:03:00 -0500
committerLinus Torvalds <torvalds@linux-foundation.org>2017-03-02 19:03:00 -0500
commitbbe08c0a43e2c5ee3a00de68c0e867a08a9aa990 (patch)
tree389386abdf1ee5820514437d0c2e22b4b64773df
parent94e877d0fb43bec0540d6a37d49cb4f7f05a5348 (diff)
parente9f467d028cd7d8bee2a4d6c4fb806caf8cd580b (diff)
Merge branch 'for-linus-4.11' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs
Pull more btrfs updates from Chris Mason: "Btrfs round two. These are mostly a continuation of Dave Sterba's collection of cleanups, but Filipe also has some bug fixes and performance improvements" * 'for-linus-4.11' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs: (69 commits) btrfs: add dummy callback for readpage_io_failed and drop checks btrfs: drop checks for mandatory extent_io_ops callbacks btrfs: document existence of extent_io ops callbacks btrfs: let writepage_end_io_hook return void btrfs: do proper error handling in btrfs_insert_xattr_item btrfs: handle allocation error in update_dev_stat_item btrfs: remove BUG_ON from __tree_mod_log_insert btrfs: derive maximum output size in the compression implementation btrfs: use predefined limits for calculating maximum number of pages for compression btrfs: export compression buffer limits in a header btrfs: merge nr_pages input and output parameter in compress_pages btrfs: merge length input and output parameter in compress_pages btrfs: constify name of subvolume in creation helpers btrfs: constify buffers used by compression helpers btrfs: constify input buffer of btrfs_csum_data btrfs: constify device path passed to relevant helpers btrfs: make btrfs_inode_resume_unlocked_dio take btrfs_inode btrfs: make btrfs_inode_block_unlocked_dio take btrfs_inode btrfs: Make btrfs_add_nondir take btrfs_inode btrfs: Make btrfs_add_link take btrfs_inode ...
Diffstat
-rw-r--r--fs/btrfs/btrfs_inode.h31
-rw-r--r--fs/btrfs/compression.c43
-rw-r--r--fs/btrfs/compression.h30
-rw-r--r--fs/btrfs/ctree.c9
-rw-r--r--fs/btrfs/ctree.h39
-rw-r--r--fs/btrfs/delayed-inode.c2
-rw-r--r--fs/btrfs/dev-replace.c5
-rw-r--r--fs/btrfs/dev-replace.h5
-rw-r--r--fs/btrfs/dir-item.c9
-rw-r--r--fs/btrfs/disk-io.c32
-rw-r--r--fs/btrfs/disk-io.h2
-rw-r--r--fs/btrfs/extent-tree.c144
-rw-r--r--fs/btrfs/extent_io.c75
-rw-r--r--fs/btrfs/extent_io.h50
-rw-r--r--fs/btrfs/file-item.c40
-rw-r--r--fs/btrfs/file.c139
-rw-r--r--fs/btrfs/free-space-cache.c5
-rw-r--r--fs/btrfs/inode-map.c2
-rw-r--r--fs/btrfs/inode.c445
-rw-r--r--fs/btrfs/ioctl.c38
-rw-r--r--fs/btrfs/lzo.c12
-rw-r--r--fs/btrfs/ordered-data.c9
-rw-r--r--fs/btrfs/ordered-data.h7
-rw-r--r--fs/btrfs/relocation.c17
-rw-r--r--fs/btrfs/scrub.c11
-rw-r--r--fs/btrfs/send.c125
-rw-r--r--fs/btrfs/tests/inode-tests.c46
-rw-r--r--fs/btrfs/transaction.c6
-rw-r--r--fs/btrfs/tree-log.c97
-rw-r--r--fs/btrfs/volumes.c21
-rw-r--r--fs/btrfs/volumes.h12
-rw-r--r--fs/btrfs/zlib.c9
32 files changed, 861 insertions, 656 deletions
diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index 819a6d27218a..0c6baaba0651 100644
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -237,20 +237,20 @@ static inline u64 btrfs_ino(struct btrfs_inode *inode)
237 return ino; 237 return ino;
238} 238}
239 239
240static inline void btrfs_i_size_write(struct inode *inode, u64 size) 240static inline void btrfs_i_size_write(struct btrfs_inode *inode, u64 size)
241{ 241{
242 i_size_write(inode, size); 242 i_size_write(&inode->vfs_inode, size);
243 BTRFS_I(inode)->disk_i_size = size; 243 inode->disk_i_size = size;
244} 244}
245 245
246static inline bool btrfs_is_free_space_inode(struct inode *inode) 246static inline bool btrfs_is_free_space_inode(struct btrfs_inode *inode)
247{ 247{
248 struct btrfs_root *root = BTRFS_I(inode)->root; 248 struct btrfs_root *root = inode->root;
249 249
250 if (root == root->fs_info->tree_root && 250 if (root == root->fs_info->tree_root &&
251 btrfs_ino(BTRFS_I(inode)) != BTRFS_BTREE_INODE_OBJECTID) 251 btrfs_ino(inode) != BTRFS_BTREE_INODE_OBJECTID)
252 return true; 252 return true;
253 if (BTRFS_I(inode)->location.objectid == BTRFS_FREE_INO_OBJECTID) 253 if (inode->location.objectid == BTRFS_FREE_INO_OBJECTID)
254 return true; 254 return true;
255 return false; 255 return false;
256} 256}
@@ -311,34 +311,33 @@ struct btrfs_dio_private {
311 * to grab i_mutex. It is used to avoid the endless truncate due to 311 * to grab i_mutex. It is used to avoid the endless truncate due to
312 * nonlocked dio read. 312 * nonlocked dio read.
313 */ 313 */
314static inline void btrfs_inode_block_unlocked_dio(struct inode *inode) 314static inline void btrfs_inode_block_unlocked_dio(struct btrfs_inode *inode)
315{ 315{
316 set_bit(BTRFS_INODE_READDIO_NEED_LOCK, &BTRFS_I(inode)->runtime_flags); 316 set_bit(BTRFS_INODE_READDIO_NEED_LOCK, &inode->runtime_flags);
317 smp_mb(); 317 smp_mb();
318} 318}
319 319
320static inline void btrfs_inode_resume_unlocked_dio(struct inode *inode) 320static inline void btrfs_inode_resume_unlocked_dio(struct btrfs_inode *inode)
321{ 321{
322 smp_mb__before_atomic(); 322 smp_mb__before_atomic();
323 clear_bit(BTRFS_INODE_READDIO_NEED_LOCK, 323 clear_bit(BTRFS_INODE_READDIO_NEED_LOCK, &inode->runtime_flags);
324 &BTRFS_I(inode)->runtime_flags);
325} 324}
326 325
327static inline void btrfs_print_data_csum_error(struct inode *inode, 326static inline void btrfs_print_data_csum_error(struct btrfs_inode *inode,
328 u64 logical_start, u32 csum, u32 csum_expected, int mirror_num) 327 u64 logical_start, u32 csum, u32 csum_expected, int mirror_num)
329{ 328{
330 struct btrfs_root *root = BTRFS_I(inode)->root; 329 struct btrfs_root *root = inode->root;
331 330
332 /* Output minus objectid, which is more meaningful */ 331 /* Output minus objectid, which is more meaningful */
333 if (root->objectid >= BTRFS_LAST_FREE_OBJECTID) 332 if (root->objectid >= BTRFS_LAST_FREE_OBJECTID)
334 btrfs_warn_rl(root->fs_info, 333 btrfs_warn_rl(root->fs_info,
335 "csum failed root %lld ino %lld off %llu csum 0x%08x expected csum 0x%08x mirror %d", 334 "csum failed root %lld ino %lld off %llu csum 0x%08x expected csum 0x%08x mirror %d",
336 root->objectid, btrfs_ino(BTRFS_I(inode)), 335 root->objectid, btrfs_ino(inode),
337 logical_start, csum, csum_expected, mirror_num); 336 logical_start, csum, csum_expected, mirror_num);
338 else 337 else
339 btrfs_warn_rl(root->fs_info, 338 btrfs_warn_rl(root->fs_info,
340 "csum failed root %llu ino %llu off %llu csum 0x%08x expected csum 0x%08x mirror %d", 339 "csum failed root %llu ino %llu off %llu csum 0x%08x expected csum 0x%08x mirror %d",
341 root->objectid, btrfs_ino(BTRFS_I(inode)), 340 root->objectid, btrfs_ino(inode),
342 logical_start, csum, csum_expected, mirror_num); 341 logical_start, csum, csum_expected, mirror_num);
343} 342}
344 343
diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index 903c32c9eb22..c7721a6aa3bb 100644
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -100,7 +100,7 @@ static struct bio *compressed_bio_alloc(struct block_device *bdev,
100 return btrfs_bio_alloc(bdev, first_byte >> 9, BIO_MAX_PAGES, gfp_flags); 100 return btrfs_bio_alloc(bdev, first_byte >> 9, BIO_MAX_PAGES, gfp_flags);
101} 101}
102 102
103static int check_compressed_csum(struct inode *inode, 103static int check_compressed_csum(struct btrfs_inode *inode,
104 struct compressed_bio *cb, 104 struct compressed_bio *cb,
105 u64 disk_start) 105 u64 disk_start)
106{ 106{
@@ -111,7 +111,7 @@ static int check_compressed_csum(struct inode *inode,
111 u32 csum; 111 u32 csum;
112 u32 *cb_sum = &cb->sums; 112 u32 *cb_sum = &cb->sums;
113 113
114 if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM) 114 if (inode->flags & BTRFS_INODE_NODATASUM)
115 return 0; 115 return 0;
116 116
117 for (i = 0; i < cb->nr_pages; i++) { 117 for (i = 0; i < cb->nr_pages; i++) {
@@ -125,7 +125,7 @@ static int check_compressed_csum(struct inode *inode,
125 125
126 if (csum != *cb_sum) { 126 if (csum != *cb_sum) {
127 btrfs_print_data_csum_error(inode, disk_start, csum, 127 btrfs_print_data_csum_error(inode, disk_start, csum,
128 *cb_sum, cb->mirror_num); 128 *cb_sum, cb->mirror_num);
129 ret = -EIO; 129 ret = -EIO;
130 goto fail; 130 goto fail;
131 } 131 }
@@ -165,7 +165,7 @@ static void end_compressed_bio_read(struct bio *bio)
165 goto out; 165 goto out;
166 166
167 inode = cb->inode; 167 inode = cb->inode;
168 ret = check_compressed_csum(inode, cb, 168 ret = check_compressed_csum(BTRFS_I(inode), cb,
169 (u64)bio->bi_iter.bi_sector << 9); 169 (u64)bio->bi_iter.bi_sector << 9);
170 if (ret) 170 if (ret)
171 goto csum_failed; 171 goto csum_failed;
@@ -911,32 +911,28 @@ static void free_workspaces(void)
911} 911}
912 912
913/* 913/*
914 * given an address space and start/len, compress the bytes. 914 * Given an address space and start and length, compress the bytes into @pages
915 * that are allocated on demand.
915 * 916 *
916 * pages are allocated to hold the compressed result and stored 917 * @out_pages is an in/out parameter, holds maximum number of pages to allocate
917 * in 'pages' 918 * and returns number of actually allocated pages
918 * 919 *
919 * out_pages is used to return the number of pages allocated. There 920 * @total_in is used to return the number of bytes actually read. It
920 * may be pages allocated even if we return an error 921 * may be smaller than the input length if we had to exit early because we
921 *
922 * total_in is used to return the number of bytes actually read. It
923 * may be smaller then len if we had to exit early because we
924 * ran out of room in the pages array or because we cross the 922 * ran out of room in the pages array or because we cross the
925 * max_out threshold. 923 * max_out threshold.
926 * 924 *
927 * total_out is used to return the total number of compressed bytes 925 * @total_out is an in/out parameter, must be set to the input length and will
926 * be also used to return the total number of compressed bytes
928 * 927 *
929 * max_out tells us the max number of bytes that we're allowed to 928 * @max_out tells us the max number of bytes that we're allowed to
930 * stuff into pages 929 * stuff into pages
931 */ 930 */
932int btrfs_compress_pages(int type, struct address_space *mapping, 931int btrfs_compress_pages(int type, struct address_space *mapping,
933 u64 start, unsigned long len, 932 u64 start, struct page **pages,
934 struct page **pages,
935 unsigned long nr_dest_pages,
936 unsigned long *out_pages, 933 unsigned long *out_pages,
937 unsigned long *total_in, 934 unsigned long *total_in,
938 unsigned long *total_out, 935 unsigned long *total_out)
939 unsigned long max_out)
940{ 936{
941 struct list_head *workspace; 937 struct list_head *workspace;
942 int ret; 938 int ret;
@@ -944,10 +940,9 @@ int btrfs_compress_pages(int type, struct address_space *mapping,
944 workspace = find_workspace(type); 940 workspace = find_workspace(type);
945 941
946 ret = btrfs_compress_op[type-1]->compress_pages(workspace, mapping, 942 ret = btrfs_compress_op[type-1]->compress_pages(workspace, mapping,
947 start, len, pages, 943 start, pages,
948 nr_dest_pages, out_pages, 944 out_pages,
949 total_in, total_out, 945 total_in, total_out);
950 max_out);
951 free_workspace(type, workspace); 946 free_workspace(type, workspace);
952 return ret; 947 return ret;
953} 948}
@@ -1015,7 +1010,7 @@ void btrfs_exit_compress(void)
1015 * 1010 *
1016 * total_out is the last byte of the buffer 1011 * total_out is the last byte of the buffer
1017 */ 1012 */
1018int btrfs_decompress_buf2page(char *buf, unsigned long buf_start, 1013int btrfs_decompress_buf2page(const char *buf, unsigned long buf_start,
1019 unsigned long total_out, u64 disk_start, 1014 unsigned long total_out, u64 disk_start,
1020 struct bio *bio) 1015 struct bio *bio)
1021{ 1016{
diff --git a/fs/btrfs/compression.h b/fs/btrfs/compression.h
index 09879579fbc8..39ec43ab8df1 100644
--- a/fs/btrfs/compression.h
+++ b/fs/btrfs/compression.h
@@ -19,20 +19,32 @@
19#ifndef __BTRFS_COMPRESSION_ 19#ifndef __BTRFS_COMPRESSION_
20#define __BTRFS_COMPRESSION_ 20#define __BTRFS_COMPRESSION_
21 21
22/*
23 * We want to make sure that amount of RAM required to uncompress an extent is
24 * reasonable, so we limit the total size in ram of a compressed extent to
25 * 128k. This is a crucial number because it also controls how easily we can
26 * spread reads across cpus for decompression.
27 *
28 * We also want to make sure the amount of IO required to do a random read is
29 * reasonably small, so we limit the size of a compressed extent to 128k.
30 */
31
32/* Maximum length of compressed data stored on disk */
33#define BTRFS_MAX_COMPRESSED (SZ_128K)
34/* Maximum size of data before compression */
35#define BTRFS_MAX_UNCOMPRESSED (SZ_128K)
36
22void btrfs_init_compress(void); 37void btrfs_init_compress(void);
23void btrfs_exit_compress(void); 38void btrfs_exit_compress(void);
24 39
25int btrfs_compress_pages(int type, struct address_space *mapping, 40int btrfs_compress_pages(int type, struct address_space *mapping,
26 u64 start, unsigned long len, 41 u64 start, struct page **pages,
27 struct page **pages,
28 unsigned long nr_dest_pages,
29 unsigned long *out_pages, 42 unsigned long *out_pages,
30 unsigned long *total_in, 43 unsigned long *total_in,
31 unsigned long *total_out, 44 unsigned long *total_out);
32 unsigned long max_out);
33int btrfs_decompress(int type, unsigned char *data_in, struct page *dest_page, 45int btrfs_decompress(int type, unsigned char *data_in, struct page *dest_page,
34 unsigned long start_byte, size_t srclen, size_t destlen); 46 unsigned long start_byte, size_t srclen, size_t destlen);
35int btrfs_decompress_buf2page(char *buf, unsigned long buf_start, 47int btrfs_decompress_buf2page(const char *buf, unsigned long buf_start,
36 unsigned long total_out, u64 disk_start, 48 unsigned long total_out, u64 disk_start,
37 struct bio *bio); 49 struct bio *bio);
38 50
@@ -59,13 +71,11 @@ struct btrfs_compress_op {
59 71
60 int (*compress_pages)(struct list_head *workspace, 72 int (*compress_pages)(struct list_head *workspace,
61 struct address_space *mapping, 73 struct address_space *mapping,
62 u64 start, unsigned long len, 74 u64 start,
63 struct page **pages, 75 struct page **pages,
64 unsigned long nr_dest_pages,
65 unsigned long *out_pages, 76 unsigned long *out_pages,
66 unsigned long *total_in, 77 unsigned long *total_in,
67 unsigned long *total_out, 78 unsigned long *total_out);
68 unsigned long max_out);
69 79
70 int (*decompress_bio)(struct list_head *workspace, 80 int (*decompress_bio)(struct list_head *workspace,
71 struct page **pages_in, 81 struct page **pages_in,
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 1192bc7d2ee7..7dc8844037e0 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -453,8 +453,6 @@ __tree_mod_log_insert(struct btrfs_fs_info *fs_info, struct tree_mod_elem *tm)
453 struct rb_node *parent = NULL; 453 struct rb_node *parent = NULL;
454 struct tree_mod_elem *cur; 454 struct tree_mod_elem *cur;
455 455
456 BUG_ON(!tm);
457
458 tm->seq = btrfs_inc_tree_mod_seq(fs_info); 456 tm->seq = btrfs_inc_tree_mod_seq(fs_info);
459 457
460 tm_root = &fs_info->tree_mod_log; 458 tm_root = &fs_info->tree_mod_log;
@@ -4159,6 +4157,9 @@ static noinline int push_for_double_split(struct btrfs_trans_handle *trans,
4159 4157
4160 /* try to push all the items before our slot into the next leaf */ 4158 /* try to push all the items before our slot into the next leaf */
4161 slot = path->slots[0]; 4159 slot = path->slots[0];
4160 space_needed = data_size;
4161 if (slot > 0)
4162 space_needed -= btrfs_leaf_free_space(fs_info, path->nodes[0]);
4162 ret = push_leaf_left(trans, root, path, 1, space_needed, 0, slot); 4163 ret = push_leaf_left(trans, root, path, 1, space_needed, 0, slot);
4163 if (ret < 0) 4164 if (ret < 0)
4164 return ret; 4165 return ret;
@@ -4214,6 +4215,10 @@ static noinline int split_leaf(struct btrfs_trans_handle *trans,
4214 if (wret < 0) 4215 if (wret < 0)
4215 return wret; 4216 return wret;
4216 if (wret) { 4217 if (wret) {
4218 space_needed = data_size;
4219 if (slot > 0)
4220 space_needed -= btrfs_leaf_free_space(fs_info,
4221 l);
4217 wret = push_leaf_left(trans, root, path, space_needed, 4222 wret = push_leaf_left(trans, root, path, space_needed,
4218 space_needed, 0, (u32)-1); 4223 space_needed, 0, (u32)-1);
4219 if (wret < 0) 4224 if (wret < 0)
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 105d4d43993e..00e3518a26ef 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -2687,7 +2687,7 @@ enum btrfs_flush_state {
2687}; 2687};
2688 2688
2689int btrfs_check_data_free_space(struct inode *inode, u64 start, u64 len); 2689int btrfs_check_data_free_space(struct inode *inode, u64 start, u64 len);
2690int btrfs_alloc_data_chunk_ondemand(struct inode *inode, u64 bytes); 2690int btrfs_alloc_data_chunk_ondemand(struct btrfs_inode *inode, u64 bytes);
2691void btrfs_free_reserved_data_space(struct inode *inode, u64 start, u64 len); 2691void btrfs_free_reserved_data_space(struct inode *inode, u64 start, u64 len);
2692void btrfs_free_reserved_data_space_noquota(struct inode *inode, u64 start, 2692void btrfs_free_reserved_data_space_noquota(struct inode *inode, u64 start,
2693 u64 len); 2693 u64 len);
@@ -2695,16 +2695,16 @@ void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,
2695 struct btrfs_fs_info *fs_info); 2695 struct btrfs_fs_info *fs_info);
2696void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans); 2696void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans);
2697int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans, 2697int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
2698 struct inode *inode); 2698 struct btrfs_inode *inode);
2699void btrfs_orphan_release_metadata(struct inode *inode); 2699void btrfs_orphan_release_metadata(struct btrfs_inode *inode);
2700int btrfs_subvolume_reserve_metadata(struct btrfs_root *root, 2700int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
2701 struct btrfs_block_rsv *rsv, 2701 struct btrfs_block_rsv *rsv,
2702 int nitems, 2702 int nitems,
2703 u64 *qgroup_reserved, bool use_global_rsv); 2703 u64 *qgroup_reserved, bool use_global_rsv);
2704void btrfs_subvolume_release_metadata(struct btrfs_fs_info *fs_info, 2704void btrfs_subvolume_release_metadata(struct btrfs_fs_info *fs_info,
2705 struct btrfs_block_rsv *rsv); 2705 struct btrfs_block_rsv *rsv);
2706int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes); 2706int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes);
2707void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes); 2707void btrfs_delalloc_release_metadata(struct btrfs_inode *inode, u64 num_bytes);
2708int btrfs_delalloc_reserve_space(struct inode *inode, u64 start, u64 len); 2708int btrfs_delalloc_reserve_space(struct inode *inode, u64 start, u64 len);
2709void btrfs_delalloc_release_space(struct inode *inode, u64 start, u64 len); 2709void btrfs_delalloc_release_space(struct inode *inode, u64 start, u64 len);
2710void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type); 2710void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type);
@@ -2982,7 +2982,7 @@ int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir,
2982 const char *name, int name_len); 2982 const char *name, int name_len);
2983int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, 2983int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
2984 struct btrfs_root *root, const char *name, 2984 struct btrfs_root *root, const char *name,
2985 int name_len, struct inode *dir, 2985 int name_len, struct btrfs_inode *dir,
2986 struct btrfs_key *location, u8 type, u64 index); 2986 struct btrfs_key *location, u8 type, u64 index);
2987struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, 2987struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
2988 struct btrfs_root *root, 2988 struct btrfs_root *root,
@@ -3081,7 +3081,7 @@ int btrfs_csum_one_bio(struct inode *inode, struct bio *bio,
3081 u64 file_start, int contig); 3081 u64 file_start, int contig);
3082int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end, 3082int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
3083 struct list_head *list, int search_commit); 3083 struct list_head *list, int search_commit);
3084void btrfs_extent_item_to_extent_map(struct inode *inode, 3084void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
3085 const struct btrfs_path *path, 3085 const struct btrfs_path *path,
3086 struct btrfs_file_extent_item *fi, 3086 struct btrfs_file_extent_item *fi,
3087 const bool new_inline, 3087 const bool new_inline,
@@ -3100,9 +3100,9 @@ struct btrfs_delalloc_work *btrfs_alloc_delalloc_work(struct inode *inode,
3100 int delay_iput); 3100 int delay_iput);
3101void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work); 3101void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work);
3102 3102
3103struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page, 3103struct extent_map *btrfs_get_extent_fiemap(struct btrfs_inode *inode,
3104 size_t pg_offset, u64 start, u64 len, 3104 struct page *page, size_t pg_offset, u64 start,
3105 int create); 3105 u64 len, int create);
3106noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len, 3106noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
3107 u64 *orig_start, u64 *orig_block_len, 3107 u64 *orig_start, u64 *orig_block_len,
3108 u64 *ram_bytes); 3108 u64 *ram_bytes);
@@ -3123,13 +3123,13 @@ static inline void btrfs_force_ra(struct address_space *mapping,
3123} 3123}
3124 3124
3125struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry); 3125struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
3126int btrfs_set_inode_index(struct inode *dir, u64 *index); 3126int btrfs_set_inode_index(struct btrfs_inode *dir, u64 *index);
3127int btrfs_unlink_inode(struct btrfs_trans_handle *trans, 3127int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
3128 struct btrfs_root *root, 3128 struct btrfs_root *root,
3129 struct btrfs_inode *dir, struct btrfs_inode *inode, 3129 struct btrfs_inode *dir, struct btrfs_inode *inode,
3130 const char *name, int name_len); 3130 const char *name, int name_len);
3131int btrfs_add_link(struct btrfs_trans_handle *trans, 3131int btrfs_add_link(struct btrfs_trans_handle *trans,
3132 struct inode *parent_inode, struct inode *inode, 3132 struct btrfs_inode *parent_inode, struct btrfs_inode *inode,
3133 const char *name, int name_len, int add_backref, u64 index); 3133 const char *name, int name_len, int add_backref, u64 index);
3134int btrfs_unlink_subvol(struct btrfs_trans_handle *trans, 3134int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
3135 struct btrfs_root *root, 3135 struct btrfs_root *root,
@@ -3166,15 +3166,16 @@ void btrfs_destroy_cachep(void);
3166long btrfs_ioctl_trans_end(struct file *file); 3166long btrfs_ioctl_trans_end(struct file *file);
3167struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location, 3167struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
3168 struct btrfs_root *root, int *was_new); 3168 struct btrfs_root *root, int *was_new);
3169struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page, 3169struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,
3170 size_t pg_offset, u64 start, u64 end, 3170 struct page *page, size_t pg_offset,
3171 int create); 3171 u64 start, u64 end, int create);
3172int btrfs_update_inode(struct btrfs_trans_handle *trans, 3172int btrfs_update_inode(struct btrfs_trans_handle *trans,
3173 struct btrfs_root *root, 3173 struct btrfs_root *root,
3174 struct inode *inode); 3174 struct inode *inode);
3175int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans, 3175int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
3176 struct btrfs_root *root, struct inode *inode); 3176 struct btrfs_root *root, struct inode *inode);
3177int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode); 3177int btrfs_orphan_add(struct btrfs_trans_handle *trans,
3178 struct btrfs_inode *inode);
3178int btrfs_orphan_cleanup(struct btrfs_root *root); 3179int btrfs_orphan_cleanup(struct btrfs_root *root);
3179void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans, 3180void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
3180 struct btrfs_root *root); 3181 struct btrfs_root *root);
@@ -3215,11 +3216,11 @@ ssize_t btrfs_dedupe_file_range(struct file *src_file, u64 loff, u64 olen,
3215int btrfs_auto_defrag_init(void); 3216int btrfs_auto_defrag_init(void);
3216void btrfs_auto_defrag_exit(void); 3217void btrfs_auto_defrag_exit(void);
3217int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans, 3218int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
3218 struct inode *inode); 3219 struct btrfs_inode *inode);
3219int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info); 3220int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info);
3220void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info); 3221void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info);
3221int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync); 3222int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
3222void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end, 3223void btrfs_drop_extent_cache(struct btrfs_inode *inode, u64 start, u64 end,
3223 int skip_pinned); 3224 int skip_pinned);
3224extern const struct file_operations btrfs_file_operations; 3225extern const struct file_operations btrfs_file_operations;
3225int __btrfs_drop_extents(struct btrfs_trans_handle *trans, 3226int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
@@ -3233,7 +3234,7 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,
3233 struct btrfs_root *root, struct inode *inode, u64 start, 3234 struct btrfs_root *root, struct inode *inode, u64 start,
3234 u64 end, int drop_cache); 3235 u64 end, int drop_cache);
3235int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, 3236int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
3236 struct inode *inode, u64 start, u64 end); 3237 struct btrfs_inode *inode, u64 start, u64 end);
3237int btrfs_release_file(struct inode *inode, struct file *file); 3238int btrfs_release_file(struct inode *inode, struct file *file);
3238int btrfs_dirty_pages(struct inode *inode, struct page **pages, 3239int btrfs_dirty_pages(struct inode *inode, struct page **pages,
3239 size_t num_pages, loff_t pos, size_t write_bytes, 3240 size_t num_pages, loff_t pos, size_t write_bytes,
diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index f7a6ee5ccc80..1aff676f0e5b 100644
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -1790,7 +1790,7 @@ int btrfs_fill_inode(struct inode *inode, u32 *rdev)
1790 1790
1791 i_uid_write(inode, btrfs_stack_inode_uid(inode_item)); 1791 i_uid_write(inode, btrfs_stack_inode_uid(inode_item));
1792 i_gid_write(inode, btrfs_stack_inode_gid(inode_item)); 1792 i_gid_write(inode, btrfs_stack_inode_gid(inode_item));
1793 btrfs_i_size_write(inode, btrfs_stack_inode_size(inode_item)); 1793 btrfs_i_size_write(BTRFS_I(inode), btrfs_stack_inode_size(inode_item));
1794 inode->i_mode = btrfs_stack_inode_mode(inode_item); 1794 inode->i_mode = btrfs_stack_inode_mode(inode_item);
1795 set_nlink(inode, btrfs_stack_inode_nlink(inode_item)); 1795 set_nlink(inode, btrfs_stack_inode_nlink(inode_item));
1796 inode_set_bytes(inode, btrfs_stack_inode_nbytes(inode_item)); 1796 inode_set_bytes(inode, btrfs_stack_inode_nbytes(inode_item));
diff --git a/fs/btrfs/dev-replace.c b/fs/btrfs/dev-replace.c
index 5de280b9ad73..e653921f05d9 100644
--- a/fs/btrfs/dev-replace.c
+++ b/fs/btrfs/dev-replace.c
@@ -304,8 +304,9 @@ void btrfs_after_dev_replace_commit(struct btrfs_fs_info *fs_info)
304 dev_replace->cursor_left_last_write_of_item; 304 dev_replace->cursor_left_last_write_of_item;
305} 305}
306 306
307int btrfs_dev_replace_start(struct btrfs_fs_info *fs_info, char *tgtdev_name, 307int btrfs_dev_replace_start(struct btrfs_fs_info *fs_info,
308 u64 srcdevid, char *srcdev_name, int read_src) 308 const char *tgtdev_name, u64 srcdevid, const char *srcdev_name,
309 int read_src)
309{ 310{
310 struct btrfs_root *root = fs_info->dev_root; 311 struct btrfs_root *root = fs_info->dev_root;
311 struct btrfs_trans_handle *trans; 312 struct btrfs_trans_handle *trans;
diff --git a/fs/btrfs/dev-replace.h b/fs/btrfs/dev-replace.h
index 54ea12bda15b..f94a76844ae7 100644
--- a/fs/btrfs/dev-replace.h
+++ b/fs/btrfs/dev-replace.h
@@ -27,8 +27,9 @@ int btrfs_run_dev_replace(struct btrfs_trans_handle *trans,
27void btrfs_after_dev_replace_commit(struct btrfs_fs_info *fs_info); 27void btrfs_after_dev_replace_commit(struct btrfs_fs_info *fs_info);
28int btrfs_dev_replace_by_ioctl(struct btrfs_fs_info *fs_info, 28int btrfs_dev_replace_by_ioctl(struct btrfs_fs_info *fs_info,
29 struct btrfs_ioctl_dev_replace_args *args); 29 struct btrfs_ioctl_dev_replace_args *args);
30int btrfs_dev_replace_start(struct btrfs_fs_info *fs_info, char *tgtdev_name, 30int btrfs_dev_replace_start(struct btrfs_fs_info *fs_info,
31 u64 srcdevid, char *srcdev_name, int read_src); 31 const char *tgtdev_name, u64 srcdevid, const char *srcdev_name,
32 int read_src);
32void btrfs_dev_replace_status(struct btrfs_fs_info *fs_info, 33void btrfs_dev_replace_status(struct btrfs_fs_info *fs_info,
33 struct btrfs_ioctl_dev_replace_args *args); 34 struct btrfs_ioctl_dev_replace_args *args);
34int btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info, 35int btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info,
diff --git a/fs/btrfs/dir-item.c b/fs/btrfs/dir-item.c
index 724504a2d7ac..60a750678a82 100644
--- a/fs/btrfs/dir-item.c
+++ b/fs/btrfs/dir-item.c
@@ -80,7 +80,8 @@ int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
80 struct extent_buffer *leaf; 80 struct extent_buffer *leaf;
81 u32 data_size; 81 u32 data_size;
82 82
83 BUG_ON(name_len + data_len > BTRFS_MAX_XATTR_SIZE(root->fs_info)); 83 if (name_len + data_len > BTRFS_MAX_XATTR_SIZE(root->fs_info))
84 return -ENOSPC;
84 85
85 key.objectid = objectid; 86 key.objectid = objectid;
86 key.type = BTRFS_XATTR_ITEM_KEY; 87 key.type = BTRFS_XATTR_ITEM_KEY;
@@ -120,7 +121,7 @@ int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
120 */ 121 */
121int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root 122int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
122 *root, const char *name, int name_len, 123 *root, const char *name, int name_len,
123 struct inode *dir, struct btrfs_key *location, 124 struct btrfs_inode *dir, struct btrfs_key *location,
124 u8 type, u64 index) 125 u8 type, u64 index)
125{ 126{
126 int ret = 0; 127 int ret = 0;
@@ -133,7 +134,7 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
133 struct btrfs_disk_key disk_key; 134 struct btrfs_disk_key disk_key;
134 u32 data_size; 135 u32 data_size;
135 136
136 key.objectid = btrfs_ino(BTRFS_I(dir)); 137 key.objectid = btrfs_ino(dir);
137 key.type = BTRFS_DIR_ITEM_KEY; 138 key.type = BTRFS_DIR_ITEM_KEY;
138 key.offset = btrfs_name_hash(name, name_len); 139 key.offset = btrfs_name_hash(name, name_len);
139 140
@@ -174,7 +175,7 @@ second_insert:
174 btrfs_release_path(path); 175 btrfs_release_path(path);
175 176
176 ret2 = btrfs_insert_delayed_dir_index(trans, root->fs_info, name, 177 ret2 = btrfs_insert_delayed_dir_index(trans, root->fs_info, name,
177 name_len, BTRFS_I(dir), &disk_key, type, index); 178 name_len, dir, &disk_key, type, index);
178out_free: 179out_free:
179 btrfs_free_path(path); 180 btrfs_free_path(path);
180 if (ret) 181 if (ret)
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 207db0270b15..08b74daf35d0 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -219,12 +219,12 @@ void btrfs_set_buffer_lockdep_class(u64 objectid, struct extent_buffer *eb,
219 * extents on the btree inode are pretty simple, there's one extent 219 * extents on the btree inode are pretty simple, there's one extent
220 * that covers the entire device 220 * that covers the entire device
221 */ 221 */
222static struct extent_map *btree_get_extent(struct inode *inode, 222static struct extent_map *btree_get_extent(struct btrfs_inode *inode,
223 struct page *page, size_t pg_offset, u64 start, u64 len, 223 struct page *page, size_t pg_offset, u64 start, u64 len,
224 int create) 224 int create)
225{ 225{
226 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 226 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
227 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 227 struct extent_map_tree *em_tree = &inode->extent_tree;
228 struct extent_map *em; 228 struct extent_map *em;
229 int ret; 229 int ret;
230 230
@@ -265,7 +265,7 @@ out:
265 return em; 265 return em;
266} 266}
267 267
268u32 btrfs_csum_data(char *data, u32 seed, size_t len) 268u32 btrfs_csum_data(const char *data, u32 seed, size_t len)
269{ 269{
270 return btrfs_crc32c(seed, data, len); 270 return btrfs_crc32c(seed, data, len);
271} 271}
@@ -2205,11 +2205,9 @@ static void btrfs_stop_all_workers(struct btrfs_fs_info *fs_info)
2205 btrfs_destroy_workqueue(fs_info->delalloc_workers); 2205 btrfs_destroy_workqueue(fs_info->delalloc_workers);
2206 btrfs_destroy_workqueue(fs_info->workers); 2206 btrfs_destroy_workqueue(fs_info->workers);
2207 btrfs_destroy_workqueue(fs_info->endio_workers); 2207 btrfs_destroy_workqueue(fs_info->endio_workers);
2208 btrfs_destroy_workqueue(fs_info->endio_meta_workers);
2209 btrfs_destroy_workqueue(fs_info->endio_raid56_workers); 2208 btrfs_destroy_workqueue(fs_info->endio_raid56_workers);
2210 btrfs_destroy_workqueue(fs_info->endio_repair_workers); 2209 btrfs_destroy_workqueue(fs_info->endio_repair_workers);
2211 btrfs_destroy_workqueue(fs_info->rmw_workers); 2210 btrfs_destroy_workqueue(fs_info->rmw_workers);
2212 btrfs_destroy_workqueue(fs_info->endio_meta_write_workers);
2213 btrfs_destroy_workqueue(fs_info->endio_write_workers); 2211 btrfs_destroy_workqueue(fs_info->endio_write_workers);
2214 btrfs_destroy_workqueue(fs_info->endio_freespace_worker); 2212 btrfs_destroy_workqueue(fs_info->endio_freespace_worker);
2215 btrfs_destroy_workqueue(fs_info->submit_workers); 2213 btrfs_destroy_workqueue(fs_info->submit_workers);
@@ -2219,6 +2217,13 @@ static void btrfs_stop_all_workers(struct btrfs_fs_info *fs_info)
2219 btrfs_destroy_workqueue(fs_info->flush_workers); 2217 btrfs_destroy_workqueue(fs_info->flush_workers);
2220 btrfs_destroy_workqueue(fs_info->qgroup_rescan_workers); 2218 btrfs_destroy_workqueue(fs_info->qgroup_rescan_workers);
2221 btrfs_destroy_workqueue(fs_info->extent_workers); 2219 btrfs_destroy_workqueue(fs_info->extent_workers);
2220 /*
2221 * Now that all other work queues are destroyed, we can safely destroy
2222 * the queues used for metadata I/O, since tasks from those other work
2223 * queues can do metadata I/O operations.
2224 */
2225 btrfs_destroy_workqueue(fs_info->endio_meta_workers);
2226 btrfs_destroy_workqueue(fs_info->endio_meta_write_workers);
2222} 2227}
2223 2228
2224static void free_root_extent_buffers(struct btrfs_root *root) 2229static void free_root_extent_buffers(struct btrfs_root *root)
@@ -3261,7 +3266,6 @@ fail_fsdev_sysfs:
3261 3266
3262fail_block_groups: 3267fail_block_groups:
3263 btrfs_put_block_group_cache(fs_info); 3268 btrfs_put_block_group_cache(fs_info);
3264 btrfs_free_block_groups(fs_info);
3265 3269
3266fail_tree_roots: 3270fail_tree_roots:
3267 free_root_pointers(fs_info, 1); 3271 free_root_pointers(fs_info, 1);
@@ -3269,6 +3273,7 @@ fail_tree_roots:
3269 3273
3270fail_sb_buffer: 3274fail_sb_buffer:
3271 btrfs_stop_all_workers(fs_info); 3275 btrfs_stop_all_workers(fs_info);
3276 btrfs_free_block_groups(fs_info);
3272fail_alloc: 3277fail_alloc:
3273fail_iput: 3278fail_iput:
3274 btrfs_mapping_tree_free(&fs_info->mapping_tree); 3279 btrfs_mapping_tree_free(&fs_info->mapping_tree);
@@ -3448,7 +3453,7 @@ static int write_dev_supers(struct btrfs_device *device,
3448 btrfs_set_super_bytenr(sb, bytenr); 3453 btrfs_set_super_bytenr(sb, bytenr);
3449 3454
3450 crc = ~(u32)0; 3455 crc = ~(u32)0;
3451 crc = btrfs_csum_data((char *)sb + 3456 crc = btrfs_csum_data((const char *)sb +
3452 BTRFS_CSUM_SIZE, crc, 3457 BTRFS_CSUM_SIZE, crc,
3453 BTRFS_SUPER_INFO_SIZE - 3458 BTRFS_SUPER_INFO_SIZE -
3454 BTRFS_CSUM_SIZE); 3459 BTRFS_CSUM_SIZE);
@@ -3977,8 +3982,6 @@ void close_ctree(struct btrfs_fs_info *fs_info)
3977 3982
3978 btrfs_put_block_group_cache(fs_info); 3983 btrfs_put_block_group_cache(fs_info);
3979 3984
3980 btrfs_free_block_groups(fs_info);
3981
3982 /* 3985 /*
3983 * we must make sure there is not any read request to 3986 * we must make sure there is not any read request to
3984 * submit after we stopping all workers. 3987 * submit after we stopping all workers.
@@ -3986,6 +3989,8 @@ void close_ctree(struct btrfs_fs_info *fs_info)
3986 invalidate_inode_pages2(fs_info->btree_inode->i_mapping); 3989 invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
3987 btrfs_stop_all_workers(fs_info); 3990 btrfs_stop_all_workers(fs_info);
3988 3991
3992 btrfs_free_block_groups(fs_info);
3993
3989 clear_bit(BTRFS_FS_OPEN, &fs_info->flags); 3994 clear_bit(BTRFS_FS_OPEN, &fs_info->flags);
3990 free_root_pointers(fs_info, 1); 3995 free_root_pointers(fs_info, 1);
3991 3996
@@ -4653,9 +4658,12 @@ static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info)
4653} 4658}
4654 4659
4655static const struct extent_io_ops btree_extent_io_ops = { 4660static const struct extent_io_ops btree_extent_io_ops = {
4656 .readpage_end_io_hook = btree_readpage_end_io_hook, 4661 /* mandatory callbacks */
4657 .readpage_io_failed_hook = btree_io_failed_hook,
4658 .submit_bio_hook = btree_submit_bio_hook, 4662 .submit_bio_hook = btree_submit_bio_hook,
4663 .readpage_end_io_hook = btree_readpage_end_io_hook,
4659 /* note we're sharing with inode.c for the merge bio hook */ 4664 /* note we're sharing with inode.c for the merge bio hook */
4660 .merge_bio_hook = btrfs_merge_bio_hook, 4665 .merge_bio_hook = btrfs_merge_bio_hook,
4666 .readpage_io_failed_hook = btree_io_failed_hook,
4667
4668 /* optional callbacks */
4661}; 4669};
diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h
index 0be2d4fe705b..2e0ec29bfd69 100644
--- a/fs/btrfs/disk-io.h
+++ b/fs/btrfs/disk-io.h
@@ -116,7 +116,7 @@ void btrfs_mark_buffer_dirty(struct extent_buffer *buf);
116int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid, 116int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
117 int atomic); 117 int atomic);
118int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid); 118int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid);
119u32 btrfs_csum_data(char *data, u32 seed, size_t len); 119u32 btrfs_csum_data(const char *data, u32 seed, size_t len);
120void btrfs_csum_final(u32 crc, u8 *result); 120void btrfs_csum_final(u32 crc, u8 *result);
121int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio, 121int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
122 enum btrfs_wq_endio_type metadata); 122 enum btrfs_wq_endio_type metadata);
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index c35b96633554..60794658ffd8 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -4135,10 +4135,10 @@ static u64 btrfs_space_info_used(struct btrfs_space_info *s_info,
4135 (may_use_included ? s_info->bytes_may_use : 0); 4135 (may_use_included ? s_info->bytes_may_use : 0);
4136} 4136}
4137 4137
4138int btrfs_alloc_data_chunk_ondemand(struct inode *inode, u64 bytes) 4138int btrfs_alloc_data_chunk_ondemand(struct btrfs_inode *inode, u64 bytes)
4139{ 4139{
4140 struct btrfs_space_info *data_sinfo; 4140 struct btrfs_space_info *data_sinfo;
4141 struct btrfs_root *root = BTRFS_I(inode)->root; 4141 struct btrfs_root *root = inode->root;
4142 struct btrfs_fs_info *fs_info = root->fs_info; 4142 struct btrfs_fs_info *fs_info = root->fs_info;
4143 u64 used; 4143 u64 used;
4144 int ret = 0; 4144 int ret = 0;
@@ -4281,7 +4281,7 @@ int btrfs_check_data_free_space(struct inode *inode, u64 start, u64 len)
4281 round_down(start, fs_info->sectorsize); 4281 round_down(start, fs_info->sectorsize);
4282 start = round_down(start, fs_info->sectorsize); 4282 start = round_down(start, fs_info->sectorsize);
4283 4283
4284 ret = btrfs_alloc_data_chunk_ondemand(inode, len); 4284 ret = btrfs_alloc_data_chunk_ondemand(BTRFS_I(inode), len);
4285 if (ret < 0) 4285 if (ret < 0)
4286 return ret; 4286 return ret;
4287 4287
@@ -5742,10 +5742,10 @@ void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans)
5742 5742
5743/* Can only return 0 or -ENOSPC */ 5743/* Can only return 0 or -ENOSPC */
5744int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans, 5744int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
5745 struct inode *inode) 5745 struct btrfs_inode *inode)
5746{ 5746{
5747 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 5747 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
5748 struct btrfs_root *root = BTRFS_I(inode)->root; 5748 struct btrfs_root *root = inode->root;
5749 /* 5749 /*
5750 * We always use trans->block_rsv here as we will have reserved space 5750 * We always use trans->block_rsv here as we will have reserved space
5751 * for our orphan when starting the transaction, using get_block_rsv() 5751 * for our orphan when starting the transaction, using get_block_rsv()
@@ -5762,19 +5762,19 @@ int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
5762 */ 5762 */
5763 u64 num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1); 5763 u64 num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1);
5764 5764
5765 trace_btrfs_space_reservation(fs_info, "orphan", 5765 trace_btrfs_space_reservation(fs_info, "orphan", btrfs_ino(inode),
5766 btrfs_ino(BTRFS_I(inode)), num_bytes, 1); 5766 num_bytes, 1);
5767 return btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes, 1); 5767 return btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes, 1);
5768} 5768}
5769 5769
5770void btrfs_orphan_release_metadata(struct inode *inode) 5770void btrfs_orphan_release_metadata(struct btrfs_inode *inode)
5771{ 5771{
5772 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 5772 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
5773 struct btrfs_root *root = BTRFS_I(inode)->root; 5773 struct btrfs_root *root = inode->root;
5774 u64 num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1); 5774 u64 num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1);
5775 5775
5776 trace_btrfs_space_reservation(fs_info, "orphan", 5776 trace_btrfs_space_reservation(fs_info, "orphan", btrfs_ino(inode),
5777 btrfs_ino(BTRFS_I(inode)), num_bytes, 0); 5777 num_bytes, 0);
5778 btrfs_block_rsv_release(fs_info, root->orphan_block_rsv, num_bytes); 5778 btrfs_block_rsv_release(fs_info, root->orphan_block_rsv, num_bytes);
5779} 5779}
5780 5780
@@ -5846,7 +5846,8 @@ void btrfs_subvolume_release_metadata(struct btrfs_fs_info *fs_info,
5846 * reserved extents that need to be freed. This must be called with 5846 * reserved extents that need to be freed. This must be called with
5847 * BTRFS_I(inode)->lock held. 5847 * BTRFS_I(inode)->lock held.
5848 */ 5848 */
5849static unsigned drop_outstanding_extent(struct inode *inode, u64 num_bytes) 5849static unsigned drop_outstanding_extent(struct btrfs_inode *inode,
5850 u64 num_bytes)
5850{ 5851{
5851 unsigned drop_inode_space = 0; 5852 unsigned drop_inode_space = 0;
5852 unsigned dropped_extents = 0; 5853 unsigned dropped_extents = 0;
@@ -5854,25 +5855,23 @@ static unsigned drop_outstanding_extent(struct inode *inode, u64 num_bytes)
5854 5855
5855 num_extents = count_max_extents(num_bytes); 5856 num_extents = count_max_extents(num_bytes);
5856 ASSERT(num_extents); 5857 ASSERT(num_extents);
5857 ASSERT(BTRFS_I(inode)->outstanding_extents >= num_extents); 5858 ASSERT(inode->outstanding_extents >= num_extents);
5858 BTRFS_I(inode)->outstanding_extents -= num_extents; 5859 inode->outstanding_extents -= num_extents;
5859 5860
5860 if (BTRFS_I(inode)->outstanding_extents == 0 && 5861 if (inode->outstanding_extents == 0 &&
5861 test_and_clear_bit(BTRFS_INODE_DELALLOC_META_RESERVED, 5862 test_and_clear_bit(BTRFS_INODE_DELALLOC_META_RESERVED,
5862 &BTRFS_I(inode)->runtime_flags)) 5863 &inode->runtime_flags))
5863 drop_inode_space = 1; 5864 drop_inode_space = 1;
5864 5865
5865 /* 5866 /*
5866 * If we have more or the same amount of outstanding extents than we have 5867 * If we have more or the same amount of outstanding extents than we have
5867 * reserved then we need to leave the reserved extents count alone. 5868 * reserved then we need to leave the reserved extents count alone.
5868 */ 5869 */
5869 if (BTRFS_I(inode)->outstanding_extents >= 5870 if (inode->outstanding_extents >= inode->reserved_extents)
5870 BTRFS_I(inode)->reserved_extents)
5871 return drop_inode_space; 5871 return drop_inode_space;
5872 5872
5873 dropped_extents = BTRFS_I(inode)->reserved_extents - 5873 dropped_extents = inode->reserved_extents - inode->outstanding_extents;
5874 BTRFS_I(inode)->outstanding_extents; 5874 inode->reserved_extents -= dropped_extents;
5875 BTRFS_I(inode)->reserved_extents -= dropped_extents;
5876 return dropped_extents + drop_inode_space; 5875 return dropped_extents + drop_inode_space;
5877} 5876}
5878 5877
@@ -5894,24 +5893,21 @@ static unsigned drop_outstanding_extent(struct inode *inode, u64 num_bytes)
5894 * 5893 *
5895 * This must be called with BTRFS_I(inode)->lock held. 5894 * This must be called with BTRFS_I(inode)->lock held.
5896 */ 5895 */
5897static u64 calc_csum_metadata_size(struct inode *inode, u64 num_bytes, 5896static u64 calc_csum_metadata_size(struct btrfs_inode *inode, u64 num_bytes,
5898 int reserve) 5897 int reserve)
5899{ 5898{
5900 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 5899 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
5901 u64 old_csums, num_csums; 5900 u64 old_csums, num_csums;
5902 5901
5903 if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM && 5902 if (inode->flags & BTRFS_INODE_NODATASUM && inode->csum_bytes == 0)
5904 BTRFS_I(inode)->csum_bytes == 0)
5905 return 0; 5903 return 0;
5906 5904
5907 old_csums = btrfs_csum_bytes_to_leaves(fs_info, 5905 old_csums = btrfs_csum_bytes_to_leaves(fs_info, inode->csum_bytes);
5908 BTRFS_I(inode)->csum_bytes);
5909 if (reserve) 5906 if (reserve)
5910 BTRFS_I(inode)->csum_bytes += num_bytes; 5907 inode->csum_bytes += num_bytes;
5911 else 5908 else
5912 BTRFS_I(inode)->csum_bytes -= num_bytes; 5909 inode->csum_bytes -= num_bytes;
5913 num_csums = btrfs_csum_bytes_to_leaves(fs_info, 5910 num_csums = btrfs_csum_bytes_to_leaves(fs_info, inode->csum_bytes);
5914 BTRFS_I(inode)->csum_bytes);
5915 5911
5916 /* No change, no need to reserve more */ 5912 /* No change, no need to reserve more */
5917 if (old_csums == num_csums) 5913 if (old_csums == num_csums)
@@ -5924,10 +5920,10 @@ static u64 calc_csum_metadata_size(struct inode *inode, u64 num_bytes,
5924 return btrfs_calc_trans_metadata_size(fs_info, old_csums - num_csums); 5920 return btrfs_calc_trans_metadata_size(fs_info, old_csums - num_csums);
5925} 5921}
5926 5922
5927int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes) 5923int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes)
5928{ 5924{
5929 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 5925 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
5930 struct btrfs_root *root = BTRFS_I(inode)->root; 5926 struct btrfs_root *root = inode->root;
5931 struct btrfs_block_rsv *block_rsv = &fs_info->delalloc_block_rsv; 5927 struct btrfs_block_rsv *block_rsv = &fs_info->delalloc_block_rsv;
5932 u64 to_reserve = 0; 5928 u64 to_reserve = 0;
5933 u64 csum_bytes; 5929 u64 csum_bytes;
@@ -5959,25 +5955,24 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
5959 schedule_timeout(1); 5955 schedule_timeout(1);
5960 5956
5961 if (delalloc_lock) 5957 if (delalloc_lock)
5962 mutex_lock(&BTRFS_I(inode)->delalloc_mutex); 5958 mutex_lock(&inode->delalloc_mutex);
5963 5959
5964 num_bytes = ALIGN(num_bytes, fs_info->sectorsize); 5960 num_bytes = ALIGN(num_bytes, fs_info->sectorsize);
5965 5961
5966 spin_lock(&BTRFS_I(inode)->lock); 5962 spin_lock(&inode->lock);
5967 nr_extents = count_max_extents(num_bytes); 5963 nr_extents = count_max_extents(num_bytes);
5968 BTRFS_I(inode)->outstanding_extents += nr_extents; 5964 inode->outstanding_extents += nr_extents;
5969 5965
5970 nr_extents = 0; 5966 nr_extents = 0;
5971 if (BTRFS_I(inode)->outstanding_extents > 5967 if (inode->outstanding_extents > inode->reserved_extents)
5972 BTRFS_I(inode)->reserved_extents) 5968 nr_extents += inode->outstanding_extents -
5973 nr_extents += BTRFS_I(inode)->outstanding_extents - 5969 inode->reserved_extents;
5974 BTRFS_I(inode)->reserved_extents;
5975 5970
5976 /* We always want to reserve a slot for updating the inode. */ 5971 /* We always want to reserve a slot for updating the inode. */
5977 to_reserve = btrfs_calc_trans_metadata_size(fs_info, nr_extents + 1); 5972 to_reserve = btrfs_calc_trans_metadata_size(fs_info, nr_extents + 1);
5978 to_reserve += calc_csum_metadata_size(inode, num_bytes, 1); 5973 to_reserve += calc_csum_metadata_size(inode, num_bytes, 1);
5979 csum_bytes = BTRFS_I(inode)->csum_bytes; 5974 csum_bytes = inode->csum_bytes;
5980 spin_unlock(&BTRFS_I(inode)->lock); 5975 spin_unlock(&inode->lock);
5981 5976
5982 if (test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) { 5977 if (test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) {
5983 ret = btrfs_qgroup_reserve_meta(root, 5978 ret = btrfs_qgroup_reserve_meta(root,
@@ -5993,38 +5988,38 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
5993 goto out_fail; 5988 goto out_fail;
5994 } 5989 }
5995 5990
5996 spin_lock(&BTRFS_I(inode)->lock); 5991 spin_lock(&inode->lock);
5997 if (test_and_set_bit(BTRFS_INODE_DELALLOC_META_RESERVED, 5992 if (test_and_set_bit(BTRFS_INODE_DELALLOC_META_RESERVED,
5998 &BTRFS_I(inode)->runtime_flags)) { 5993 &inode->runtime_flags)) {
5999 to_reserve -= btrfs_calc_trans_metadata_size(fs_info, 1); 5994 to_reserve -= btrfs_calc_trans_metadata_size(fs_info, 1);
6000 release_extra = true; 5995 release_extra = true;
6001 } 5996 }
6002 BTRFS_I(inode)->reserved_extents += nr_extents; 5997 inode->reserved_extents += nr_extents;
6003 spin_unlock(&BTRFS_I(inode)->lock); 5998 spin_unlock(&inode->lock);
6004 5999
6005 if (delalloc_lock) 6000 if (delalloc_lock)
6006 mutex_unlock(&BTRFS_I(inode)->delalloc_mutex); 6001 mutex_unlock(&inode->delalloc_mutex);
6007 6002
6008 if (to_reserve) 6003 if (to_reserve)
6009 trace_btrfs_space_reservation(fs_info, "delalloc", 6004 trace_btrfs_space_reservation(fs_info, "delalloc",
6010 btrfs_ino(BTRFS_I(inode)), to_reserve, 1); 6005 btrfs_ino(inode), to_reserve, 1);
6011 if (release_extra) 6006 if (release_extra)
6012 btrfs_block_rsv_release(fs_info, block_rsv, 6007 btrfs_block_rsv_release(fs_info, block_rsv,
6013 btrfs_calc_trans_metadata_size(fs_info, 1)); 6008 btrfs_calc_trans_metadata_size(fs_info, 1));
6014 return 0; 6009 return 0;
6015 6010
6016out_fail: 6011out_fail:
6017 spin_lock(&BTRFS_I(inode)->lock); 6012 spin_lock(&inode->lock);
6018 dropped = drop_outstanding_extent(inode, num_bytes); 6013 dropped = drop_outstanding_extent(inode, num_bytes);
6019 /* 6014 /*
6020 * If the inodes csum_bytes is the same as the original 6015 * If the inodes csum_bytes is the same as the original
6021 * csum_bytes then we know we haven't raced with any free()ers 6016 * csum_bytes then we know we haven't raced with any free()ers
6022 * so we can just reduce our inodes csum bytes and carry on. 6017 * so we can just reduce our inodes csum bytes and carry on.
6023 */ 6018 */
6024 if (BTRFS_I(inode)->csum_bytes == csum_bytes) { 6019 if (inode->csum_bytes == csum_bytes) {
6025 calc_csum_metadata_size(inode, num_bytes, 0); 6020 calc_csum_metadata_size(inode, num_bytes, 0);
6026 } else { 6021 } else {
6027 u64 orig_csum_bytes = BTRFS_I(inode)->csum_bytes; 6022 u64 orig_csum_bytes = inode->csum_bytes;
6028 u64 bytes; 6023 u64 bytes;
6029 6024
6030 /* 6025 /*
@@ -6035,8 +6030,8 @@ out_fail:
6035 * number of bytes that were freed while we were trying our 6030 * number of bytes that were freed while we were trying our
6036 * reservation. 6031 * reservation.
6037 */ 6032 */
6038 bytes = csum_bytes - BTRFS_I(inode)->csum_bytes; 6033 bytes = csum_bytes - inode->csum_bytes;
6039 BTRFS_I(inode)->csum_bytes = csum_bytes; 6034 inode->csum_bytes = csum_bytes;
6040 to_free = calc_csum_metadata_size(inode, bytes, 0); 6035 to_free = calc_csum_metadata_size(inode, bytes, 0);
6041 6036
6042 6037
@@ -6045,7 +6040,7 @@ out_fail:
6045 * been making this reservation and our ->csum_bytes were not 6040 * been making this reservation and our ->csum_bytes were not
6046 * artificially inflated. 6041 * artificially inflated.
6047 */ 6042 */
6048 BTRFS_I(inode)->csum_bytes = csum_bytes - num_bytes; 6043 inode->csum_bytes = csum_bytes - num_bytes;
6049 bytes = csum_bytes - orig_csum_bytes; 6044 bytes = csum_bytes - orig_csum_bytes;
6050 bytes = calc_csum_metadata_size(inode, bytes, 0); 6045 bytes = calc_csum_metadata_size(inode, bytes, 0);
6051 6046
@@ -6057,23 +6052,23 @@ out_fail:
6057 * need to do anything, the other free-ers did the correct 6052 * need to do anything, the other free-ers did the correct
6058 * thing. 6053 * thing.
6059 */ 6054 */
6060 BTRFS_I(inode)->csum_bytes = orig_csum_bytes - num_bytes; 6055 inode->csum_bytes = orig_csum_bytes - num_bytes;
6061 if (bytes > to_free) 6056 if (bytes > to_free)
6062 to_free = bytes - to_free; 6057 to_free = bytes - to_free;
6063 else 6058 else
6064 to_free = 0; 6059 to_free = 0;
6065 } 6060 }
6066 spin_unlock(&BTRFS_I(inode)->lock); 6061 spin_unlock(&inode->lock);
6067 if (dropped) 6062 if (dropped)
6068 to_free += btrfs_calc_trans_metadata_size(fs_info, dropped); 6063 to_free += btrfs_calc_trans_metadata_size(fs_info, dropped);
6069 6064
6070 if (to_free) { 6065 if (to_free) {
6071 btrfs_block_rsv_release(fs_info, block_rsv, to_free); 6066 btrfs_block_rsv_release(fs_info, block_rsv, to_free);
6072 trace_btrfs_space_reservation(fs_info, "delalloc", 6067 trace_btrfs_space_reservation(fs_info, "delalloc",
6073 btrfs_ino(BTRFS_I(inode)), to_free, 0); 6068 btrfs_ino(inode), to_free, 0);
6074 } 6069 }
6075 if (delalloc_lock) 6070 if (delalloc_lock)
6076 mutex_unlock(&BTRFS_I(inode)->delalloc_mutex); 6071 mutex_unlock(&inode->delalloc_mutex);
6077 return ret; 6072 return ret;
6078} 6073}
6079 6074
@@ -6086,27 +6081,27 @@ out_fail:
6086 * once we complete IO for a given set of bytes to release their metadata 6081 * once we complete IO for a given set of bytes to release their metadata
6087 * reservations. 6082 * reservations.
6088 */ 6083 */
6089void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes) 6084void btrfs_delalloc_release_metadata(struct btrfs_inode *inode, u64 num_bytes)
6090{ 6085{
6091 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 6086 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
6092 u64 to_free = 0; 6087 u64 to_free = 0;
6093 unsigned dropped; 6088 unsigned dropped;
6094 6089
6095 num_bytes = ALIGN(num_bytes, fs_info->sectorsize); 6090 num_bytes = ALIGN(num_bytes, fs_info->sectorsize);
6096 spin_lock(&BTRFS_I(inode)->lock); 6091 spin_lock(&inode->lock);
6097 dropped = drop_outstanding_extent(inode, num_bytes); 6092 dropped = drop_outstanding_extent(inode, num_bytes);
6098 6093
6099 if (num_bytes) 6094 if (num_bytes)
6100 to_free = calc_csum_metadata_size(inode, num_bytes, 0); 6095 to_free = calc_csum_metadata_size(inode, num_bytes, 0);
6101 spin_unlock(&BTRFS_I(inode)->lock); 6096 spin_unlock(&inode->lock);
6102 if (dropped > 0) 6097 if (dropped > 0)
6103 to_free += btrfs_calc_trans_metadata_size(fs_info, dropped); 6098 to_free += btrfs_calc_trans_metadata_size(fs_info, dropped);
6104 6099
6105 if (btrfs_is_testing(fs_info)) 6100 if (btrfs_is_testing(fs_info))
6106 return; 6101 return;
6107 6102
6108 trace_btrfs_space_reservation(fs_info, "delalloc", 6103 trace_btrfs_space_reservation(fs_info, "delalloc", btrfs_ino(inode),
6109 btrfs_ino(BTRFS_I(inode)), to_free, 0); 6104 to_free, 0);
6110 6105
6111 btrfs_block_rsv_release(fs_info, &fs_info->delalloc_block_rsv, to_free); 6106 btrfs_block_rsv_release(fs_info, &fs_info->delalloc_block_rsv, to_free);
6112} 6107}
@@ -6141,7 +6136,7 @@ int btrfs_delalloc_reserve_space(struct inode *inode, u64 start, u64 len)
6141 ret = btrfs_check_data_free_space(inode, start, len); 6136 ret = btrfs_check_data_free_space(inode, start, len);
6142 if (ret < 0) 6137 if (ret < 0)
6143 return ret; 6138 return ret;
6144 ret = btrfs_delalloc_reserve_metadata(inode, len); 6139 ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), len);
6145 if (ret < 0) 6140 if (ret < 0)
6146 btrfs_free_reserved_data_space(inode, start, len); 6141 btrfs_free_reserved_data_space(inode, start, len);
6147 return ret; 6142 return ret;
@@ -6164,7 +6159,7 @@ int btrfs_delalloc_reserve_space(struct inode *inode, u64 start, u64 len)
6164 */ 6159 */
6165void btrfs_delalloc_release_space(struct inode *inode, u64 start, u64 len) 6160void btrfs_delalloc_release_space(struct inode *inode, u64 start, u64 len)
6166{ 6161{
6167 btrfs_delalloc_release_metadata(inode, len); 6162 btrfs_delalloc_release_metadata(BTRFS_I(inode), len);
6168 btrfs_free_reserved_data_space(inode, start, len); 6163 btrfs_free_reserved_data_space(inode, start, len);
6169} 6164}
6170 6165
@@ -9740,6 +9735,11 @@ void btrfs_put_block_group_cache(struct btrfs_fs_info *info)
9740 } 9735 }
9741} 9736}
9742 9737
9738/*
9739 * Must be called only after stopping all workers, since we could have block
9740 * group caching kthreads running, and therefore they could race with us if we
9741 * freed the block groups before stopping them.
9742 */
9743int btrfs_free_block_groups(struct btrfs_fs_info *info) 9743int btrfs_free_block_groups(struct btrfs_fs_info *info)
9744{ 9744{
9745 struct btrfs_block_group_cache *block_group; 9745 struct btrfs_block_group_cache *block_group;
@@ -9779,9 +9779,6 @@ int btrfs_free_block_groups(struct btrfs_fs_info *info)
9779 list_del(&block_group->list); 9779 list_del(&block_group->list);
9780 up_write(&block_group->space_info->groups_sem); 9780 up_write(&block_group->space_info->groups_sem);
9781 9781
9782 if (block_group->cached == BTRFS_CACHE_STARTED)
9783 wait_block_group_cache_done(block_group);
9784
9785 /* 9782 /*
9786 * We haven't cached this block group, which means we could 9783 * We haven't cached this block group, which means we could
9787 * possibly have excluded extents on this block group. 9784 * possibly have excluded extents on this block group.
@@ -9791,6 +9788,7 @@ int btrfs_free_block_groups(struct btrfs_fs_info *info)
9791 free_excluded_extents(info, block_group); 9788 free_excluded_extents(info, block_group);
9792 9789
9793 btrfs_remove_free_space_cache(block_group); 9790 btrfs_remove_free_space_cache(block_group);
9791 ASSERT(block_group->cached != BTRFS_CACHE_STARTED);
9794 ASSERT(list_empty(&block_group->dirty_list)); 9792 ASSERT(list_empty(&block_group->dirty_list));
9795 ASSERT(list_empty(&block_group->io_list)); 9793 ASSERT(list_empty(&block_group->io_list));
9796 ASSERT(list_empty(&block_group->bg_list)); 9794 ASSERT(list_empty(&block_group->bg_list));
@@ -10342,7 +10340,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
10342 mutex_unlock(&trans->transaction->cache_write_mutex); 10340 mutex_unlock(&trans->transaction->cache_write_mutex);
10343 10341
10344 if (!IS_ERR(inode)) { 10342 if (!IS_ERR(inode)) {
10345 ret = btrfs_orphan_add(trans, inode); 10343 ret = btrfs_orphan_add(trans, BTRFS_I(inode));
10346 if (ret) { 10344 if (ret) {
10347 btrfs_add_delayed_iput(inode); 10345 btrfs_add_delayed_iput(inode);
10348 goto out; 10346 goto out;
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index d15b5ddb6732..28e81922a21c 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -428,7 +428,8 @@ static void clear_state_cb(struct extent_io_tree *tree,
428 struct extent_state *state, unsigned *bits) 428 struct extent_state *state, unsigned *bits)
429{ 429{
430 if (tree->ops && tree->ops->clear_bit_hook) 430 if (tree->ops && tree->ops->clear_bit_hook)
431 tree->ops->clear_bit_hook(tree->mapping->host, state, bits); 431 tree->ops->clear_bit_hook(BTRFS_I(tree->mapping->host),
432 state, bits);
432} 433}
433 434
434static void set_state_bits(struct extent_io_tree *tree, 435static void set_state_bits(struct extent_io_tree *tree,
@@ -1959,11 +1960,11 @@ static void check_page_uptodate(struct extent_io_tree *tree, struct page *page)
1959 SetPageUptodate(page); 1960 SetPageUptodate(page);
1960} 1961}
1961 1962
1962int free_io_failure(struct inode *inode, struct io_failure_record *rec) 1963int free_io_failure(struct btrfs_inode *inode, struct io_failure_record *rec)
1963{ 1964{
1964 int ret; 1965 int ret;
1965 int err = 0; 1966 int err = 0;
1966 struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree; 1967 struct extent_io_tree *failure_tree = &inode->io_failure_tree;
1967 1968
1968 set_state_failrec(failure_tree, rec->start, NULL); 1969 set_state_failrec(failure_tree, rec->start, NULL);
1969 ret = clear_extent_bits(failure_tree, rec->start, 1970 ret = clear_extent_bits(failure_tree, rec->start,
@@ -1972,7 +1973,7 @@ int free_io_failure(struct inode *inode, struct io_failure_record *rec)
1972 if (ret) 1973 if (ret)
1973 err = ret; 1974 err = ret;
1974 1975
1975 ret = clear_extent_bits(&BTRFS_I(inode)->io_tree, rec->start, 1976 ret = clear_extent_bits(&inode->io_tree, rec->start,
1976 rec->start + rec->len - 1, 1977 rec->start + rec->len - 1,
1977 EXTENT_DAMAGED); 1978 EXTENT_DAMAGED);
1978 if (ret && !err) 1979 if (ret && !err)
@@ -1992,10 +1993,11 @@ int free_io_failure(struct inode *inode, struct io_failure_record *rec)
1992 * currently, there can be no more than two copies of every data bit. thus, 1993 * currently, there can be no more than two copies of every data bit. thus,
1993 * exactly one rewrite is required. 1994 * exactly one rewrite is required.
1994 */ 1995 */
1995int repair_io_failure(struct inode *inode, u64 start, u64 length, u64 logical, 1996int repair_io_failure(struct btrfs_inode *inode, u64 start, u64 length,
1996 struct page *page, unsigned int pg_offset, int mirror_num) 1997 u64 logical, struct page *page,
1998 unsigned int pg_offset, int mirror_num)
1997{ 1999{
1998 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; 2000 struct btrfs_fs_info *fs_info = inode->root->fs_info;
1999 struct bio *bio; 2001 struct bio *bio;
2000 struct btrfs_device *dev; 2002 struct btrfs_device *dev;
2001 u64 map_length = 0; 2003 u64 map_length = 0;
@@ -2054,7 +2056,7 @@ int repair_io_failure(struct inode *inode, u64 start, u64 length, u64 logical,
2054 2056
2055 btrfs_info_rl_in_rcu(fs_info, 2057 btrfs_info_rl_in_rcu(fs_info,
2056 "read error corrected: ino %llu off %llu (dev %s sector %llu)", 2058 "read error corrected: ino %llu off %llu (dev %s sector %llu)",
2057 btrfs_ino(BTRFS_I(inode)), start, 2059 btrfs_ino(inode), start,
2058 rcu_str_deref(dev->name), sector); 2060 rcu_str_deref(dev->name), sector);
2059 btrfs_bio_counter_dec(fs_info); 2061 btrfs_bio_counter_dec(fs_info);
2060 bio_put(bio); 2062 bio_put(bio);
@@ -2074,7 +2076,7 @@ int repair_eb_io_failure(struct btrfs_fs_info *fs_info,
2074 for (i = 0; i < num_pages; i++) { 2076 for (i = 0; i < num_pages; i++) {
2075 struct page *p = eb->pages[i]; 2077 struct page *p = eb->pages[i];
2076 2078
2077 ret = repair_io_failure(fs_info->btree_inode, start, 2079 ret = repair_io_failure(BTRFS_I(fs_info->btree_inode), start,
2078 PAGE_SIZE, start, p, 2080 PAGE_SIZE, start, p,
2079 start - page_offset(p), mirror_num); 2081 start - page_offset(p), mirror_num);
2080 if (ret) 2082 if (ret)
@@ -2089,23 +2091,23 @@ int repair_eb_io_failure(struct btrfs_fs_info *fs_info,
2089 * each time an IO finishes, we do a fast check in the IO failure tree 2091 * each time an IO finishes, we do a fast check in the IO failure tree
2090 * to see if we need to process or clean up an io_failure_record 2092 * to see if we need to process or clean up an io_failure_record
2091 */ 2093 */
2092int clean_io_failure(struct inode *inode, u64 start, struct page *page, 2094int clean_io_failure(struct btrfs_inode *inode, u64 start, struct page *page,
2093 unsigned int pg_offset) 2095 unsigned int pg_offset)
2094{ 2096{
2095 u64 private; 2097 u64 private;
2096 struct io_failure_record *failrec; 2098 struct io_failure_record *failrec;
2097 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; 2099 struct btrfs_fs_info *fs_info = inode->root->fs_info;
2098 struct extent_state *state; 2100 struct extent_state *state;
2099 int num_copies; 2101 int num_copies;
2100 int ret; 2102 int ret;
2101 2103
2102 private = 0; 2104 private = 0;
2103 ret = count_range_bits(&BTRFS_I(inode)->io_failure_tree, &private, 2105 ret = count_range_bits(&inode->io_failure_tree, &private,
2104 (u64)-1, 1, EXTENT_DIRTY, 0); 2106 (u64)-1, 1, EXTENT_DIRTY, 0);
2105 if (!ret) 2107 if (!ret)
2106 return 0; 2108 return 0;
2107 2109
2108 ret = get_state_failrec(&BTRFS_I(inode)->io_failure_tree, start, 2110 ret = get_state_failrec(&inode->io_failure_tree, start,
2109 &failrec); 2111 &failrec);
2110 if (ret) 2112 if (ret)
2111 return 0; 2113 return 0;
@@ -2122,11 +2124,11 @@ int clean_io_failure(struct inode *inode, u64 start, struct page *page,
2122 if (fs_info->sb->s_flags & MS_RDONLY) 2124 if (fs_info->sb->s_flags & MS_RDONLY)
2123 goto out; 2125 goto out;
2124 2126
2125 spin_lock(&BTRFS_I(inode)->io_tree.lock); 2127 spin_lock(&inode->io_tree.lock);
2126 state = find_first_extent_bit_state(&BTRFS_I(inode)->io_tree, 2128 state = find_first_extent_bit_state(&inode->io_tree,
2127 failrec->start, 2129 failrec->start,
2128 EXTENT_LOCKED); 2130 EXTENT_LOCKED);
2129 spin_unlock(&BTRFS_I(inode)->io_tree.lock); 2131 spin_unlock(&inode->io_tree.lock);
2130 2132
2131 if (state && state->start <= failrec->start && 2133 if (state && state->start <= failrec->start &&
2132 state->end >= failrec->start + failrec->len - 1) { 2134 state->end >= failrec->start + failrec->len - 1) {
@@ -2151,9 +2153,9 @@ out:
2151 * - under ordered extent 2153 * - under ordered extent
2152 * - the inode is freeing 2154 * - the inode is freeing
2153 */ 2155 */
2154void btrfs_free_io_failure_record(struct inode *inode, u64 start, u64 end) 2156void btrfs_free_io_failure_record(struct btrfs_inode *inode, u64 start, u64 end)
2155{ 2157{
2156 struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree; 2158 struct extent_io_tree *failure_tree = &inode->io_failure_tree;
2157 struct io_failure_record *failrec; 2159 struct io_failure_record *failrec;
2158 struct extent_state *state, *next; 2160 struct extent_state *state, *next;
2159 2161
@@ -2393,7 +2395,7 @@ static int bio_readpage_error(struct bio *failed_bio, u64 phy_offset,
2393 2395
2394 ret = btrfs_check_repairable(inode, failed_bio, failrec, failed_mirror); 2396 ret = btrfs_check_repairable(inode, failed_bio, failrec, failed_mirror);
2395 if (!ret) { 2397 if (!ret) {
2396 free_io_failure(inode, failrec); 2398 free_io_failure(BTRFS_I(inode), failrec);
2397 return -EIO; 2399 return -EIO;
2398 } 2400 }
2399 2401
@@ -2406,7 +2408,7 @@ static int bio_readpage_error(struct bio *failed_bio, u64 phy_offset,
2406 (int)phy_offset, failed_bio->bi_end_io, 2408 (int)phy_offset, failed_bio->bi_end_io,
2407 NULL); 2409 NULL);
2408 if (!bio) { 2410 if (!bio) {
2409 free_io_failure(inode, failrec); 2411 free_io_failure(BTRFS_I(inode), failrec);
2410 return -EIO; 2412 return -EIO;
2411 } 2413 }
2412 bio_set_op_attrs(bio, REQ_OP_READ, read_mode); 2414 bio_set_op_attrs(bio, REQ_OP_READ, read_mode);
@@ -2418,7 +2420,7 @@ static int bio_readpage_error(struct bio *failed_bio, u64 phy_offset,
2418 ret = tree->ops->submit_bio_hook(inode, bio, failrec->this_mirror, 2420 ret = tree->ops->submit_bio_hook(inode, bio, failrec->this_mirror,
2419 failrec->bio_flags, 0); 2421 failrec->bio_flags, 0);
2420 if (ret) { 2422 if (ret) {
2421 free_io_failure(inode, failrec); 2423 free_io_failure(BTRFS_I(inode), failrec);
2422 bio_put(bio); 2424 bio_put(bio);
2423 } 2425 }
2424 2426
@@ -2435,12 +2437,9 @@ void end_extent_writepage(struct page *page, int err, u64 start, u64 end)
2435 2437
2436 tree = &BTRFS_I(page->mapping->host)->io_tree; 2438 tree = &BTRFS_I(page->mapping->host)->io_tree;
2437 2439
2438 if (tree->ops && tree->ops->writepage_end_io_hook) { 2440 if (tree->ops && tree->ops->writepage_end_io_hook)
2439 ret = tree->ops->writepage_end_io_hook(page, start, 2441 tree->ops->writepage_end_io_hook(page, start, end, NULL,
2440 end, NULL, uptodate); 2442 uptodate);
2441 if (ret)
2442 uptodate = 0;
2443 }
2444 2443
2445 if (!uptodate) { 2444 if (!uptodate) {
2446 ClearPageUptodate(page); 2445 ClearPageUptodate(page);
@@ -2568,21 +2567,21 @@ static void end_bio_extent_readpage(struct bio *bio)
2568 len = bvec->bv_len; 2567 len = bvec->bv_len;
2569 2568
2570 mirror = io_bio->mirror_num; 2569 mirror = io_bio->mirror_num;
2571 if (likely(uptodate && tree->ops && 2570 if (likely(uptodate && tree->ops)) {
2572 tree->ops->readpage_end_io_hook)) {
2573 ret = tree->ops->readpage_end_io_hook(io_bio, offset, 2571 ret = tree->ops->readpage_end_io_hook(io_bio, offset,
2574 page, start, end, 2572 page, start, end,
2575 mirror); 2573 mirror);
2576 if (ret) 2574 if (ret)
2577 uptodate = 0; 2575 uptodate = 0;
2578 else 2576 else
2579 clean_io_failure(inode, start, page, 0); 2577 clean_io_failure(BTRFS_I(inode), start,
2578 page, 0);
2580 } 2579 }
2581 2580
2582 if (likely(uptodate)) 2581 if (likely(uptodate))
2583 goto readpage_ok; 2582 goto readpage_ok;
2584 2583
2585 if (tree->ops && tree->ops->readpage_io_failed_hook) { 2584 if (tree->ops) {
2586 ret = tree->ops->readpage_io_failed_hook(page, mirror); 2585 ret = tree->ops->readpage_io_failed_hook(page, mirror);
2587 if (!ret && !bio->bi_error) 2586 if (!ret && !bio->bi_error)
2588 uptodate = 1; 2587 uptodate = 1;
@@ -2731,7 +2730,7 @@ static int __must_check submit_one_bio(struct bio *bio, int mirror_num,
2731 bio->bi_private = NULL; 2730 bio->bi_private = NULL;
2732 bio_get(bio); 2731 bio_get(bio);
2733 2732
2734 if (tree->ops && tree->ops->submit_bio_hook) 2733 if (tree->ops)
2735 ret = tree->ops->submit_bio_hook(page->mapping->host, bio, 2734 ret = tree->ops->submit_bio_hook(page->mapping->host, bio,
2736 mirror_num, bio_flags, start); 2735 mirror_num, bio_flags, start);
2737 else 2736 else
@@ -2746,7 +2745,7 @@ static int merge_bio(struct extent_io_tree *tree, struct page *page,
2746 unsigned long bio_flags) 2745 unsigned long bio_flags)
2747{ 2746{
2748 int ret = 0; 2747 int ret = 0;
2749 if (tree->ops && tree->ops->merge_bio_hook) 2748 if (tree->ops)
2750 ret = tree->ops->merge_bio_hook(page, offset, size, bio, 2749 ret = tree->ops->merge_bio_hook(page, offset, size, bio,
2751 bio_flags); 2750 bio_flags);
2752 return ret; 2751 return ret;
@@ -2857,7 +2856,7 @@ __get_extent_map(struct inode *inode, struct page *page, size_t pg_offset,
2857 *em_cached = NULL; 2856 *em_cached = NULL;
2858 } 2857 }
2859 2858
2860 em = get_extent(inode, page, pg_offset, start, len, 0); 2859 em = get_extent(BTRFS_I(inode), page, pg_offset, start, len, 0);
2861 if (em_cached && !IS_ERR_OR_NULL(em)) { 2860 if (em_cached && !IS_ERR_OR_NULL(em)) {
2862 BUG_ON(*em_cached); 2861 BUG_ON(*em_cached);
2863 atomic_inc(&em->refs); 2862 atomic_inc(&em->refs);
@@ -3101,7 +3100,7 @@ static inline void __do_contiguous_readpages(struct extent_io_tree *tree,
3101 inode = pages[0]->mapping->host; 3100 inode = pages[0]->mapping->host;
3102 while (1) { 3101 while (1) {
3103 lock_extent(tree, start, end); 3102 lock_extent(tree, start, end);
3104 ordered = btrfs_lookup_ordered_range(inode, start, 3103 ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), start,
3105 end - start + 1); 3104 end - start + 1);
3106 if (!ordered) 3105 if (!ordered)
3107 break; 3106 break;
@@ -3173,7 +3172,7 @@ static int __extent_read_full_page(struct extent_io_tree *tree,
3173 3172
3174 while (1) { 3173 while (1) {
3175 lock_extent(tree, start, end); 3174 lock_extent(tree, start, end);
3176 ordered = btrfs_lookup_ordered_range(inode, start, 3175 ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), start,
3177 PAGE_SIZE); 3176 PAGE_SIZE);
3178 if (!ordered) 3177 if (!ordered)
3179 break; 3178 break;
@@ -3370,7 +3369,7 @@ static noinline_for_stack int __extent_writepage_io(struct inode *inode,
3370 page_end, NULL, 1); 3369 page_end, NULL, 1);
3371 break; 3370 break;
3372 } 3371 }
3373 em = epd->get_extent(inode, page, pg_offset, cur, 3372 em = epd->get_extent(BTRFS_I(inode), page, pg_offset, cur,
3374 end - cur + 1, 1); 3373 end - cur + 1, 1);
3375 if (IS_ERR_OR_NULL(em)) { 3374 if (IS_ERR_OR_NULL(em)) {
3376 SetPageError(page); 3375 SetPageError(page);
@@ -4335,7 +4334,7 @@ static struct extent_map *get_extent_skip_holes(struct inode *inode,
4335 if (len == 0) 4334 if (len == 0)
4336 break; 4335 break;
4337 len = ALIGN(len, sectorsize); 4336 len = ALIGN(len, sectorsize);
4338 em = get_extent(inode, NULL, 0, offset, len, 0); 4337 em = get_extent(BTRFS_I(inode), NULL, 0, offset, len, 0);
4339 if (IS_ERR_OR_NULL(em)) 4338 if (IS_ERR_OR_NULL(em))
4340 return em; 4339 return em;
4341 4340
diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index 270d03be290e..3e4fad4a909d 100644
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -84,6 +84,7 @@ extern void le_bitmap_clear(u8 *map, unsigned int start, int len);
84 84
85struct extent_state; 85struct extent_state;
86struct btrfs_root; 86struct btrfs_root;
87struct btrfs_inode;
87struct btrfs_io_bio; 88struct btrfs_io_bio;
88struct io_failure_record; 89struct io_failure_record;
89 90
@@ -91,24 +92,34 @@ typedef int (extent_submit_bio_hook_t)(struct inode *inode, struct bio *bio,
91 int mirror_num, unsigned long bio_flags, 92 int mirror_num, unsigned long bio_flags,
92 u64 bio_offset); 93 u64 bio_offset);
93struct extent_io_ops { 94struct extent_io_ops {
94 int (*fill_delalloc)(struct inode *inode, struct page *locked_page, 95 /*
95 u64 start, u64 end, int *page_started, 96 * The following callbacks must be allways defined, the function
96 unsigned long *nr_written); 97 * pointer will be called unconditionally.
97 int (*writepage_start_hook)(struct page *page, u64 start, u64 end); 98 */
98 extent_submit_bio_hook_t *submit_bio_hook; 99 extent_submit_bio_hook_t *submit_bio_hook;
100 int (*readpage_end_io_hook)(struct btrfs_io_bio *io_bio, u64 phy_offset,
101 struct page *page, u64 start, u64 end,
102 int mirror);
99 int (*merge_bio_hook)(struct page *page, unsigned long offset, 103 int (*merge_bio_hook)(struct page *page, unsigned long offset,
100 size_t size, struct bio *bio, 104 size_t size, struct bio *bio,
101 unsigned long bio_flags); 105 unsigned long bio_flags);
102 int (*readpage_io_failed_hook)(struct page *page, int failed_mirror); 106 int (*readpage_io_failed_hook)(struct page *page, int failed_mirror);
103 int (*readpage_end_io_hook)(struct btrfs_io_bio *io_bio, u64 phy_offset, 107
104 struct page *page, u64 start, u64 end, 108 /*
105 int mirror); 109 * Optional hooks, called if the pointer is not NULL
106 int (*writepage_end_io_hook)(struct page *page, u64 start, u64 end, 110 */
111 int (*fill_delalloc)(struct inode *inode, struct page *locked_page,
112 u64 start, u64 end, int *page_started,
113 unsigned long *nr_written);
114
115 int (*writepage_start_hook)(struct page *page, u64 start, u64 end);
116 void (*writepage_end_io_hook)(struct page *page, u64 start, u64 end,
107 struct extent_state *state, int uptodate); 117 struct extent_state *state, int uptodate);
108 void (*set_bit_hook)(struct inode *inode, struct extent_state *state, 118 void (*set_bit_hook)(struct inode *inode, struct extent_state *state,
109 unsigned *bits); 119 unsigned *bits);
110 void (*clear_bit_hook)(struct inode *inode, struct extent_state *state, 120 void (*clear_bit_hook)(struct btrfs_inode *inode,
111 unsigned *bits); 121 struct extent_state *state,
122 unsigned *bits);
112 void (*merge_extent_hook)(struct inode *inode, 123 void (*merge_extent_hook)(struct inode *inode,
113 struct extent_state *new, 124 struct extent_state *new,
114 struct extent_state *other); 125 struct extent_state *other);
@@ -209,7 +220,7 @@ static inline int extent_compress_type(unsigned long bio_flags)
209 220
210struct extent_map_tree; 221struct extent_map_tree;
211 222
212typedef struct extent_map *(get_extent_t)(struct inode *inode, 223typedef struct extent_map *(get_extent_t)(struct btrfs_inode *inode,
213 struct page *page, 224 struct page *page,
214 size_t pg_offset, 225 size_t pg_offset,
215 u64 start, u64 len, 226 u64 start, u64 len,
@@ -451,12 +462,13 @@ struct bio *btrfs_io_bio_alloc(gfp_t gfp_mask, unsigned int nr_iovecs);
451struct bio *btrfs_bio_clone(struct bio *bio, gfp_t gfp_mask); 462struct bio *btrfs_bio_clone(struct bio *bio, gfp_t gfp_mask);
452 463
453struct btrfs_fs_info; 464struct btrfs_fs_info;
465struct btrfs_inode;
454 466
455int repair_io_failure(struct inode *inode, u64 start, u64 length, u64 logical, 467int repair_io_failure(struct btrfs_inode *inode, u64 start, u64 length,
456 struct page *page, unsigned int pg_offset, 468 u64 logical, struct page *page,
457 int mirror_num); 469 unsigned int pg_offset, int mirror_num);
458int clean_io_failure(struct inode *inode, u64 start, struct page *page, 470int clean_io_failure(struct btrfs_inode *inode, u64 start,
459 unsigned int pg_offset); 471 struct page *page, unsigned int pg_offset);
460void end_extent_writepage(struct page *page, int err, u64 start, u64 end); 472void end_extent_writepage(struct page *page, int err, u64 start, u64 end);
461int repair_eb_io_failure(struct btrfs_fs_info *fs_info, 473int repair_eb_io_failure(struct btrfs_fs_info *fs_info,
462 struct extent_buffer *eb, int mirror_num); 474 struct extent_buffer *eb, int mirror_num);
@@ -480,7 +492,9 @@ struct io_failure_record {
480 int in_validation; 492 int in_validation;
481}; 493};
482 494
483void btrfs_free_io_failure_record(struct inode *inode, u64 start, u64 end); 495
496void btrfs_free_io_failure_record(struct btrfs_inode *inode, u64 start,
497 u64 end);
484int btrfs_get_io_failure_record(struct inode *inode, u64 start, u64 end, 498int btrfs_get_io_failure_record(struct inode *inode, u64 start, u64 end,
485 struct io_failure_record **failrec_ret); 499 struct io_failure_record **failrec_ret);
486int btrfs_check_repairable(struct inode *inode, struct bio *failed_bio, 500int btrfs_check_repairable(struct inode *inode, struct bio *failed_bio,
@@ -489,7 +503,7 @@ struct bio *btrfs_create_repair_bio(struct inode *inode, struct bio *failed_bio,
489 struct io_failure_record *failrec, 503 struct io_failure_record *failrec,
490 struct page *page, int pg_offset, int icsum, 504 struct page *page, int pg_offset, int icsum,
491 bio_end_io_t *endio_func, void *data); 505 bio_end_io_t *endio_func, void *data);
492int free_io_failure(struct inode *inode, struct io_failure_record *rec); 506int free_io_failure(struct btrfs_inode *inode, struct io_failure_record *rec);
493#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS 507#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
494noinline u64 find_lock_delalloc_range(struct inode *inode, 508noinline u64 find_lock_delalloc_range(struct inode *inode,
495 struct extent_io_tree *tree, 509 struct extent_io_tree *tree,
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index f7b9a92ad56d..64fcb31d7163 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -214,7 +214,7 @@ static int __btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio,
214 * read from the commit root and sidestep a nasty deadlock 214 * read from the commit root and sidestep a nasty deadlock
215 * between reading the free space cache and updating the csum tree. 215 * between reading the free space cache and updating the csum tree.
216 */ 216 */
217 if (btrfs_is_free_space_inode(inode)) { 217 if (btrfs_is_free_space_inode(BTRFS_I(inode))) {
218 path->search_commit_root = 1; 218 path->search_commit_root = 1;
219 path->skip_locking = 1; 219 path->skip_locking = 1;
220 } 220 }
@@ -643,7 +643,33 @@ int btrfs_del_csums(struct btrfs_trans_handle *trans,
643 643
644 /* delete the entire item, it is inside our range */ 644 /* delete the entire item, it is inside our range */
645 if (key.offset >= bytenr && csum_end <= end_byte) { 645 if (key.offset >= bytenr && csum_end <= end_byte) {
646 ret = btrfs_del_item(trans, root, path); 646 int del_nr = 1;
647
648 /*
649 * Check how many csum items preceding this one in this
650 * leaf correspond to our range and then delete them all
651 * at once.
652 */
653 if (key.offset > bytenr && path->slots[0] > 0) {
654 int slot = path->slots[0] - 1;
655
656 while (slot >= 0) {
657 struct btrfs_key pk;
658
659 btrfs_item_key_to_cpu(leaf, &pk, slot);
660 if (pk.offset < bytenr ||
661 pk.type != BTRFS_EXTENT_CSUM_KEY ||
662 pk.objectid !=
663 BTRFS_EXTENT_CSUM_OBJECTID)
664 break;
665 path->slots[0] = slot;
666 del_nr++;
667 key.offset = pk.offset;
668 slot--;
669 }
670 }
671 ret = btrfs_del_items(trans, root, path,
672 path->slots[0], del_nr);
647 if (ret) 673 if (ret)
648 goto out; 674 goto out;
649 if (key.offset == bytenr) 675 if (key.offset == bytenr)
@@ -904,14 +930,14 @@ fail_unlock:
904 goto out; 930 goto out;
905} 931}
906 932
907void btrfs_extent_item_to_extent_map(struct inode *inode, 933void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
908 const struct btrfs_path *path, 934 const struct btrfs_path *path,
909 struct btrfs_file_extent_item *fi, 935 struct btrfs_file_extent_item *fi,
910 const bool new_inline, 936 const bool new_inline,
911 struct extent_map *em) 937 struct extent_map *em)
912{ 938{
913 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 939 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
914 struct btrfs_root *root = BTRFS_I(inode)->root; 940 struct btrfs_root *root = inode->root;
915 struct extent_buffer *leaf = path->nodes[0]; 941 struct extent_buffer *leaf = path->nodes[0];
916 const int slot = path->slots[0]; 942 const int slot = path->slots[0];
917 struct btrfs_key key; 943 struct btrfs_key key;
@@ -976,8 +1002,8 @@ void btrfs_extent_item_to_extent_map(struct inode *inode,
976 } 1002 }
977 } else { 1003 } else {
978 btrfs_err(fs_info, 1004 btrfs_err(fs_info,
979 "unknown file extent item type %d, inode %llu, offset %llu, root %llu", 1005 "unknown file extent item type %d, inode %llu, offset %llu, "
980 type, btrfs_ino(BTRFS_I(inode)), extent_start, 1006 "root %llu", type, btrfs_ino(inode), extent_start,
981 root->root_key.objectid); 1007 root->root_key.objectid);
982 } 1008 }
983} 1009}
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index c1d2a07205da..520cb7230b2d 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -92,10 +92,10 @@ static int __compare_inode_defrag(struct inode_defrag *defrag1,
92 * If an existing record is found the defrag item you 92 * If an existing record is found the defrag item you
93 * pass in is freed 93 * pass in is freed
94 */ 94 */
95static int __btrfs_add_inode_defrag(struct inode *inode, 95static int __btrfs_add_inode_defrag(struct btrfs_inode *inode,
96 struct inode_defrag *defrag) 96 struct inode_defrag *defrag)
97{ 97{
98 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 98 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
99 struct inode_defrag *entry; 99 struct inode_defrag *entry;
100 struct rb_node **p; 100 struct rb_node **p;
101 struct rb_node *parent = NULL; 101 struct rb_node *parent = NULL;
@@ -123,7 +123,7 @@ static int __btrfs_add_inode_defrag(struct inode *inode,
123 return -EEXIST; 123 return -EEXIST;
124 } 124 }
125 } 125 }
126 set_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags); 126 set_bit(BTRFS_INODE_IN_DEFRAG, &inode->runtime_flags);
127 rb_link_node(&defrag->rb_node, parent, p); 127 rb_link_node(&defrag->rb_node, parent, p);
128 rb_insert_color(&defrag->rb_node, &fs_info->defrag_inodes); 128 rb_insert_color(&defrag->rb_node, &fs_info->defrag_inodes);
129 return 0; 129 return 0;
@@ -145,10 +145,10 @@ static inline int __need_auto_defrag(struct btrfs_fs_info *fs_info)
145 * enabled 145 * enabled
146 */ 146 */
147int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans, 147int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
148 struct inode *inode) 148 struct btrfs_inode *inode)
149{ 149{
150 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 150 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
151 struct btrfs_root *root = BTRFS_I(inode)->root; 151 struct btrfs_root *root = inode->root;
152 struct inode_defrag *defrag; 152 struct inode_defrag *defrag;
153 u64 transid; 153 u64 transid;
154 int ret; 154 int ret;
@@ -156,24 +156,24 @@ int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
156 if (!__need_auto_defrag(fs_info)) 156 if (!__need_auto_defrag(fs_info))
157 return 0; 157 return 0;
158 158
159 if (test_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags)) 159 if (test_bit(BTRFS_INODE_IN_DEFRAG, &inode->runtime_flags))
160 return 0; 160 return 0;
161 161
162 if (trans) 162 if (trans)
163 transid = trans->transid; 163 transid = trans->transid;
164 else 164 else
165 transid = BTRFS_I(inode)->root->last_trans; 165 transid = inode->root->last_trans;
166 166
167 defrag = kmem_cache_zalloc(btrfs_inode_defrag_cachep, GFP_NOFS); 167 defrag = kmem_cache_zalloc(btrfs_inode_defrag_cachep, GFP_NOFS);
168 if (!defrag) 168 if (!defrag)
169 return -ENOMEM; 169 return -ENOMEM;
170 170
171 defrag->ino = btrfs_ino(BTRFS_I(inode)); 171 defrag->ino = btrfs_ino(inode);
172 defrag->transid = transid; 172 defrag->transid = transid;
173 defrag->root = root->root_key.objectid; 173 defrag->root = root->root_key.objectid;
174 174
175 spin_lock(&fs_info->defrag_inodes_lock); 175 spin_lock(&fs_info->defrag_inodes_lock);
176 if (!test_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags)) { 176 if (!test_bit(BTRFS_INODE_IN_DEFRAG, &inode->runtime_flags)) {
177 /* 177 /*
178 * If we set IN_DEFRAG flag and evict the inode from memory, 178 * If we set IN_DEFRAG flag and evict the inode from memory,
179 * and then re-read this inode, this new inode doesn't have 179 * and then re-read this inode, this new inode doesn't have
@@ -194,10 +194,10 @@ int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
194 * the same inode in the tree, we will merge them together (by 194 * the same inode in the tree, we will merge them together (by
195 * __btrfs_add_inode_defrag()) and free the one that we want to requeue. 195 * __btrfs_add_inode_defrag()) and free the one that we want to requeue.
196 */ 196 */
197static void btrfs_requeue_inode_defrag(struct inode *inode, 197static void btrfs_requeue_inode_defrag(struct btrfs_inode *inode,
198 struct inode_defrag *defrag) 198 struct inode_defrag *defrag)
199{ 199{
200 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 200 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
201 int ret; 201 int ret;
202 202
203 if (!__need_auto_defrag(fs_info)) 203 if (!__need_auto_defrag(fs_info))
@@ -334,7 +334,7 @@ static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info,
334 */ 334 */
335 if (num_defrag == BTRFS_DEFRAG_BATCH) { 335 if (num_defrag == BTRFS_DEFRAG_BATCH) {
336 defrag->last_offset = range.start; 336 defrag->last_offset = range.start;
337 btrfs_requeue_inode_defrag(inode, defrag); 337 btrfs_requeue_inode_defrag(BTRFS_I(inode), defrag);
338 } else if (defrag->last_offset && !defrag->cycled) { 338 } else if (defrag->last_offset && !defrag->cycled) {
339 /* 339 /*
340 * we didn't fill our defrag batch, but 340 * we didn't fill our defrag batch, but
@@ -343,7 +343,7 @@ static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info,
343 */ 343 */
344 defrag->last_offset = 0; 344 defrag->last_offset = 0;
345 defrag->cycled = 1; 345 defrag->cycled = 1;
346 btrfs_requeue_inode_defrag(inode, defrag); 346 btrfs_requeue_inode_defrag(BTRFS_I(inode), defrag);
347 } else { 347 } else {
348 kmem_cache_free(btrfs_inode_defrag_cachep, defrag); 348 kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
349 } 349 }
@@ -529,13 +529,13 @@ int btrfs_dirty_pages(struct inode *inode, struct page **pages,
529 * this drops all the extents in the cache that intersect the range 529 * this drops all the extents in the cache that intersect the range
530 * [start, end]. Existing extents are split as required. 530 * [start, end]. Existing extents are split as required.
531 */ 531 */
532void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end, 532void btrfs_drop_extent_cache(struct btrfs_inode *inode, u64 start, u64 end,
533 int skip_pinned) 533 int skip_pinned)
534{ 534{
535 struct extent_map *em; 535 struct extent_map *em;
536 struct extent_map *split = NULL; 536 struct extent_map *split = NULL;
537 struct extent_map *split2 = NULL; 537 struct extent_map *split2 = NULL;
538 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 538 struct extent_map_tree *em_tree = &inode->extent_tree;
539 u64 len = end - start + 1; 539 u64 len = end - start + 1;
540 u64 gen; 540 u64 gen;
541 int ret; 541 int ret;
@@ -720,7 +720,7 @@ int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
720 int leafs_visited = 0; 720 int leafs_visited = 0;
721 721
722 if (drop_cache) 722 if (drop_cache)
723 btrfs_drop_extent_cache(inode, start, end - 1, 0); 723 btrfs_drop_extent_cache(BTRFS_I(inode), start, end - 1, 0);
724 724
725 if (start >= BTRFS_I(inode)->disk_i_size && !replace_extent) 725 if (start >= BTRFS_I(inode)->disk_i_size && !replace_extent)
726 modify_tree = 0; 726 modify_tree = 0;
@@ -1082,10 +1082,10 @@ static int extent_mergeable(struct extent_buffer *leaf, int slot,
1082 * two or three. 1082 * two or three.
1083 */ 1083 */
1084int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, 1084int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
1085 struct inode *inode, u64 start, u64 end) 1085 struct btrfs_inode *inode, u64 start, u64 end)
1086{ 1086{
1087 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 1087 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
1088 struct btrfs_root *root = BTRFS_I(inode)->root; 1088 struct btrfs_root *root = inode->root;
1089 struct extent_buffer *leaf; 1089 struct extent_buffer *leaf;
1090 struct btrfs_path *path; 1090 struct btrfs_path *path;
1091 struct btrfs_file_extent_item *fi; 1091 struct btrfs_file_extent_item *fi;
@@ -1102,7 +1102,7 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
1102 int del_slot = 0; 1102 int del_slot = 0;
1103 int recow; 1103 int recow;
1104 int ret; 1104 int ret;
1105 u64 ino = btrfs_ino(BTRFS_I(inode)); 1105 u64 ino = btrfs_ino(inode);
1106 1106
1107 path = btrfs_alloc_path(); 1107 path = btrfs_alloc_path();
1108 if (!path) 1108 if (!path)
@@ -1415,13 +1415,13 @@ fail:
1415 * the other < 0 number - Something wrong happens 1415 * the other < 0 number - Something wrong happens
1416 */ 1416 */
1417static noinline int 1417static noinline int
1418lock_and_cleanup_extent_if_need(struct inode *inode, struct page **pages, 1418lock_and_cleanup_extent_if_need(struct btrfs_inode *inode, struct page **pages,
1419 size_t num_pages, loff_t pos, 1419 size_t num_pages, loff_t pos,
1420 size_t write_bytes, 1420 size_t write_bytes,
1421 u64 *lockstart, u64 *lockend, 1421 u64 *lockstart, u64 *lockend,
1422 struct extent_state **cached_state) 1422 struct extent_state **cached_state)
1423{ 1423{
1424 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 1424 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
1425 u64 start_pos; 1425 u64 start_pos;
1426 u64 last_pos; 1426 u64 last_pos;
1427 int i; 1427 int i;
@@ -1432,30 +1432,30 @@ lock_and_cleanup_extent_if_need(struct inode *inode, struct page **pages,
1432 + round_up(pos + write_bytes - start_pos, 1432 + round_up(pos + write_bytes - start_pos,
1433 fs_info->sectorsize) - 1; 1433 fs_info->sectorsize) - 1;
1434 1434
1435 if (start_pos < inode->i_size) { 1435 if (start_pos < inode->vfs_inode.i_size) {
1436 struct btrfs_ordered_extent *ordered; 1436 struct btrfs_ordered_extent *ordered;
1437 lock_extent_bits(&BTRFS_I(inode)->io_tree, 1437 lock_extent_bits(&inode->io_tree, start_pos, last_pos,
1438 start_pos, last_pos, cached_state); 1438 cached_state);
1439 ordered = btrfs_lookup_ordered_range(inode, start_pos, 1439 ordered = btrfs_lookup_ordered_range(inode, start_pos,
1440 last_pos - start_pos + 1); 1440 last_pos - start_pos + 1);
1441 if (ordered && 1441 if (ordered &&
1442 ordered->file_offset + ordered->len > start_pos && 1442 ordered->file_offset + ordered->len > start_pos &&
1443 ordered->file_offset <= last_pos) { 1443 ordered->file_offset <= last_pos) {
1444 unlock_extent_cached(&BTRFS_I(inode)->io_tree, 1444 unlock_extent_cached(&inode->io_tree, start_pos,
1445 start_pos, last_pos, 1445 last_pos, cached_state, GFP_NOFS);
1446 cached_state, GFP_NOFS);
1447 for (i = 0; i < num_pages; i++) { 1446 for (i = 0; i < num_pages; i++) {
1448 unlock_page(pages[i]); 1447 unlock_page(pages[i]);
1449 put_page(pages[i]); 1448 put_page(pages[i]);
1450 } 1449 }
1451 btrfs_start_ordered_extent(inode, ordered, 1); 1450 btrfs_start_ordered_extent(&inode->vfs_inode,
1451 ordered, 1);
1452 btrfs_put_ordered_extent(ordered); 1452 btrfs_put_ordered_extent(ordered);
1453 return -EAGAIN; 1453 return -EAGAIN;
1454 } 1454 }
1455 if (ordered) 1455 if (ordered)
1456 btrfs_put_ordered_extent(ordered); 1456 btrfs_put_ordered_extent(ordered);
1457 1457
1458 clear_extent_bit(&BTRFS_I(inode)->io_tree, start_pos, 1458 clear_extent_bit(&inode->io_tree, start_pos,
1459 last_pos, EXTENT_DIRTY | EXTENT_DELALLOC | 1459 last_pos, EXTENT_DIRTY | EXTENT_DELALLOC |
1460 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 1460 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
1461 0, 0, cached_state, GFP_NOFS); 1461 0, 0, cached_state, GFP_NOFS);
@@ -1474,11 +1474,11 @@ lock_and_cleanup_extent_if_need(struct inode *inode, struct page **pages,
1474 return ret; 1474 return ret;
1475} 1475}
1476 1476
1477static noinline int check_can_nocow(struct inode *inode, loff_t pos, 1477static noinline int check_can_nocow(struct btrfs_inode *inode, loff_t pos,
1478 size_t *write_bytes) 1478 size_t *write_bytes)
1479{ 1479{
1480 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 1480 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
1481 struct btrfs_root *root = BTRFS_I(inode)->root; 1481 struct btrfs_root *root = inode->root;
1482 struct btrfs_ordered_extent *ordered; 1482 struct btrfs_ordered_extent *ordered;
1483 u64 lockstart, lockend; 1483 u64 lockstart, lockend;
1484 u64 num_bytes; 1484 u64 num_bytes;
@@ -1493,19 +1493,20 @@ static noinline int check_can_nocow(struct inode *inode, loff_t pos,
1493 fs_info->sectorsize) - 1; 1493 fs_info->sectorsize) - 1;
1494 1494
1495 while (1) { 1495 while (1) {
1496 lock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend); 1496 lock_extent(&inode->io_tree, lockstart, lockend);
1497 ordered = btrfs_lookup_ordered_range(inode, lockstart, 1497 ordered = btrfs_lookup_ordered_range(inode, lockstart,
1498 lockend - lockstart + 1); 1498 lockend - lockstart + 1);
1499 if (!ordered) { 1499 if (!ordered) {
1500 break; 1500 break;
1501 } 1501 }
1502 unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend); 1502 unlock_extent(&inode->io_tree, lockstart, lockend);
1503 btrfs_start_ordered_extent(inode, ordered, 1); 1503 btrfs_start_ordered_extent(&inode->vfs_inode, ordered, 1);
1504 btrfs_put_ordered_extent(ordered); 1504 btrfs_put_ordered_extent(ordered);
1505 } 1505 }
1506 1506
1507 num_bytes = lockend - lockstart + 1; 1507 num_bytes = lockend - lockstart + 1;
1508 ret = can_nocow_extent(inode, lockstart, &num_bytes, NULL, NULL, NULL); 1508 ret = can_nocow_extent(&inode->vfs_inode, lockstart, &num_bytes,
1509 NULL, NULL, NULL);
1509 if (ret <= 0) { 1510 if (ret <= 0) {
1510 ret = 0; 1511 ret = 0;
1511 btrfs_end_write_no_snapshoting(root); 1512 btrfs_end_write_no_snapshoting(root);
@@ -1514,7 +1515,7 @@ static noinline int check_can_nocow(struct inode *inode, loff_t pos,
1514 num_bytes - pos + lockstart); 1515 num_bytes - pos + lockstart);
1515 } 1516 }
1516 1517
1517 unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend); 1518 unlock_extent(&inode->io_tree, lockstart, lockend);
1518 1519
1519 return ret; 1520 return ret;
1520} 1521}
@@ -1579,7 +1580,8 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
1579 if (ret < 0) { 1580 if (ret < 0) {
1580 if ((BTRFS_I(inode)->flags & (BTRFS_INODE_NODATACOW | 1581 if ((BTRFS_I(inode)->flags & (BTRFS_INODE_NODATACOW |
1581 BTRFS_INODE_PREALLOC)) && 1582 BTRFS_INODE_PREALLOC)) &&
1582 check_can_nocow(inode, pos, &write_bytes) > 0) { 1583 check_can_nocow(BTRFS_I(inode), pos,
1584 &write_bytes) > 0) {
1583 /* 1585 /*
1584 * For nodata cow case, no need to reserve 1586 * For nodata cow case, no need to reserve
1585 * data space. 1587 * data space.
@@ -1599,7 +1601,8 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
1599 } 1601 }
1600 } 1602 }
1601 1603
1602 ret = btrfs_delalloc_reserve_metadata(inode, reserve_bytes); 1604 ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode),
1605 reserve_bytes);
1603 if (ret) { 1606 if (ret) {
1604 if (!only_release_metadata) 1607 if (!only_release_metadata)
1605 btrfs_free_reserved_data_space(inode, pos, 1608 btrfs_free_reserved_data_space(inode, pos,
@@ -1623,9 +1626,9 @@ again:
1623 if (ret) 1626 if (ret)
1624 break; 1627 break;
1625 1628
1626 ret = lock_and_cleanup_extent_if_need(inode, pages, num_pages, 1629 ret = lock_and_cleanup_extent_if_need(BTRFS_I(inode), pages,
1627 pos, write_bytes, &lockstart, 1630 num_pages, pos, write_bytes, &lockstart,
1628 &lockend, &cached_state); 1631 &lockend, &cached_state);
1629 if (ret < 0) { 1632 if (ret < 0) {
1630 if (ret == -EAGAIN) 1633 if (ret == -EAGAIN)
1631 goto again; 1634 goto again;
@@ -1677,7 +1680,7 @@ again:
1677 spin_unlock(&BTRFS_I(inode)->lock); 1680 spin_unlock(&BTRFS_I(inode)->lock);
1678 } 1681 }
1679 if (only_release_metadata) { 1682 if (only_release_metadata) {
1680 btrfs_delalloc_release_metadata(inode, 1683 btrfs_delalloc_release_metadata(BTRFS_I(inode),
1681 release_bytes); 1684 release_bytes);
1682 } else { 1685 } else {
1683 u64 __pos; 1686 u64 __pos;
@@ -1738,7 +1741,8 @@ again:
1738 if (release_bytes) { 1741 if (release_bytes) {
1739 if (only_release_metadata) { 1742 if (only_release_metadata) {
1740 btrfs_end_write_no_snapshoting(root); 1743 btrfs_end_write_no_snapshoting(root);
1741 btrfs_delalloc_release_metadata(inode, release_bytes); 1744 btrfs_delalloc_release_metadata(BTRFS_I(inode),
1745 release_bytes);
1742 } else { 1746 } else {
1743 btrfs_delalloc_release_space(inode, 1747 btrfs_delalloc_release_space(inode,
1744 round_down(pos, fs_info->sectorsize), 1748 round_down(pos, fs_info->sectorsize),
@@ -2193,7 +2197,7 @@ static int btrfs_file_mmap(struct file *filp, struct vm_area_struct *vma)
2193 return 0; 2197 return 0;
2194} 2198}
2195 2199
2196static int hole_mergeable(struct inode *inode, struct extent_buffer *leaf, 2200static int hole_mergeable(struct btrfs_inode *inode, struct extent_buffer *leaf,
2197 int slot, u64 start, u64 end) 2201 int slot, u64 start, u64 end)
2198{ 2202{
2199 struct btrfs_file_extent_item *fi; 2203 struct btrfs_file_extent_item *fi;
@@ -2203,7 +2207,7 @@ static int hole_mergeable(struct inode *inode, struct extent_buffer *leaf,
2203 return 0; 2207 return 0;
2204 2208
2205 btrfs_item_key_to_cpu(leaf, &key, slot); 2209 btrfs_item_key_to_cpu(leaf, &key, slot);
2206 if (key.objectid != btrfs_ino(BTRFS_I(inode)) || 2210 if (key.objectid != btrfs_ino(inode) ||
2207 key.type != BTRFS_EXTENT_DATA_KEY) 2211 key.type != BTRFS_EXTENT_DATA_KEY)
2208 return 0; 2212 return 0;
2209 2213
@@ -2222,22 +2226,23 @@ static int hole_mergeable(struct inode *inode, struct extent_buffer *leaf,
2222 return 0; 2226 return 0;
2223} 2227}
2224 2228
2225static int fill_holes(struct btrfs_trans_handle *trans, struct inode *inode, 2229static int fill_holes(struct btrfs_trans_handle *trans,
2226 struct btrfs_path *path, u64 offset, u64 end) 2230 struct btrfs_inode *inode,
2231 struct btrfs_path *path, u64 offset, u64 end)
2227{ 2232{
2228 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 2233 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
2229 struct btrfs_root *root = BTRFS_I(inode)->root; 2234 struct btrfs_root *root = inode->root;
2230 struct extent_buffer *leaf; 2235 struct extent_buffer *leaf;
2231 struct btrfs_file_extent_item *fi; 2236 struct btrfs_file_extent_item *fi;
2232 struct extent_map *hole_em; 2237 struct extent_map *hole_em;
2233 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 2238 struct extent_map_tree *em_tree = &inode->extent_tree;
2234 struct btrfs_key key; 2239 struct btrfs_key key;
2235 int ret; 2240 int ret;
2236 2241
2237 if (btrfs_fs_incompat(fs_info, NO_HOLES)) 2242 if (btrfs_fs_incompat(fs_info, NO_HOLES))
2238 goto out; 2243 goto out;
2239 2244
2240 key.objectid = btrfs_ino(BTRFS_I(inode)); 2245 key.objectid = btrfs_ino(inode);
2241 key.type = BTRFS_EXTENT_DATA_KEY; 2246 key.type = BTRFS_EXTENT_DATA_KEY;
2242 key.offset = offset; 2247 key.offset = offset;
2243 2248
@@ -2253,7 +2258,7 @@ static int fill_holes(struct btrfs_trans_handle *trans, struct inode *inode,
2253 } 2258 }
2254 2259
2255 leaf = path->nodes[0]; 2260 leaf = path->nodes[0];
2256 if (hole_mergeable(inode, leaf, path->slots[0]-1, offset, end)) { 2261 if (hole_mergeable(inode, leaf, path->slots[0] - 1, offset, end)) {
2257 u64 num_bytes; 2262 u64 num_bytes;
2258 2263
2259 path->slots[0]--; 2264 path->slots[0]--;
@@ -2285,7 +2290,7 @@ static int fill_holes(struct btrfs_trans_handle *trans, struct inode *inode,
2285 } 2290 }
2286 btrfs_release_path(path); 2291 btrfs_release_path(path);
2287 2292
2288 ret = btrfs_insert_file_extent(trans, root, btrfs_ino(BTRFS_I(inode)), 2293 ret = btrfs_insert_file_extent(trans, root, btrfs_ino(inode),
2289 offset, 0, 0, end - offset, 0, end - offset, 0, 0, 0); 2294 offset, 0, 0, end - offset, 0, end - offset, 0, 0, 0);
2290 if (ret) 2295 if (ret)
2291 return ret; 2296 return ret;
@@ -2296,8 +2301,7 @@ out:
2296 hole_em = alloc_extent_map(); 2301 hole_em = alloc_extent_map();
2297 if (!hole_em) { 2302 if (!hole_em) {
2298 btrfs_drop_extent_cache(inode, offset, end - 1, 0); 2303 btrfs_drop_extent_cache(inode, offset, end - 1, 0);
2299 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, 2304 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &inode->runtime_flags);
2300 &BTRFS_I(inode)->runtime_flags);
2301 } else { 2305 } else {
2302 hole_em->start = offset; 2306 hole_em->start = offset;
2303 hole_em->len = end - offset; 2307 hole_em->len = end - offset;
@@ -2320,7 +2324,7 @@ out:
2320 free_extent_map(hole_em); 2324 free_extent_map(hole_em);
2321 if (ret) 2325 if (ret)
2322 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, 2326 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
2323 &BTRFS_I(inode)->runtime_flags); 2327 &inode->runtime_flags);
2324 } 2328 }
2325 2329
2326 return 0; 2330 return 0;
@@ -2337,7 +2341,7 @@ static int find_first_non_hole(struct inode *inode, u64 *start, u64 *len)
2337 struct extent_map *em; 2341 struct extent_map *em;
2338 int ret = 0; 2342 int ret = 0;
2339 2343
2340 em = btrfs_get_extent(inode, NULL, 0, *start, *len, 0); 2344 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, *start, *len, 0);
2341 if (IS_ERR_OR_NULL(em)) { 2345 if (IS_ERR_OR_NULL(em)) {
2342 if (!em) 2346 if (!em)
2343 ret = -ENOMEM; 2347 ret = -ENOMEM;
@@ -2550,8 +2554,8 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
2550 trans->block_rsv = &fs_info->trans_block_rsv; 2554 trans->block_rsv = &fs_info->trans_block_rsv;
2551 2555
2552 if (cur_offset < drop_end && cur_offset < ino_size) { 2556 if (cur_offset < drop_end && cur_offset < ino_size) {
2553 ret = fill_holes(trans, inode, path, cur_offset, 2557 ret = fill_holes(trans, BTRFS_I(inode), path,
2554 drop_end); 2558 cur_offset, drop_end);
2555 if (ret) { 2559 if (ret) {
2556 /* 2560 /*
2557 * If we failed then we didn't insert our hole 2561 * If we failed then we didn't insert our hole
@@ -2622,7 +2626,8 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
2622 * cur_offset == drop_end). 2626 * cur_offset == drop_end).
2623 */ 2627 */
2624 if (cur_offset < ino_size && cur_offset < drop_end) { 2628 if (cur_offset < ino_size && cur_offset < drop_end) {
2625 ret = fill_holes(trans, inode, path, cur_offset, drop_end); 2629 ret = fill_holes(trans, BTRFS_I(inode), path,
2630 cur_offset, drop_end);
2626 if (ret) { 2631 if (ret) {
2627 /* Same comment as above. */ 2632 /* Same comment as above. */
2628 btrfs_abort_transaction(trans, ret); 2633 btrfs_abort_transaction(trans, ret);
@@ -2747,7 +2752,8 @@ static long btrfs_fallocate(struct file *file, int mode,
2747 * 2752 *
2748 * For qgroup space, it will be checked later. 2753 * For qgroup space, it will be checked later.
2749 */ 2754 */
2750 ret = btrfs_alloc_data_chunk_ondemand(inode, alloc_end - alloc_start); 2755 ret = btrfs_alloc_data_chunk_ondemand(BTRFS_I(inode),
2756 alloc_end - alloc_start);
2751 if (ret < 0) 2757 if (ret < 0)
2752 return ret; 2758 return ret;
2753 2759
@@ -2827,7 +2833,7 @@ static long btrfs_fallocate(struct file *file, int mode,
2827 /* First, check if we exceed the qgroup limit */ 2833 /* First, check if we exceed the qgroup limit */
2828 INIT_LIST_HEAD(&reserve_list); 2834 INIT_LIST_HEAD(&reserve_list);
2829 while (1) { 2835 while (1) {
2830 em = btrfs_get_extent(inode, NULL, 0, cur_offset, 2836 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, cur_offset,
2831 alloc_end - cur_offset, 0); 2837 alloc_end - cur_offset, 0);
2832 if (IS_ERR_OR_NULL(em)) { 2838 if (IS_ERR_OR_NULL(em)) {
2833 if (!em) 2839 if (!em)
@@ -2954,7 +2960,8 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int whence)
2954 &cached_state); 2960 &cached_state);
2955 2961
2956 while (start < inode->i_size) { 2962 while (start < inode->i_size) {
2957 em = btrfs_get_extent_fiemap(inode, NULL, 0, start, len, 0); 2963 em = btrfs_get_extent_fiemap(BTRFS_I(inode), NULL, 0,
2964 start, len, 0);
2958 if (IS_ERR(em)) { 2965 if (IS_ERR(em)) {
2959 ret = PTR_ERR(em); 2966 ret = PTR_ERR(em);
2960 em = NULL; 2967 em = NULL;
diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index 1a131f7d6c1b..7dcf0b100dcd 100644
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -260,7 +260,7 @@ int btrfs_truncate_free_space_cache(struct btrfs_trans_handle *trans,
260 btrfs_free_path(path); 260 btrfs_free_path(path);
261 } 261 }
262 262
263 btrfs_i_size_write(inode, 0); 263 btrfs_i_size_write(BTRFS_I(inode), 0);
264 truncate_pagecache(inode, 0); 264 truncate_pagecache(inode, 0);
265 265
266 /* 266 /*
@@ -3545,7 +3545,8 @@ int btrfs_write_out_ino_cache(struct btrfs_root *root,
3545 3545
3546 if (ret) { 3546 if (ret) {
3547 if (release_metadata) 3547 if (release_metadata)
3548 btrfs_delalloc_release_metadata(inode, inode->i_size); 3548 btrfs_delalloc_release_metadata(BTRFS_I(inode),
3549 inode->i_size);
3549#ifdef DEBUG 3550#ifdef DEBUG
3550 btrfs_err(fs_info, 3551 btrfs_err(fs_info,
3551 "failed to write free ino cache for root %llu", 3552 "failed to write free ino cache for root %llu",
diff --git a/fs/btrfs/inode-map.c b/fs/btrfs/inode-map.c
index 3bbb8f095953..5c6c20ec64d8 100644
--- a/fs/btrfs/inode-map.c
+++ b/fs/btrfs/inode-map.c
@@ -499,7 +499,7 @@ again:
499 ret = btrfs_prealloc_file_range_trans(inode, trans, 0, 0, prealloc, 499 ret = btrfs_prealloc_file_range_trans(inode, trans, 0, 0, prealloc,
500 prealloc, prealloc, &alloc_hint); 500 prealloc, prealloc, &alloc_hint);
501 if (ret) { 501 if (ret) {
502 btrfs_delalloc_release_metadata(inode, prealloc); 502 btrfs_delalloc_release_metadata(BTRFS_I(inode), prealloc);
503 goto out_put; 503 goto out_put;
504 } 504 }
505 505
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index f02823f088c2..ee6978d80491 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -316,8 +316,8 @@ static noinline int cow_file_range_inline(struct btrfs_root *root,
316 } 316 }
317 317
318 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags); 318 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
319 btrfs_delalloc_release_metadata(inode, end + 1 - start); 319 btrfs_delalloc_release_metadata(BTRFS_I(inode), end + 1 - start);
320 btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0); 320 btrfs_drop_extent_cache(BTRFS_I(inode), start, aligned_end - 1, 0);
321out: 321out:
322 /* 322 /*
323 * Don't forget to free the reserved space, as for inlined extent 323 * Don't forget to free the reserved space, as for inlined extent
@@ -389,12 +389,12 @@ static inline int inode_need_compress(struct inode *inode)
389 return 0; 389 return 0;
390} 390}
391 391
392static inline void inode_should_defrag(struct inode *inode, 392static inline void inode_should_defrag(struct btrfs_inode *inode,
393 u64 start, u64 end, u64 num_bytes, u64 small_write) 393 u64 start, u64 end, u64 num_bytes, u64 small_write)
394{ 394{
395 /* If this is a small write inside eof, kick off a defrag */ 395 /* If this is a small write inside eof, kick off a defrag */
396 if (num_bytes < small_write && 396 if (num_bytes < small_write &&
397 (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size)) 397 (start > 0 || end + 1 < inode->disk_i_size))
398 btrfs_add_inode_defrag(NULL, inode); 398 btrfs_add_inode_defrag(NULL, inode);
399} 399}
400 400
@@ -430,23 +430,23 @@ static noinline void compress_file_range(struct inode *inode,
430 int ret = 0; 430 int ret = 0;
431 struct page **pages = NULL; 431 struct page **pages = NULL;
432 unsigned long nr_pages; 432 unsigned long nr_pages;
433 unsigned long nr_pages_ret = 0;
434 unsigned long total_compressed = 0; 433 unsigned long total_compressed = 0;
435 unsigned long total_in = 0; 434 unsigned long total_in = 0;
436 unsigned long max_compressed = SZ_128K;
437 unsigned long max_uncompressed = SZ_128K;
438 int i; 435 int i;
439 int will_compress; 436 int will_compress;
440 int compress_type = fs_info->compress_type; 437 int compress_type = fs_info->compress_type;
441 int redirty = 0; 438 int redirty = 0;
442 439
443 inode_should_defrag(inode, start, end, end - start + 1, SZ_16K); 440 inode_should_defrag(BTRFS_I(inode), start, end, end - start + 1,
441 SZ_16K);
444 442
445 actual_end = min_t(u64, isize, end + 1); 443 actual_end = min_t(u64, isize, end + 1);
446again: 444again:
447 will_compress = 0; 445 will_compress = 0;
448 nr_pages = (end >> PAGE_SHIFT) - (start >> PAGE_SHIFT) + 1; 446 nr_pages = (end >> PAGE_SHIFT) - (start >> PAGE_SHIFT) + 1;
449 nr_pages = min_t(unsigned long, nr_pages, SZ_128K / PAGE_SIZE); 447 BUILD_BUG_ON((BTRFS_MAX_COMPRESSED % PAGE_SIZE) != 0);
448 nr_pages = min_t(unsigned long, nr_pages,
449 BTRFS_MAX_COMPRESSED / PAGE_SIZE);
450 450
451 /* 451 /*
452 * we don't want to send crud past the end of i_size through 452 * we don't want to send crud past the end of i_size through
@@ -471,17 +471,8 @@ again:
471 (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size)) 471 (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
472 goto cleanup_and_bail_uncompressed; 472 goto cleanup_and_bail_uncompressed;
473 473
474 /* we want to make sure that amount of ram required to uncompress 474 total_compressed = min_t(unsigned long, total_compressed,
475 * an extent is reasonable, so we limit the total size in ram 475 BTRFS_MAX_UNCOMPRESSED);
476 * of a compressed extent to 128k. This is a crucial number
477 * because it also controls how easily we can spread reads across
478 * cpus for decompression.
479 *
480 * We also want to make sure the amount of IO required to do
481 * a random read is reasonably small, so we limit the size of
482 * a compressed extent to 128k.
483 */
484 total_compressed = min(total_compressed, max_uncompressed);
485 num_bytes = ALIGN(end - start + 1, blocksize); 476 num_bytes = ALIGN(end - start + 1, blocksize);
486 num_bytes = max(blocksize, num_bytes); 477 num_bytes = max(blocksize, num_bytes);
487 total_in = 0; 478 total_in = 0;
@@ -516,16 +507,15 @@ again:
516 redirty = 1; 507 redirty = 1;
517 ret = btrfs_compress_pages(compress_type, 508 ret = btrfs_compress_pages(compress_type,
518 inode->i_mapping, start, 509 inode->i_mapping, start,
519 total_compressed, pages, 510 pages,
520 nr_pages, &nr_pages_ret, 511 &nr_pages,
521 &total_in, 512 &total_in,
522 &total_compressed, 513 &total_compressed);
523 max_compressed);
524 514
525 if (!ret) { 515 if (!ret) {
526 unsigned long offset = total_compressed & 516 unsigned long offset = total_compressed &
527 (PAGE_SIZE - 1); 517 (PAGE_SIZE - 1);
528 struct page *page = pages[nr_pages_ret - 1]; 518 struct page *page = pages[nr_pages - 1];
529 char *kaddr; 519 char *kaddr;
530 520
531 /* zero the tail end of the last page, we might be 521 /* zero the tail end of the last page, we might be
@@ -606,7 +596,7 @@ cont:
606 * will submit them to the elevator. 596 * will submit them to the elevator.
607 */ 597 */
608 add_async_extent(async_cow, start, num_bytes, 598 add_async_extent(async_cow, start, num_bytes,
609 total_compressed, pages, nr_pages_ret, 599 total_compressed, pages, nr_pages,
610 compress_type); 600 compress_type);
611 601
612 if (start + num_bytes < end) { 602 if (start + num_bytes < end) {
@@ -623,14 +613,14 @@ cont:
623 * the compression code ran but failed to make things smaller, 613 * the compression code ran but failed to make things smaller,
624 * free any pages it allocated and our page pointer array 614 * free any pages it allocated and our page pointer array
625 */ 615 */
626 for (i = 0; i < nr_pages_ret; i++) { 616 for (i = 0; i < nr_pages; i++) {
627 WARN_ON(pages[i]->mapping); 617 WARN_ON(pages[i]->mapping);
628 put_page(pages[i]); 618 put_page(pages[i]);
629 } 619 }
630 kfree(pages); 620 kfree(pages);
631 pages = NULL; 621 pages = NULL;
632 total_compressed = 0; 622 total_compressed = 0;
633 nr_pages_ret = 0; 623 nr_pages = 0;
634 624
635 /* flag the file so we don't compress in the future */ 625 /* flag the file so we don't compress in the future */
636 if (!btrfs_test_opt(fs_info, FORCE_COMPRESS) && 626 if (!btrfs_test_opt(fs_info, FORCE_COMPRESS) &&
@@ -659,7 +649,7 @@ cleanup_and_bail_uncompressed:
659 return; 649 return;
660 650
661free_pages_out: 651free_pages_out:
662 for (i = 0; i < nr_pages_ret; i++) { 652 for (i = 0; i < nr_pages; i++) {
663 WARN_ON(pages[i]->mapping); 653 WARN_ON(pages[i]->mapping);
664 put_page(pages[i]); 654 put_page(pages[i]);
665 } 655 }
@@ -806,7 +796,8 @@ retry:
806 BTRFS_ORDERED_COMPRESSED, 796 BTRFS_ORDERED_COMPRESSED,
807 async_extent->compress_type); 797 async_extent->compress_type);
808 if (ret) { 798 if (ret) {
809 btrfs_drop_extent_cache(inode, async_extent->start, 799 btrfs_drop_extent_cache(BTRFS_I(inode),
800 async_extent->start,
810 async_extent->start + 801 async_extent->start +
811 async_extent->ram_size - 1, 0); 802 async_extent->ram_size - 1, 0);
812 goto out_free_reserve; 803 goto out_free_reserve;
@@ -933,7 +924,7 @@ static noinline int cow_file_range(struct inode *inode,
933 struct extent_map *em; 924 struct extent_map *em;
934 int ret = 0; 925 int ret = 0;
935 926
936 if (btrfs_is_free_space_inode(inode)) { 927 if (btrfs_is_free_space_inode(BTRFS_I(inode))) {
937 WARN_ON_ONCE(1); 928 WARN_ON_ONCE(1);
938 ret = -EINVAL; 929 ret = -EINVAL;
939 goto out_unlock; 930 goto out_unlock;
@@ -943,7 +934,7 @@ static noinline int cow_file_range(struct inode *inode,
943 num_bytes = max(blocksize, num_bytes); 934 num_bytes = max(blocksize, num_bytes);
944 disk_num_bytes = num_bytes; 935 disk_num_bytes = num_bytes;
945 936
946 inode_should_defrag(inode, start, end, num_bytes, SZ_64K); 937 inode_should_defrag(BTRFS_I(inode), start, end, num_bytes, SZ_64K);
947 938
948 if (start == 0) { 939 if (start == 0) {
949 /* lets try to make an inline extent */ 940 /* lets try to make an inline extent */
@@ -971,7 +962,8 @@ static noinline int cow_file_range(struct inode *inode,
971 btrfs_super_total_bytes(fs_info->super_copy)); 962 btrfs_super_total_bytes(fs_info->super_copy));
972 963
973 alloc_hint = get_extent_allocation_hint(inode, start, num_bytes); 964 alloc_hint = get_extent_allocation_hint(inode, start, num_bytes);
974 btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0); 965 btrfs_drop_extent_cache(BTRFS_I(inode), start,
966 start + num_bytes - 1, 0);
975 967
976 while (disk_num_bytes > 0) { 968 while (disk_num_bytes > 0) {
977 unsigned long op; 969 unsigned long op;
@@ -1039,7 +1031,7 @@ out:
1039 return ret; 1031 return ret;
1040 1032
1041out_drop_extent_cache: 1033out_drop_extent_cache:
1042 btrfs_drop_extent_cache(inode, start, start + ram_size - 1, 0); 1034 btrfs_drop_extent_cache(BTRFS_I(inode), start, start + ram_size - 1, 0);
1043out_reserve: 1035out_reserve:
1044 btrfs_dec_block_group_reservations(fs_info, ins.objectid); 1036 btrfs_dec_block_group_reservations(fs_info, ins.objectid);
1045 btrfs_free_reserved_extent(fs_info, ins.objectid, ins.offset, 1); 1037 btrfs_free_reserved_extent(fs_info, ins.objectid, ins.offset, 1);
@@ -1231,7 +1223,7 @@ static noinline int run_delalloc_nocow(struct inode *inode,
1231 return -ENOMEM; 1223 return -ENOMEM;
1232 } 1224 }
1233 1225
1234 nolock = btrfs_is_free_space_inode(inode); 1226 nolock = btrfs_is_free_space_inode(BTRFS_I(inode));
1235 1227
1236 cow_start = (u64)-1; 1228 cow_start = (u64)-1;
1237 cur_offset = start; 1229 cur_offset = start;
@@ -1331,10 +1323,16 @@ next_slot:
1331 * either valid or do not exist. 1323 * either valid or do not exist.
1332 */ 1324 */
1333 if (csum_exist_in_range(fs_info, disk_bytenr, 1325 if (csum_exist_in_range(fs_info, disk_bytenr,
1334 num_bytes)) 1326 num_bytes)) {
1327 if (!nolock)
1328 btrfs_end_write_no_snapshoting(root);
1335 goto out_check; 1329 goto out_check;
1336 if (!btrfs_inc_nocow_writers(fs_info, disk_bytenr)) 1330 }
1331 if (!btrfs_inc_nocow_writers(fs_info, disk_bytenr)) {
1332 if (!nolock)
1333 btrfs_end_write_no_snapshoting(root);
1337 goto out_check; 1334 goto out_check;
1335 }
1338 nocow = 1; 1336 nocow = 1;
1339 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) { 1337 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1340 extent_end = found_key.offset + 1338 extent_end = found_key.offset +
@@ -1629,15 +1627,15 @@ static void btrfs_add_delalloc_inodes(struct btrfs_root *root,
1629} 1627}
1630 1628
1631static void btrfs_del_delalloc_inode(struct btrfs_root *root, 1629static void btrfs_del_delalloc_inode(struct btrfs_root *root,
1632 struct inode *inode) 1630 struct btrfs_inode *inode)
1633{ 1631{
1634 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 1632 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
1635 1633
1636 spin_lock(&root->delalloc_lock); 1634 spin_lock(&root->delalloc_lock);
1637 if (!list_empty(&BTRFS_I(inode)->delalloc_inodes)) { 1635 if (!list_empty(&inode->delalloc_inodes)) {
1638 list_del_init(&BTRFS_I(inode)->delalloc_inodes); 1636 list_del_init(&inode->delalloc_inodes);
1639 clear_bit(BTRFS_INODE_IN_DELALLOC_LIST, 1637 clear_bit(BTRFS_INODE_IN_DELALLOC_LIST,
1640 &BTRFS_I(inode)->runtime_flags); 1638 &inode->runtime_flags);
1641 root->nr_delalloc_inodes--; 1639 root->nr_delalloc_inodes--;
1642 if (!root->nr_delalloc_inodes) { 1640 if (!root->nr_delalloc_inodes) {
1643 spin_lock(&fs_info->delalloc_root_lock); 1641 spin_lock(&fs_info->delalloc_root_lock);
@@ -1670,7 +1668,7 @@ static void btrfs_set_bit_hook(struct inode *inode,
1670 if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) { 1668 if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1671 struct btrfs_root *root = BTRFS_I(inode)->root; 1669 struct btrfs_root *root = BTRFS_I(inode)->root;
1672 u64 len = state->end + 1 - state->start; 1670 u64 len = state->end + 1 - state->start;
1673 bool do_list = !btrfs_is_free_space_inode(inode); 1671 bool do_list = !btrfs_is_free_space_inode(BTRFS_I(inode));
1674 1672
1675 if (*bits & EXTENT_FIRST_DELALLOC) { 1673 if (*bits & EXTENT_FIRST_DELALLOC) {
1676 *bits &= ~EXTENT_FIRST_DELALLOC; 1674 *bits &= ~EXTENT_FIRST_DELALLOC;
@@ -1700,18 +1698,18 @@ static void btrfs_set_bit_hook(struct inode *inode,
1700/* 1698/*
1701 * extent_io.c clear_bit_hook, see set_bit_hook for why 1699 * extent_io.c clear_bit_hook, see set_bit_hook for why
1702 */ 1700 */
1703static void btrfs_clear_bit_hook(struct inode *inode, 1701static void btrfs_clear_bit_hook(struct btrfs_inode *inode,
1704 struct extent_state *state, 1702 struct extent_state *state,
1705 unsigned *bits) 1703 unsigned *bits)
1706{ 1704{
1707 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 1705 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
1708 u64 len = state->end + 1 - state->start; 1706 u64 len = state->end + 1 - state->start;
1709 u32 num_extents = count_max_extents(len); 1707 u32 num_extents = count_max_extents(len);
1710 1708
1711 spin_lock(&BTRFS_I(inode)->lock); 1709 spin_lock(&inode->lock);
1712 if ((state->state & EXTENT_DEFRAG) && (*bits & EXTENT_DEFRAG)) 1710 if ((state->state & EXTENT_DEFRAG) && (*bits & EXTENT_DEFRAG))
1713 BTRFS_I(inode)->defrag_bytes -= len; 1711 inode->defrag_bytes -= len;
1714 spin_unlock(&BTRFS_I(inode)->lock); 1712 spin_unlock(&inode->lock);
1715 1713
1716 /* 1714 /*
1717 * set_bit and clear bit hooks normally require _irqsave/restore 1715 * set_bit and clear bit hooks normally require _irqsave/restore
@@ -1719,15 +1717,15 @@ static void btrfs_clear_bit_hook(struct inode *inode,
1719 * bit, which is only set or cleared with irqs on 1717 * bit, which is only set or cleared with irqs on
1720 */ 1718 */
1721 if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) { 1719 if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1722 struct btrfs_root *root = BTRFS_I(inode)->root; 1720 struct btrfs_root *root = inode->root;
1723 bool do_list = !btrfs_is_free_space_inode(inode); 1721 bool do_list = !btrfs_is_free_space_inode(inode);
1724 1722
1725 if (*bits & EXTENT_FIRST_DELALLOC) { 1723 if (*bits & EXTENT_FIRST_DELALLOC) {
1726 *bits &= ~EXTENT_FIRST_DELALLOC; 1724 *bits &= ~EXTENT_FIRST_DELALLOC;
1727 } else if (!(*bits & EXTENT_DO_ACCOUNTING)) { 1725 } else if (!(*bits & EXTENT_DO_ACCOUNTING)) {
1728 spin_lock(&BTRFS_I(inode)->lock); 1726 spin_lock(&inode->lock);
1729 BTRFS_I(inode)->outstanding_extents -= num_extents; 1727 inode->outstanding_extents -= num_extents;
1730 spin_unlock(&BTRFS_I(inode)->lock); 1728 spin_unlock(&inode->lock);
1731 } 1729 }
1732 1730
1733 /* 1731 /*
@@ -1747,18 +1745,19 @@ static void btrfs_clear_bit_hook(struct inode *inode,
1747 && do_list && !(state->state & EXTENT_NORESERVE) 1745 && do_list && !(state->state & EXTENT_NORESERVE)
1748 && (*bits & (EXTENT_DO_ACCOUNTING | 1746 && (*bits & (EXTENT_DO_ACCOUNTING |
1749 EXTENT_CLEAR_DATA_RESV))) 1747 EXTENT_CLEAR_DATA_RESV)))
1750 btrfs_free_reserved_data_space_noquota(inode, 1748 btrfs_free_reserved_data_space_noquota(
1749 &inode->vfs_inode,
1751 state->start, len); 1750 state->start, len);
1752 1751
1753 __percpu_counter_add(&fs_info->delalloc_bytes, -len, 1752 __percpu_counter_add(&fs_info->delalloc_bytes, -len,
1754 fs_info->delalloc_batch); 1753 fs_info->delalloc_batch);
1755 spin_lock(&BTRFS_I(inode)->lock); 1754 spin_lock(&inode->lock);
1756 BTRFS_I(inode)->delalloc_bytes -= len; 1755 inode->delalloc_bytes -= len;
1757 if (do_list && BTRFS_I(inode)->delalloc_bytes == 0 && 1756 if (do_list && inode->delalloc_bytes == 0 &&
1758 test_bit(BTRFS_INODE_IN_DELALLOC_LIST, 1757 test_bit(BTRFS_INODE_IN_DELALLOC_LIST,
1759 &BTRFS_I(inode)->runtime_flags)) 1758 &inode->runtime_flags))
1760 btrfs_del_delalloc_inode(root, inode); 1759 btrfs_del_delalloc_inode(root, inode);
1761 spin_unlock(&BTRFS_I(inode)->lock); 1760 spin_unlock(&inode->lock);
1762 } 1761 }
1763} 1762}
1764 1763
@@ -1854,7 +1853,7 @@ static int btrfs_submit_bio_hook(struct inode *inode, struct bio *bio,
1854 1853
1855 skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM; 1854 skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
1856 1855
1857 if (btrfs_is_free_space_inode(inode)) 1856 if (btrfs_is_free_space_inode(BTRFS_I(inode)))
1858 metadata = BTRFS_WQ_ENDIO_FREE_SPACE; 1857 metadata = BTRFS_WQ_ENDIO_FREE_SPACE;
1859 1858
1860 if (bio_op(bio) != REQ_OP_WRITE) { 1859 if (bio_op(bio) != REQ_OP_WRITE) {
@@ -1963,7 +1962,7 @@ again:
1963 if (PagePrivate2(page)) 1962 if (PagePrivate2(page))
1964 goto out; 1963 goto out;
1965 1964
1966 ordered = btrfs_lookup_ordered_range(inode, page_start, 1965 ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start,
1967 PAGE_SIZE); 1966 PAGE_SIZE);
1968 if (ordered) { 1967 if (ordered) {
1969 unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start, 1968 unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start,
@@ -2793,16 +2792,17 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
2793 bool nolock; 2792 bool nolock;
2794 bool truncated = false; 2793 bool truncated = false;
2795 2794
2796 nolock = btrfs_is_free_space_inode(inode); 2795 nolock = btrfs_is_free_space_inode(BTRFS_I(inode));
2797 2796
2798 if (test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags)) { 2797 if (test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags)) {
2799 ret = -EIO; 2798 ret = -EIO;
2800 goto out; 2799 goto out;
2801 } 2800 }
2802 2801
2803 btrfs_free_io_failure_record(inode, ordered_extent->file_offset, 2802 btrfs_free_io_failure_record(BTRFS_I(inode),
2804 ordered_extent->file_offset + 2803 ordered_extent->file_offset,
2805 ordered_extent->len - 1); 2804 ordered_extent->file_offset +
2805 ordered_extent->len - 1);
2806 2806
2807 if (test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) { 2807 if (test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) {
2808 truncated = true; 2808 truncated = true;
@@ -2873,7 +2873,7 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
2873 compress_type = ordered_extent->compress_type; 2873 compress_type = ordered_extent->compress_type;
2874 if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) { 2874 if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
2875 BUG_ON(compress_type); 2875 BUG_ON(compress_type);
2876 ret = btrfs_mark_extent_written(trans, inode, 2876 ret = btrfs_mark_extent_written(trans, BTRFS_I(inode),
2877 ordered_extent->file_offset, 2877 ordered_extent->file_offset,
2878 ordered_extent->file_offset + 2878 ordered_extent->file_offset +
2879 logical_len); 2879 logical_len);
@@ -2914,7 +2914,8 @@ out_unlock:
2914 ordered_extent->len - 1, &cached_state, GFP_NOFS); 2914 ordered_extent->len - 1, &cached_state, GFP_NOFS);
2915out: 2915out:
2916 if (root != fs_info->tree_root) 2916 if (root != fs_info->tree_root)
2917 btrfs_delalloc_release_metadata(inode, ordered_extent->len); 2917 btrfs_delalloc_release_metadata(BTRFS_I(inode),
2918 ordered_extent->len);
2918 if (trans) 2919 if (trans)
2919 btrfs_end_transaction(trans); 2920 btrfs_end_transaction(trans);
2920 2921
@@ -2929,7 +2930,7 @@ out:
2929 clear_extent_uptodate(io_tree, start, end, NULL, GFP_NOFS); 2930 clear_extent_uptodate(io_tree, start, end, NULL, GFP_NOFS);
2930 2931
2931 /* Drop the cache for the part of the extent we didn't write. */ 2932 /* Drop the cache for the part of the extent we didn't write. */
2932 btrfs_drop_extent_cache(inode, start, end, 0); 2933 btrfs_drop_extent_cache(BTRFS_I(inode), start, end, 0);
2933 2934
2934 /* 2935 /*
2935 * If the ordered extent had an IOERR or something else went 2936 * If the ordered extent had an IOERR or something else went
@@ -2977,7 +2978,7 @@ static void finish_ordered_fn(struct btrfs_work *work)
2977 btrfs_finish_ordered_io(ordered_extent); 2978 btrfs_finish_ordered_io(ordered_extent);
2978} 2979}
2979 2980
2980static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end, 2981static void btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
2981 struct extent_state *state, int uptodate) 2982 struct extent_state *state, int uptodate)
2982{ 2983{
2983 struct inode *inode = page->mapping->host; 2984 struct inode *inode = page->mapping->host;
@@ -2991,9 +2992,9 @@ static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
2991 ClearPagePrivate2(page); 2992 ClearPagePrivate2(page);
2992 if (!btrfs_dec_test_ordered_pending(inode, &ordered_extent, start, 2993 if (!btrfs_dec_test_ordered_pending(inode, &ordered_extent, start,
2993 end - start + 1, uptodate)) 2994 end - start + 1, uptodate))
2994 return 0; 2995 return;
2995 2996
2996 if (btrfs_is_free_space_inode(inode)) { 2997 if (btrfs_is_free_space_inode(BTRFS_I(inode))) {
2997 wq = fs_info->endio_freespace_worker; 2998 wq = fs_info->endio_freespace_worker;
2998 func = btrfs_freespace_write_helper; 2999 func = btrfs_freespace_write_helper;
2999 } else { 3000 } else {
@@ -3004,8 +3005,6 @@ static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
3004 btrfs_init_work(&ordered_extent->work, func, finish_ordered_fn, NULL, 3005 btrfs_init_work(&ordered_extent->work, func, finish_ordered_fn, NULL,
3005 NULL); 3006 NULL);
3006 btrfs_queue_work(wq, &ordered_extent->work); 3007 btrfs_queue_work(wq, &ordered_extent->work);
3007
3008 return 0;
3009} 3008}
3010 3009
3011static int __readpage_endio_check(struct inode *inode, 3010static int __readpage_endio_check(struct inode *inode,
@@ -3028,7 +3027,7 @@ static int __readpage_endio_check(struct inode *inode,
3028 kunmap_atomic(kaddr); 3027 kunmap_atomic(kaddr);
3029 return 0; 3028 return 0;
3030zeroit: 3029zeroit:
3031 btrfs_print_data_csum_error(inode, start, csum, csum_expected, 3030 btrfs_print_data_csum_error(BTRFS_I(inode), start, csum, csum_expected,
3032 io_bio->mirror_num); 3031 io_bio->mirror_num);
3033 memset(kaddr + pgoff, 1, len); 3032 memset(kaddr + pgoff, 1, len);
3034 flush_dcache_page(page); 3033 flush_dcache_page(page);
@@ -3167,10 +3166,11 @@ void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
3167 * NOTE: caller of this function should reserve 5 units of metadata for 3166 * NOTE: caller of this function should reserve 5 units of metadata for
3168 * this function. 3167 * this function.
3169 */ 3168 */
3170int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode) 3169int btrfs_orphan_add(struct btrfs_trans_handle *trans,
3170 struct btrfs_inode *inode)
3171{ 3171{
3172 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 3172 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
3173 struct btrfs_root *root = BTRFS_I(inode)->root; 3173 struct btrfs_root *root = inode->root;
3174 struct btrfs_block_rsv *block_rsv = NULL; 3174 struct btrfs_block_rsv *block_rsv = NULL;
3175 int reserve = 0; 3175 int reserve = 0;
3176 int insert = 0; 3176 int insert = 0;
@@ -3192,7 +3192,7 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
3192 } 3192 }
3193 3193
3194 if (!test_and_set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM, 3194 if (!test_and_set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
3195 &BTRFS_I(inode)->runtime_flags)) { 3195 &inode->runtime_flags)) {
3196#if 0 3196#if 0
3197 /* 3197 /*
3198 * For proper ENOSPC handling, we should do orphan 3198 * For proper ENOSPC handling, we should do orphan
@@ -3209,7 +3209,7 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
3209 } 3209 }
3210 3210
3211 if (!test_and_set_bit(BTRFS_INODE_ORPHAN_META_RESERVED, 3211 if (!test_and_set_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
3212 &BTRFS_I(inode)->runtime_flags)) 3212 &inode->runtime_flags))
3213 reserve = 1; 3213 reserve = 1;
3214 spin_unlock(&root->orphan_lock); 3214 spin_unlock(&root->orphan_lock);
3215 3215
@@ -3220,28 +3220,27 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
3220 if (ret) { 3220 if (ret) {
3221 atomic_dec(&root->orphan_inodes); 3221 atomic_dec(&root->orphan_inodes);
3222 clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED, 3222 clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
3223 &BTRFS_I(inode)->runtime_flags); 3223 &inode->runtime_flags);
3224 if (insert) 3224 if (insert)
3225 clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM, 3225 clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
3226 &BTRFS_I(inode)->runtime_flags); 3226 &inode->runtime_flags);
3227 return ret; 3227 return ret;
3228 } 3228 }
3229 } 3229 }
3230 3230
3231 /* insert an orphan item to track this unlinked/truncated file */ 3231 /* insert an orphan item to track this unlinked/truncated file */
3232 if (insert >= 1) { 3232 if (insert >= 1) {
3233 ret = btrfs_insert_orphan_item(trans, root, 3233 ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode));
3234 btrfs_ino(BTRFS_I(inode)));
3235 if (ret) { 3234 if (ret) {
3236 atomic_dec(&root->orphan_inodes); 3235 atomic_dec(&root->orphan_inodes);
3237 if (reserve) { 3236 if (reserve) {
3238 clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED, 3237 clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
3239 &BTRFS_I(inode)->runtime_flags); 3238 &inode->runtime_flags);
3240 btrfs_orphan_release_metadata(inode); 3239 btrfs_orphan_release_metadata(inode);
3241 } 3240 }
3242 if (ret != -EEXIST) { 3241 if (ret != -EEXIST) {
3243 clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM, 3242 clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
3244 &BTRFS_I(inode)->runtime_flags); 3243 &inode->runtime_flags);
3245 btrfs_abort_transaction(trans, ret); 3244 btrfs_abort_transaction(trans, ret);
3246 return ret; 3245 return ret;
3247 } 3246 }
@@ -3266,20 +3265,20 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
3266 * item for this particular inode. 3265 * item for this particular inode.
3267 */ 3266 */
3268static int btrfs_orphan_del(struct btrfs_trans_handle *trans, 3267static int btrfs_orphan_del(struct btrfs_trans_handle *trans,
3269 struct inode *inode) 3268 struct btrfs_inode *inode)
3270{ 3269{
3271 struct btrfs_root *root = BTRFS_I(inode)->root; 3270 struct btrfs_root *root = inode->root;
3272 int delete_item = 0; 3271 int delete_item = 0;
3273 int release_rsv = 0; 3272 int release_rsv = 0;
3274 int ret = 0; 3273 int ret = 0;
3275 3274
3276 spin_lock(&root->orphan_lock); 3275 spin_lock(&root->orphan_lock);
3277 if (test_and_clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM, 3276 if (test_and_clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
3278 &BTRFS_I(inode)->runtime_flags)) 3277 &inode->runtime_flags))
3279 delete_item = 1; 3278 delete_item = 1;
3280 3279
3281 if (test_and_clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED, 3280 if (test_and_clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
3282 &BTRFS_I(inode)->runtime_flags)) 3281 &inode->runtime_flags))
3283 release_rsv = 1; 3282 release_rsv = 1;
3284 spin_unlock(&root->orphan_lock); 3283 spin_unlock(&root->orphan_lock);
3285 3284
@@ -3287,7 +3286,7 @@ static int btrfs_orphan_del(struct btrfs_trans_handle *trans,
3287 atomic_dec(&root->orphan_inodes); 3286 atomic_dec(&root->orphan_inodes);
3288 if (trans) 3287 if (trans)
3289 ret = btrfs_del_orphan_item(trans, root, 3288 ret = btrfs_del_orphan_item(trans, root,
3290 btrfs_ino(BTRFS_I(inode))); 3289 btrfs_ino(inode));
3291 } 3290 }
3292 3291
3293 if (release_rsv) 3292 if (release_rsv)
@@ -3453,7 +3452,7 @@ int btrfs_orphan_cleanup(struct btrfs_root *root)
3453 ret = PTR_ERR(trans); 3452 ret = PTR_ERR(trans);
3454 goto out; 3453 goto out;
3455 } 3454 }
3456 ret = btrfs_orphan_add(trans, inode); 3455 ret = btrfs_orphan_add(trans, BTRFS_I(inode));
3457 btrfs_end_transaction(trans); 3456 btrfs_end_transaction(trans);
3458 if (ret) { 3457 if (ret) {
3459 iput(inode); 3458 iput(inode);
@@ -3462,7 +3461,7 @@ int btrfs_orphan_cleanup(struct btrfs_root *root)
3462 3461
3463 ret = btrfs_truncate(inode); 3462 ret = btrfs_truncate(inode);
3464 if (ret) 3463 if (ret)
3465 btrfs_orphan_del(NULL, inode); 3464 btrfs_orphan_del(NULL, BTRFS_I(inode));
3466 } else { 3465 } else {
3467 nr_unlink++; 3466 nr_unlink++;
3468 } 3467 }
@@ -3617,7 +3616,7 @@ static int btrfs_read_locked_inode(struct inode *inode)
3617 set_nlink(inode, btrfs_inode_nlink(leaf, inode_item)); 3616 set_nlink(inode, btrfs_inode_nlink(leaf, inode_item));
3618 i_uid_write(inode, btrfs_inode_uid(leaf, inode_item)); 3617 i_uid_write(inode, btrfs_inode_uid(leaf, inode_item));
3619 i_gid_write(inode, btrfs_inode_gid(leaf, inode_item)); 3618 i_gid_write(inode, btrfs_inode_gid(leaf, inode_item));
3620 btrfs_i_size_write(inode, btrfs_inode_size(leaf, inode_item)); 3619 btrfs_i_size_write(BTRFS_I(inode), btrfs_inode_size(leaf, inode_item));
3621 3620
3622 inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->atime); 3621 inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->atime);
3623 inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->atime); 3622 inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->atime);
@@ -3865,7 +3864,7 @@ noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
3865 * The data relocation inode should also be directly updated 3864 * The data relocation inode should also be directly updated
3866 * without delay 3865 * without delay
3867 */ 3866 */
3868 if (!btrfs_is_free_space_inode(inode) 3867 if (!btrfs_is_free_space_inode(BTRFS_I(inode))
3869 && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID 3868 && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
3870 && !test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) { 3869 && !test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) {
3871 btrfs_update_root_times(trans, root); 3870 btrfs_update_root_times(trans, root);
@@ -3988,8 +3987,7 @@ err:
3988 if (ret) 3987 if (ret)
3989 goto out; 3988 goto out;
3990 3989
3991 btrfs_i_size_write(&dir->vfs_inode, 3990 btrfs_i_size_write(dir, dir->vfs_inode.i_size - name_len * 2);
3992 dir->vfs_inode.i_size - name_len * 2);
3993 inode_inc_iversion(&inode->vfs_inode); 3991 inode_inc_iversion(&inode->vfs_inode);
3994 inode_inc_iversion(&dir->vfs_inode); 3992 inode_inc_iversion(&dir->vfs_inode);
3995 inode->vfs_inode.i_ctime = dir->vfs_inode.i_mtime = 3993 inode->vfs_inode.i_ctime = dir->vfs_inode.i_mtime =
@@ -4056,7 +4054,7 @@ static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
4056 goto out; 4054 goto out;
4057 4055
4058 if (inode->i_nlink == 0) { 4056 if (inode->i_nlink == 0) {
4059 ret = btrfs_orphan_add(trans, inode); 4057 ret = btrfs_orphan_add(trans, BTRFS_I(inode));
4060 if (ret) 4058 if (ret)
4061 goto out; 4059 goto out;
4062 } 4060 }
@@ -4137,7 +4135,7 @@ int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
4137 goto out; 4135 goto out;
4138 } 4136 }
4139 4137
4140 btrfs_i_size_write(dir, dir->i_size - name_len * 2); 4138 btrfs_i_size_write(BTRFS_I(dir), dir->i_size - name_len * 2);
4141 inode_inc_iversion(dir); 4139 inode_inc_iversion(dir);
4142 dir->i_mtime = dir->i_ctime = current_time(dir); 4140 dir->i_mtime = dir->i_ctime = current_time(dir);
4143 ret = btrfs_update_inode_fallback(trans, root, dir); 4141 ret = btrfs_update_inode_fallback(trans, root, dir);
@@ -4173,7 +4171,7 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
4173 goto out; 4171 goto out;
4174 } 4172 }
4175 4173
4176 err = btrfs_orphan_add(trans, inode); 4174 err = btrfs_orphan_add(trans, BTRFS_I(inode));
4177 if (err) 4175 if (err)
4178 goto out; 4176 goto out;
4179 4177
@@ -4184,7 +4182,7 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
4184 BTRFS_I(d_inode(dentry)), dentry->d_name.name, 4182 BTRFS_I(d_inode(dentry)), dentry->d_name.name,
4185 dentry->d_name.len); 4183 dentry->d_name.len);
4186 if (!err) { 4184 if (!err) {
4187 btrfs_i_size_write(inode, 0); 4185 btrfs_i_size_write(BTRFS_I(inode), 0);
4188 /* 4186 /*
4189 * Propagate the last_unlink_trans value of the deleted dir to 4187 * Propagate the last_unlink_trans value of the deleted dir to
4190 * its parent directory. This is to prevent an unrecoverable 4188 * its parent directory. This is to prevent an unrecoverable
@@ -4320,7 +4318,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
4320 * for non-free space inodes and ref cows, we want to back off from 4318 * for non-free space inodes and ref cows, we want to back off from
4321 * time to time 4319 * time to time
4322 */ 4320 */
4323 if (!btrfs_is_free_space_inode(inode) && 4321 if (!btrfs_is_free_space_inode(BTRFS_I(inode)) &&
4324 test_bit(BTRFS_ROOT_REF_COWS, &root->state)) 4322 test_bit(BTRFS_ROOT_REF_COWS, &root->state))
4325 be_nice = 1; 4323 be_nice = 1;
4326 4324
@@ -4336,7 +4334,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
4336 */ 4334 */
4337 if (test_bit(BTRFS_ROOT_REF_COWS, &root->state) || 4335 if (test_bit(BTRFS_ROOT_REF_COWS, &root->state) ||
4338 root == fs_info->tree_root) 4336 root == fs_info->tree_root)
4339 btrfs_drop_extent_cache(inode, ALIGN(new_size, 4337 btrfs_drop_extent_cache(BTRFS_I(inode), ALIGN(new_size,
4340 fs_info->sectorsize), 4338 fs_info->sectorsize),
4341 (u64)-1, 0); 4339 (u64)-1, 0);
4342 4340
@@ -4412,19 +4410,8 @@ search_again:
4412 if (found_type > min_type) { 4410 if (found_type > min_type) {
4413 del_item = 1; 4411 del_item = 1;
4414 } else { 4412 } else {
4415 if (item_end < new_size) { 4413 if (item_end < new_size)
4416 /*
4417 * With NO_HOLES mode, for the following mapping
4418 *
4419 * [0-4k][hole][8k-12k]
4420 *
4421 * if truncating isize down to 6k, it ends up
4422 * isize being 8k.
4423 */
4424 if (btrfs_fs_incompat(root->fs_info, NO_HOLES))
4425 last_size = new_size;
4426 break; 4414 break;
4427 }
4428 if (found_key.offset >= new_size) 4415 if (found_key.offset >= new_size)
4429 del_item = 1; 4416 del_item = 1;
4430 else 4417 else
@@ -4607,8 +4594,12 @@ out:
4607 btrfs_abort_transaction(trans, ret); 4594 btrfs_abort_transaction(trans, ret);
4608 } 4595 }
4609error: 4596error:
4610 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) 4597 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
4598 ASSERT(last_size >= new_size);
4599 if (!err && last_size > new_size)
4600 last_size = new_size;
4611 btrfs_ordered_update_i_size(inode, last_size, NULL); 4601 btrfs_ordered_update_i_size(inode, last_size, NULL);
4602 }
4612 4603
4613 btrfs_free_path(path); 4604 btrfs_free_path(path);
4614 4605
@@ -4835,7 +4826,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
4835 4826
4836 lock_extent_bits(io_tree, hole_start, block_end - 1, 4827 lock_extent_bits(io_tree, hole_start, block_end - 1,
4837 &cached_state); 4828 &cached_state);
4838 ordered = btrfs_lookup_ordered_range(inode, hole_start, 4829 ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), hole_start,
4839 block_end - hole_start); 4830 block_end - hole_start);
4840 if (!ordered) 4831 if (!ordered)
4841 break; 4832 break;
@@ -4847,7 +4838,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
4847 4838
4848 cur_offset = hole_start; 4839 cur_offset = hole_start;
4849 while (1) { 4840 while (1) {
4850 em = btrfs_get_extent(inode, NULL, 0, cur_offset, 4841 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, cur_offset,
4851 block_end - cur_offset, 0); 4842 block_end - cur_offset, 0);
4852 if (IS_ERR(em)) { 4843 if (IS_ERR(em)) {
4853 err = PTR_ERR(em); 4844 err = PTR_ERR(em);
@@ -4864,7 +4855,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
4864 hole_size); 4855 hole_size);
4865 if (err) 4856 if (err)
4866 break; 4857 break;
4867 btrfs_drop_extent_cache(inode, cur_offset, 4858 btrfs_drop_extent_cache(BTRFS_I(inode), cur_offset,
4868 cur_offset + hole_size - 1, 0); 4859 cur_offset + hole_size - 1, 0);
4869 hole_em = alloc_extent_map(); 4860 hole_em = alloc_extent_map();
4870 if (!hole_em) { 4861 if (!hole_em) {
@@ -4890,7 +4881,8 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
4890 write_unlock(&em_tree->lock); 4881 write_unlock(&em_tree->lock);
4891 if (err != -EEXIST) 4882 if (err != -EEXIST)
4892 break; 4883 break;
4893 btrfs_drop_extent_cache(inode, cur_offset, 4884 btrfs_drop_extent_cache(BTRFS_I(inode),
4885 cur_offset,
4894 cur_offset + 4886 cur_offset +
4895 hole_size - 1, 0); 4887 hole_size - 1, 0);
4896 } 4888 }
@@ -4987,7 +4979,7 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)
4987 * so we need to guarantee from this point on that everything 4979 * so we need to guarantee from this point on that everything
4988 * will be consistent. 4980 * will be consistent.
4989 */ 4981 */
4990 ret = btrfs_orphan_add(trans, inode); 4982 ret = btrfs_orphan_add(trans, BTRFS_I(inode));
4991 btrfs_end_transaction(trans); 4983 btrfs_end_transaction(trans);
4992 if (ret) 4984 if (ret)
4993 return ret; 4985 return ret;
@@ -4996,9 +4988,9 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)
4996 truncate_setsize(inode, newsize); 4988 truncate_setsize(inode, newsize);
4997 4989
4998 /* Disable nonlocked read DIO to avoid the end less truncate */ 4990 /* Disable nonlocked read DIO to avoid the end less truncate */
4999 btrfs_inode_block_unlocked_dio(inode); 4991 btrfs_inode_block_unlocked_dio(BTRFS_I(inode));
5000 inode_dio_wait(inode); 4992 inode_dio_wait(inode);
5001 btrfs_inode_resume_unlocked_dio(inode); 4993 btrfs_inode_resume_unlocked_dio(BTRFS_I(inode));
5002 4994
5003 ret = btrfs_truncate(inode); 4995 ret = btrfs_truncate(inode);
5004 if (ret && inode->i_nlink) { 4996 if (ret && inode->i_nlink) {
@@ -5007,7 +4999,7 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)
5007 /* To get a stable disk_i_size */ 4999 /* To get a stable disk_i_size */
5008 err = btrfs_wait_ordered_range(inode, 0, (u64)-1); 5000 err = btrfs_wait_ordered_range(inode, 0, (u64)-1);
5009 if (err) { 5001 if (err) {
5010 btrfs_orphan_del(NULL, inode); 5002 btrfs_orphan_del(NULL, BTRFS_I(inode));
5011 return err; 5003 return err;
5012 } 5004 }
5013 5005
@@ -5019,11 +5011,11 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)
5019 */ 5011 */
5020 trans = btrfs_join_transaction(root); 5012 trans = btrfs_join_transaction(root);
5021 if (IS_ERR(trans)) { 5013 if (IS_ERR(trans)) {
5022 btrfs_orphan_del(NULL, inode); 5014 btrfs_orphan_del(NULL, BTRFS_I(inode));
5023 return ret; 5015 return ret;
5024 } 5016 }
5025 i_size_write(inode, BTRFS_I(inode)->disk_i_size); 5017 i_size_write(inode, BTRFS_I(inode)->disk_i_size);
5026 err = btrfs_orphan_del(trans, inode); 5018 err = btrfs_orphan_del(trans, BTRFS_I(inode));
5027 if (err) 5019 if (err)
5028 btrfs_abort_transaction(trans, err); 5020 btrfs_abort_transaction(trans, err);
5029 btrfs_end_transaction(trans); 5021 btrfs_end_transaction(trans);
@@ -5181,18 +5173,18 @@ void btrfs_evict_inode(struct inode *inode)
5181 if (inode->i_nlink && 5173 if (inode->i_nlink &&
5182 ((btrfs_root_refs(&root->root_item) != 0 && 5174 ((btrfs_root_refs(&root->root_item) != 0 &&
5183 root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID) || 5175 root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID) ||
5184 btrfs_is_free_space_inode(inode))) 5176 btrfs_is_free_space_inode(BTRFS_I(inode))))
5185 goto no_delete; 5177 goto no_delete;
5186 5178
5187 if (is_bad_inode(inode)) { 5179 if (is_bad_inode(inode)) {
5188 btrfs_orphan_del(NULL, inode); 5180 btrfs_orphan_del(NULL, BTRFS_I(inode));
5189 goto no_delete; 5181 goto no_delete;
5190 } 5182 }
5191 /* do we really want it for ->i_nlink > 0 and zero btrfs_root_refs? */ 5183 /* do we really want it for ->i_nlink > 0 and zero btrfs_root_refs? */
5192 if (!special_file(inode->i_mode)) 5184 if (!special_file(inode->i_mode))
5193 btrfs_wait_ordered_range(inode, 0, (u64)-1); 5185 btrfs_wait_ordered_range(inode, 0, (u64)-1);
5194 5186
5195 btrfs_free_io_failure_record(inode, 0, (u64)-1); 5187 btrfs_free_io_failure_record(BTRFS_I(inode), 0, (u64)-1);
5196 5188
5197 if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) { 5189 if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) {
5198 BUG_ON(test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM, 5190 BUG_ON(test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
@@ -5208,20 +5200,20 @@ void btrfs_evict_inode(struct inode *inode)
5208 5200
5209 ret = btrfs_commit_inode_delayed_inode(BTRFS_I(inode)); 5201 ret = btrfs_commit_inode_delayed_inode(BTRFS_I(inode));
5210 if (ret) { 5202 if (ret) {
5211 btrfs_orphan_del(NULL, inode); 5203 btrfs_orphan_del(NULL, BTRFS_I(inode));
5212 goto no_delete; 5204 goto no_delete;
5213 } 5205 }
5214 5206
5215 rsv = btrfs_alloc_block_rsv(fs_info, BTRFS_BLOCK_RSV_TEMP); 5207 rsv = btrfs_alloc_block_rsv(fs_info, BTRFS_BLOCK_RSV_TEMP);
5216 if (!rsv) { 5208 if (!rsv) {
5217 btrfs_orphan_del(NULL, inode); 5209 btrfs_orphan_del(NULL, BTRFS_I(inode));
5218 goto no_delete; 5210 goto no_delete;
5219 } 5211 }
5220 rsv->size = min_size; 5212 rsv->size = min_size;
5221 rsv->failfast = 1; 5213 rsv->failfast = 1;
5222 global_rsv = &fs_info->global_block_rsv; 5214 global_rsv = &fs_info->global_block_rsv;
5223 5215
5224 btrfs_i_size_write(inode, 0); 5216 btrfs_i_size_write(BTRFS_I(inode), 0);
5225 5217
5226 /* 5218 /*
5227 * This is a bit simpler than btrfs_truncate since we've already 5219 * This is a bit simpler than btrfs_truncate since we've already
@@ -5256,14 +5248,14 @@ void btrfs_evict_inode(struct inode *inode)
5256 btrfs_warn(fs_info, 5248 btrfs_warn(fs_info,
5257 "Could not get space for a delete, will truncate on mount %d", 5249 "Could not get space for a delete, will truncate on mount %d",
5258 ret); 5250 ret);
5259 btrfs_orphan_del(NULL, inode); 5251 btrfs_orphan_del(NULL, BTRFS_I(inode));
5260 btrfs_free_block_rsv(fs_info, rsv); 5252 btrfs_free_block_rsv(fs_info, rsv);
5261 goto no_delete; 5253 goto no_delete;
5262 } 5254 }
5263 5255
5264 trans = btrfs_join_transaction(root); 5256 trans = btrfs_join_transaction(root);
5265 if (IS_ERR(trans)) { 5257 if (IS_ERR(trans)) {
5266 btrfs_orphan_del(NULL, inode); 5258 btrfs_orphan_del(NULL, BTRFS_I(inode));
5267 btrfs_free_block_rsv(fs_info, rsv); 5259 btrfs_free_block_rsv(fs_info, rsv);
5268 goto no_delete; 5260 goto no_delete;
5269 } 5261 }
@@ -5289,7 +5281,7 @@ void btrfs_evict_inode(struct inode *inode)
5289 if (ret) { 5281 if (ret) {
5290 ret = btrfs_commit_transaction(trans); 5282 ret = btrfs_commit_transaction(trans);
5291 if (ret) { 5283 if (ret) {
5292 btrfs_orphan_del(NULL, inode); 5284 btrfs_orphan_del(NULL, BTRFS_I(inode));
5293 btrfs_free_block_rsv(fs_info, rsv); 5285 btrfs_free_block_rsv(fs_info, rsv);
5294 goto no_delete; 5286 goto no_delete;
5295 } 5287 }
@@ -5318,9 +5310,9 @@ void btrfs_evict_inode(struct inode *inode)
5318 */ 5310 */
5319 if (ret == 0) { 5311 if (ret == 0) {
5320 trans->block_rsv = root->orphan_block_rsv; 5312 trans->block_rsv = root->orphan_block_rsv;
5321 btrfs_orphan_del(trans, inode); 5313 btrfs_orphan_del(trans, BTRFS_I(inode));
5322 } else { 5314 } else {
5323 btrfs_orphan_del(NULL, inode); 5315 btrfs_orphan_del(NULL, BTRFS_I(inode));
5324 } 5316 }
5325 5317
5326 trans->block_rsv = &fs_info->trans_block_rsv; 5318 trans->block_rsv = &fs_info->trans_block_rsv;
@@ -5898,7 +5890,8 @@ int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
5898 if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags)) 5890 if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))
5899 return 0; 5891 return 0;
5900 5892
5901 if (btrfs_fs_closing(root->fs_info) && btrfs_is_free_space_inode(inode)) 5893 if (btrfs_fs_closing(root->fs_info) &&
5894 btrfs_is_free_space_inode(BTRFS_I(inode)))
5902 nolock = true; 5895 nolock = true;
5903 5896
5904 if (wbc->sync_mode == WB_SYNC_ALL) { 5897 if (wbc->sync_mode == WB_SYNC_ALL) {
@@ -5978,15 +5971,15 @@ static int btrfs_update_time(struct inode *inode, struct timespec *now,
5978 * and then set the in-memory index_cnt variable to reflect 5971 * and then set the in-memory index_cnt variable to reflect
5979 * free sequence numbers 5972 * free sequence numbers
5980 */ 5973 */
5981static int btrfs_set_inode_index_count(struct inode *inode) 5974static int btrfs_set_inode_index_count(struct btrfs_inode *inode)
5982{ 5975{
5983 struct btrfs_root *root = BTRFS_I(inode)->root; 5976 struct btrfs_root *root = inode->root;
5984 struct btrfs_key key, found_key; 5977 struct btrfs_key key, found_key;
5985 struct btrfs_path *path; 5978 struct btrfs_path *path;
5986 struct extent_buffer *leaf; 5979 struct extent_buffer *leaf;
5987 int ret; 5980 int ret;
5988 5981
5989 key.objectid = btrfs_ino(BTRFS_I(inode)); 5982 key.objectid = btrfs_ino(inode);
5990 key.type = BTRFS_DIR_INDEX_KEY; 5983 key.type = BTRFS_DIR_INDEX_KEY;
5991 key.offset = (u64)-1; 5984 key.offset = (u64)-1;
5992 5985
@@ -6009,7 +6002,7 @@ static int btrfs_set_inode_index_count(struct inode *inode)
6009 * else has to start at 2 6002 * else has to start at 2
6010 */ 6003 */
6011 if (path->slots[0] == 0) { 6004 if (path->slots[0] == 0) {
6012 BTRFS_I(inode)->index_cnt = 2; 6005 inode->index_cnt = 2;
6013 goto out; 6006 goto out;
6014 } 6007 }
6015 6008
@@ -6018,13 +6011,13 @@ static int btrfs_set_inode_index_count(struct inode *inode)
6018 leaf = path->nodes[0]; 6011 leaf = path->nodes[0];
6019 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 6012 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
6020 6013
6021 if (found_key.objectid != btrfs_ino(BTRFS_I(inode)) || 6014 if (found_key.objectid != btrfs_ino(inode) ||
6022 found_key.type != BTRFS_DIR_INDEX_KEY) { 6015 found_key.type != BTRFS_DIR_INDEX_KEY) {
6023 BTRFS_I(inode)->index_cnt = 2; 6016 inode->index_cnt = 2;
6024 goto out; 6017 goto out;
6025 } 6018 }
6026 6019
6027 BTRFS_I(inode)->index_cnt = found_key.offset + 1; 6020 inode->index_cnt = found_key.offset + 1;
6028out: 6021out:
6029 btrfs_free_path(path); 6022 btrfs_free_path(path);
6030 return ret; 6023 return ret;
@@ -6034,12 +6027,12 @@ out:
6034 * helper to find a free sequence number in a given directory. This current 6027 * helper to find a free sequence number in a given directory. This current
6035 * code is very simple, later versions will do smarter things in the btree 6028 * code is very simple, later versions will do smarter things in the btree
6036 */ 6029 */
6037int btrfs_set_inode_index(struct inode *dir, u64 *index) 6030int btrfs_set_inode_index(struct btrfs_inode *dir, u64 *index)
6038{ 6031{
6039 int ret = 0; 6032 int ret = 0;
6040 6033
6041 if (BTRFS_I(dir)->index_cnt == (u64)-1) { 6034 if (dir->index_cnt == (u64)-1) {
6042 ret = btrfs_inode_delayed_dir_index_count(BTRFS_I(dir)); 6035 ret = btrfs_inode_delayed_dir_index_count(dir);
6043 if (ret) { 6036 if (ret) {
6044 ret = btrfs_set_inode_index_count(dir); 6037 ret = btrfs_set_inode_index_count(dir);
6045 if (ret) 6038 if (ret)
@@ -6047,8 +6040,8 @@ int btrfs_set_inode_index(struct inode *dir, u64 *index)
6047 } 6040 }
6048 } 6041 }
6049 6042
6050 *index = BTRFS_I(dir)->index_cnt; 6043 *index = dir->index_cnt;
6051 BTRFS_I(dir)->index_cnt++; 6044 dir->index_cnt++;
6052 6045
6053 return ret; 6046 return ret;
6054} 6047}
@@ -6109,7 +6102,7 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
6109 if (dir && name) { 6102 if (dir && name) {
6110 trace_btrfs_inode_request(dir); 6103 trace_btrfs_inode_request(dir);
6111 6104
6112 ret = btrfs_set_inode_index(dir, index); 6105 ret = btrfs_set_inode_index(BTRFS_I(dir), index);
6113 if (ret) { 6106 if (ret) {
6114 btrfs_free_path(path); 6107 btrfs_free_path(path);
6115 iput(inode); 6108 iput(inode);
@@ -6244,18 +6237,18 @@ static inline u8 btrfs_inode_type(struct inode *inode)
6244 * inode to the parent directory. 6237 * inode to the parent directory.
6245 */ 6238 */
6246int btrfs_add_link(struct btrfs_trans_handle *trans, 6239int btrfs_add_link(struct btrfs_trans_handle *trans,
6247 struct inode *parent_inode, struct inode *inode, 6240 struct btrfs_inode *parent_inode, struct btrfs_inode *inode,
6248 const char *name, int name_len, int add_backref, u64 index) 6241 const char *name, int name_len, int add_backref, u64 index)
6249{ 6242{
6250 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 6243 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
6251 int ret = 0; 6244 int ret = 0;
6252 struct btrfs_key key; 6245 struct btrfs_key key;
6253 struct btrfs_root *root = BTRFS_I(parent_inode)->root; 6246 struct btrfs_root *root = parent_inode->root;
6254 u64 ino = btrfs_ino(BTRFS_I(inode)); 6247 u64 ino = btrfs_ino(inode);
6255 u64 parent_ino = btrfs_ino(BTRFS_I(parent_inode)); 6248 u64 parent_ino = btrfs_ino(parent_inode);
6256 6249
6257 if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) { 6250 if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
6258 memcpy(&key, &BTRFS_I(inode)->root->root_key, sizeof(key)); 6251 memcpy(&key, &inode->root->root_key, sizeof(key));
6259 } else { 6252 } else {
6260 key.objectid = ino; 6253 key.objectid = ino;
6261 key.type = BTRFS_INODE_ITEM_KEY; 6254 key.type = BTRFS_INODE_ITEM_KEY;
@@ -6277,7 +6270,7 @@ int btrfs_add_link(struct btrfs_trans_handle *trans,
6277 6270
6278 ret = btrfs_insert_dir_item(trans, root, name, name_len, 6271 ret = btrfs_insert_dir_item(trans, root, name, name_len,
6279 parent_inode, &key, 6272 parent_inode, &key,
6280 btrfs_inode_type(inode), index); 6273 btrfs_inode_type(&inode->vfs_inode), index);
6281 if (ret == -EEXIST || ret == -EOVERFLOW) 6274 if (ret == -EEXIST || ret == -EOVERFLOW)
6282 goto fail_dir_item; 6275 goto fail_dir_item;
6283 else if (ret) { 6276 else if (ret) {
@@ -6285,12 +6278,12 @@ int btrfs_add_link(struct btrfs_trans_handle *trans,
6285 return ret; 6278 return ret;
6286 } 6279 }
6287 6280
6288 btrfs_i_size_write(parent_inode, parent_inode->i_size + 6281 btrfs_i_size_write(parent_inode, parent_inode->vfs_inode.i_size +
6289 name_len * 2); 6282 name_len * 2);
6290 inode_inc_iversion(parent_inode); 6283 inode_inc_iversion(&parent_inode->vfs_inode);
6291 parent_inode->i_mtime = parent_inode->i_ctime = 6284 parent_inode->vfs_inode.i_mtime = parent_inode->vfs_inode.i_ctime =
6292 current_time(parent_inode); 6285 current_time(&parent_inode->vfs_inode);
6293 ret = btrfs_update_inode(trans, root, parent_inode); 6286 ret = btrfs_update_inode(trans, root, &parent_inode->vfs_inode);
6294 if (ret) 6287 if (ret)
6295 btrfs_abort_transaction(trans, ret); 6288 btrfs_abort_transaction(trans, ret);
6296 return ret; 6289 return ret;
@@ -6314,8 +6307,8 @@ fail_dir_item:
6314} 6307}
6315 6308
6316static int btrfs_add_nondir(struct btrfs_trans_handle *trans, 6309static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
6317 struct inode *dir, struct dentry *dentry, 6310 struct btrfs_inode *dir, struct dentry *dentry,
6318 struct inode *inode, int backref, u64 index) 6311 struct btrfs_inode *inode, int backref, u64 index)
6319{ 6312{
6320 int err = btrfs_add_link(trans, dir, inode, 6313 int err = btrfs_add_link(trans, dir, inode,
6321 dentry->d_name.name, dentry->d_name.len, 6314 dentry->d_name.name, dentry->d_name.len,
@@ -6371,7 +6364,8 @@ static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
6371 if (err) 6364 if (err)
6372 goto out_unlock_inode; 6365 goto out_unlock_inode;
6373 6366
6374 err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index); 6367 err = btrfs_add_nondir(trans, BTRFS_I(dir), dentry, BTRFS_I(inode),
6368 0, index);
6375 if (err) { 6369 if (err) {
6376 goto out_unlock_inode; 6370 goto out_unlock_inode;
6377 } else { 6371 } else {
@@ -6448,7 +6442,8 @@ static int btrfs_create(struct inode *dir, struct dentry *dentry,
6448 if (err) 6442 if (err)
6449 goto out_unlock_inode; 6443 goto out_unlock_inode;
6450 6444
6451 err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index); 6445 err = btrfs_add_nondir(trans, BTRFS_I(dir), dentry, BTRFS_I(inode),
6446 0, index);
6452 if (err) 6447 if (err)
6453 goto out_unlock_inode; 6448 goto out_unlock_inode;
6454 6449
@@ -6490,7 +6485,7 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
6490 if (inode->i_nlink >= BTRFS_LINK_MAX) 6485 if (inode->i_nlink >= BTRFS_LINK_MAX)
6491 return -EMLINK; 6486 return -EMLINK;
6492 6487
6493 err = btrfs_set_inode_index(dir, &index); 6488 err = btrfs_set_inode_index(BTRFS_I(dir), &index);
6494 if (err) 6489 if (err)
6495 goto fail; 6490 goto fail;
6496 6491
@@ -6514,7 +6509,8 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
6514 ihold(inode); 6509 ihold(inode);
6515 set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags); 6510 set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);
6516 6511
6517 err = btrfs_add_nondir(trans, dir, dentry, inode, 1, index); 6512 err = btrfs_add_nondir(trans, BTRFS_I(dir), dentry, BTRFS_I(inode),
6513 1, index);
6518 6514
6519 if (err) { 6515 if (err) {
6520 drop_inode = 1; 6516 drop_inode = 1;
@@ -6528,7 +6524,7 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
6528 * If new hard link count is 1, it's a file created 6524 * If new hard link count is 1, it's a file created
6529 * with open(2) O_TMPFILE flag. 6525 * with open(2) O_TMPFILE flag.
6530 */ 6526 */
6531 err = btrfs_orphan_del(trans, inode); 6527 err = btrfs_orphan_del(trans, BTRFS_I(inode));
6532 if (err) 6528 if (err)
6533 goto fail; 6529 goto fail;
6534 } 6530 }
@@ -6589,13 +6585,14 @@ static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
6589 if (err) 6585 if (err)
6590 goto out_fail_inode; 6586 goto out_fail_inode;
6591 6587
6592 btrfs_i_size_write(inode, 0); 6588 btrfs_i_size_write(BTRFS_I(inode), 0);
6593 err = btrfs_update_inode(trans, root, inode); 6589 err = btrfs_update_inode(trans, root, inode);
6594 if (err) 6590 if (err)
6595 goto out_fail_inode; 6591 goto out_fail_inode;
6596 6592
6597 err = btrfs_add_link(trans, dir, inode, dentry->d_name.name, 6593 err = btrfs_add_link(trans, BTRFS_I(dir), BTRFS_I(inode),
6598 dentry->d_name.len, 0, index); 6594 dentry->d_name.name,
6595 dentry->d_name.len, 0, index);
6599 if (err) 6596 if (err)
6600 goto out_fail_inode; 6597 goto out_fail_inode;
6601 6598
@@ -6725,25 +6722,26 @@ static noinline int uncompress_inline(struct btrfs_path *path,
6725 * This also copies inline extents directly into the page. 6722 * This also copies inline extents directly into the page.
6726 */ 6723 */
6727 6724
6728struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page, 6725struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,
6729 size_t pg_offset, u64 start, u64 len, 6726 struct page *page,
6730 int create) 6727 size_t pg_offset, u64 start, u64 len,
6728 int create)
6731{ 6729{
6732 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 6730 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
6733 int ret; 6731 int ret;
6734 int err = 0; 6732 int err = 0;
6735 u64 extent_start = 0; 6733 u64 extent_start = 0;
6736 u64 extent_end = 0; 6734 u64 extent_end = 0;
6737 u64 objectid = btrfs_ino(BTRFS_I(inode)); 6735 u64 objectid = btrfs_ino(inode);
6738 u32 found_type; 6736 u32 found_type;
6739 struct btrfs_path *path = NULL; 6737 struct btrfs_path *path = NULL;
6740 struct btrfs_root *root = BTRFS_I(inode)->root; 6738 struct btrfs_root *root = inode->root;
6741 struct btrfs_file_extent_item *item; 6739 struct btrfs_file_extent_item *item;
6742 struct extent_buffer *leaf; 6740 struct extent_buffer *leaf;
6743 struct btrfs_key found_key; 6741 struct btrfs_key found_key;
6744 struct extent_map *em = NULL; 6742 struct extent_map *em = NULL;
6745 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 6743 struct extent_map_tree *em_tree = &inode->extent_tree;
6746 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 6744 struct extent_io_tree *io_tree = &inode->io_tree;
6747 struct btrfs_trans_handle *trans = NULL; 6745 struct btrfs_trans_handle *trans = NULL;
6748 const bool new_inline = !page || create; 6746 const bool new_inline = !page || create;
6749 6747
@@ -6856,7 +6854,8 @@ next:
6856 goto not_found_em; 6854 goto not_found_em;
6857 } 6855 }
6858 6856
6859 btrfs_extent_item_to_extent_map(inode, path, item, new_inline, em); 6857 btrfs_extent_item_to_extent_map(inode, path, item,
6858 new_inline, em);
6860 6859
6861 if (found_type == BTRFS_FILE_EXTENT_REG || 6860 if (found_type == BTRFS_FILE_EXTENT_REG ||
6862 found_type == BTRFS_FILE_EXTENT_PREALLOC) { 6861 found_type == BTRFS_FILE_EXTENT_PREALLOC) {
@@ -6992,7 +6991,7 @@ insert:
6992 write_unlock(&em_tree->lock); 6991 write_unlock(&em_tree->lock);
6993out: 6992out:
6994 6993
6995 trace_btrfs_get_extent(root, BTRFS_I(inode), em); 6994 trace_btrfs_get_extent(root, inode, em);
6996 6995
6997 btrfs_free_path(path); 6996 btrfs_free_path(path);
6998 if (trans) { 6997 if (trans) {
@@ -7008,9 +7007,10 @@ out:
7008 return em; 7007 return em;
7009} 7008}
7010 7009
7011struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page, 7010struct extent_map *btrfs_get_extent_fiemap(struct btrfs_inode *inode,
7012 size_t pg_offset, u64 start, u64 len, 7011 struct page *page,
7013 int create) 7012 size_t pg_offset, u64 start, u64 len,
7013 int create)
7014{ 7014{
7015 struct extent_map *em; 7015 struct extent_map *em;
7016 struct extent_map *hole_em = NULL; 7016 struct extent_map *hole_em = NULL;
@@ -7047,7 +7047,7 @@ struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *pag
7047 em = NULL; 7047 em = NULL;
7048 7048
7049 /* ok, we didn't find anything, lets look for delalloc */ 7049 /* ok, we didn't find anything, lets look for delalloc */
7050 found = count_range_bits(&BTRFS_I(inode)->io_tree, &range_start, 7050 found = count_range_bits(&inode->io_tree, &range_start,
7051 end, len, EXTENT_DELALLOC, 1); 7051 end, len, EXTENT_DELALLOC, 1);
7052 found_end = range_start + found; 7052 found_end = range_start + found;
7053 if (found_end < range_start) 7053 if (found_end < range_start)
@@ -7162,7 +7162,7 @@ static struct extent_map *btrfs_create_dio_extent(struct inode *inode,
7162 if (ret) { 7162 if (ret) {
7163 if (em) { 7163 if (em) {
7164 free_extent_map(em); 7164 free_extent_map(em);
7165 btrfs_drop_extent_cache(inode, start, 7165 btrfs_drop_extent_cache(BTRFS_I(inode), start,
7166 start + len - 1, 0); 7166 start + len - 1, 0);
7167 } 7167 }
7168 em = ERR_PTR(ret); 7168 em = ERR_PTR(ret);
@@ -7423,7 +7423,7 @@ static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend,
7423 * doing DIO to, so we need to make sure there's no ordered 7423 * doing DIO to, so we need to make sure there's no ordered
7424 * extents in this range. 7424 * extents in this range.
7425 */ 7425 */
7426 ordered = btrfs_lookup_ordered_range(inode, lockstart, 7426 ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), lockstart,
7427 lockend - lockstart + 1); 7427 lockend - lockstart + 1);
7428 7428
7429 /* 7429 /*
@@ -7529,7 +7529,7 @@ static struct extent_map *create_io_em(struct inode *inode, u64 start, u64 len,
7529 } 7529 }
7530 7530
7531 do { 7531 do {
7532 btrfs_drop_extent_cache(inode, em->start, 7532 btrfs_drop_extent_cache(BTRFS_I(inode), em->start,
7533 em->start + em->len - 1, 0); 7533 em->start + em->len - 1, 0);
7534 write_lock(&em_tree->lock); 7534 write_lock(&em_tree->lock);
7535 ret = add_extent_mapping(em_tree, em, 1); 7535 ret = add_extent_mapping(em_tree, em, 1);
@@ -7617,7 +7617,7 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
7617 goto err; 7617 goto err;
7618 } 7618 }
7619 7619
7620 em = btrfs_get_extent(inode, NULL, 0, start, len, 0); 7620 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, start, len, 0);
7621 if (IS_ERR(em)) { 7621 if (IS_ERR(em)) {
7622 ret = PTR_ERR(em); 7622 ret = PTR_ERR(em);
7623 goto unlock_err; 7623 goto unlock_err;
@@ -7854,7 +7854,7 @@ static int dio_read_error(struct inode *inode, struct bio *failed_bio,
7854 ret = btrfs_check_dio_repairable(inode, failed_bio, failrec, 7854 ret = btrfs_check_dio_repairable(inode, failed_bio, failrec,
7855 failed_mirror); 7855 failed_mirror);
7856 if (!ret) { 7856 if (!ret) {
7857 free_io_failure(inode, failrec); 7857 free_io_failure(BTRFS_I(inode), failrec);
7858 return -EIO; 7858 return -EIO;
7859 } 7859 }
7860 7860
@@ -7868,7 +7868,7 @@ static int dio_read_error(struct inode *inode, struct bio *failed_bio,
7868 bio = btrfs_create_repair_bio(inode, failed_bio, failrec, page, 7868 bio = btrfs_create_repair_bio(inode, failed_bio, failrec, page,
7869 pgoff, isector, repair_endio, repair_arg); 7869 pgoff, isector, repair_endio, repair_arg);
7870 if (!bio) { 7870 if (!bio) {
7871 free_io_failure(inode, failrec); 7871 free_io_failure(BTRFS_I(inode), failrec);
7872 return -EIO; 7872 return -EIO;
7873 } 7873 }
7874 bio_set_op_attrs(bio, REQ_OP_READ, read_mode); 7874 bio_set_op_attrs(bio, REQ_OP_READ, read_mode);
@@ -7879,7 +7879,7 @@ static int dio_read_error(struct inode *inode, struct bio *failed_bio,
7879 7879
7880 ret = submit_dio_repair_bio(inode, bio, failrec->this_mirror); 7880 ret = submit_dio_repair_bio(inode, bio, failrec->this_mirror);
7881 if (ret) { 7881 if (ret) {
7882 free_io_failure(inode, failrec); 7882 free_io_failure(BTRFS_I(inode), failrec);
7883 bio_put(bio); 7883 bio_put(bio);
7884 } 7884 }
7885 7885
@@ -7909,7 +7909,7 @@ static void btrfs_retry_endio_nocsum(struct bio *bio)
7909 7909
7910 done->uptodate = 1; 7910 done->uptodate = 1;
7911 bio_for_each_segment_all(bvec, bio, i) 7911 bio_for_each_segment_all(bvec, bio, i)
7912 clean_io_failure(done->inode, done->start, bvec->bv_page, 0); 7912 clean_io_failure(BTRFS_I(done->inode), done->start, bvec->bv_page, 0);
7913end: 7913end:
7914 complete(&done->done); 7914 complete(&done->done);
7915 bio_put(bio); 7915 bio_put(bio);
@@ -7995,7 +7995,7 @@ static void btrfs_retry_endio(struct bio *bio)
7995 bvec->bv_page, bvec->bv_offset, 7995 bvec->bv_page, bvec->bv_offset,
7996 done->start, bvec->bv_len); 7996 done->start, bvec->bv_len);
7997 if (!ret) 7997 if (!ret)
7998 clean_io_failure(done->inode, done->start, 7998 clean_io_failure(BTRFS_I(done->inode), done->start,
7999 bvec->bv_page, bvec->bv_offset); 7999 bvec->bv_page, bvec->bv_offset);
8000 else 8000 else
8001 uptodate = 0; 8001 uptodate = 0;
@@ -8796,7 +8796,7 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,
8796 lock_extent_bits(tree, page_start, page_end, &cached_state); 8796 lock_extent_bits(tree, page_start, page_end, &cached_state);
8797again: 8797again:
8798 start = page_start; 8798 start = page_start;
8799 ordered = btrfs_lookup_ordered_range(inode, start, 8799 ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), start,
8800 page_end - start + 1); 8800 page_end - start + 1);
8801 if (ordered) { 8801 if (ordered) {
8802 end = min(page_end, ordered->file_offset + ordered->len - 1); 8802 end = min(page_end, ordered->file_offset + ordered->len - 1);
@@ -8962,7 +8962,8 @@ again:
8962 * we can't set the delalloc bits if there are pending ordered 8962 * we can't set the delalloc bits if there are pending ordered
8963 * extents. Drop our locks and wait for them to finish 8963 * extents. Drop our locks and wait for them to finish
8964 */ 8964 */
8965 ordered = btrfs_lookup_ordered_range(inode, page_start, PAGE_SIZE); 8965 ordered = btrfs_lookup_ordered_range(BTRFS_I(inode), page_start,
8966 PAGE_SIZE);
8966 if (ordered) { 8967 if (ordered) {
8967 unlock_extent_cached(io_tree, page_start, page_end, 8968 unlock_extent_cached(io_tree, page_start, page_end,
8968 &cached_state, GFP_NOFS); 8969 &cached_state, GFP_NOFS);
@@ -9160,7 +9161,7 @@ static int btrfs_truncate(struct inode *inode)
9160 9161
9161 if (ret == 0 && inode->i_nlink > 0) { 9162 if (ret == 0 && inode->i_nlink > 0) {
9162 trans->block_rsv = root->orphan_block_rsv; 9163 trans->block_rsv = root->orphan_block_rsv;
9163 ret = btrfs_orphan_del(trans, inode); 9164 ret = btrfs_orphan_del(trans, BTRFS_I(inode));
9164 if (ret) 9165 if (ret)
9165 err = ret; 9166 err = ret;
9166 } 9167 }
@@ -9205,7 +9206,7 @@ int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
9205 inode->i_fop = &btrfs_dir_file_operations; 9206 inode->i_fop = &btrfs_dir_file_operations;
9206 9207
9207 set_nlink(inode, 1); 9208 set_nlink(inode, 1);
9208 btrfs_i_size_write(inode, 0); 9209 btrfs_i_size_write(BTRFS_I(inode), 0);
9209 unlock_new_inode(inode); 9210 unlock_new_inode(inode);
9210 9211
9211 err = btrfs_subvol_inherit_props(trans, new_root, parent_root); 9212 err = btrfs_subvol_inherit_props(trans, new_root, parent_root);
@@ -9278,7 +9279,7 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
9278#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS 9279#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
9279void btrfs_test_destroy_inode(struct inode *inode) 9280void btrfs_test_destroy_inode(struct inode *inode)
9280{ 9281{
9281 btrfs_drop_extent_cache(inode, 0, (u64)-1, 0); 9282 btrfs_drop_extent_cache(BTRFS_I(inode), 0, (u64)-1, 0);
9282 kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode)); 9283 kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
9283} 9284}
9284#endif 9285#endif
@@ -9333,7 +9334,7 @@ void btrfs_destroy_inode(struct inode *inode)
9333 } 9334 }
9334 btrfs_qgroup_check_reserved_leak(inode); 9335 btrfs_qgroup_check_reserved_leak(inode);
9335 inode_tree_del(inode); 9336 inode_tree_del(inode);
9336 btrfs_drop_extent_cache(inode, 0, (u64)-1, 0); 9337 btrfs_drop_extent_cache(BTRFS_I(inode), 0, (u64)-1, 0);
9337free: 9338free:
9338 call_rcu(&inode->i_rcu, btrfs_i_callback); 9339 call_rcu(&inode->i_rcu, btrfs_i_callback);
9339} 9340}
@@ -9480,10 +9481,10 @@ static int btrfs_rename_exchange(struct inode *old_dir,
9480 * We need to find a free sequence number both in the source and 9481 * We need to find a free sequence number both in the source and
9481 * in the destination directory for the exchange. 9482 * in the destination directory for the exchange.
9482 */ 9483 */
9483 ret = btrfs_set_inode_index(new_dir, &old_idx); 9484 ret = btrfs_set_inode_index(BTRFS_I(new_dir), &old_idx);
9484 if (ret) 9485 if (ret)
9485 goto out_fail; 9486 goto out_fail;
9486 ret = btrfs_set_inode_index(old_dir, &new_idx); 9487 ret = btrfs_set_inode_index(BTRFS_I(old_dir), &new_idx);
9487 if (ret) 9488 if (ret)
9488 goto out_fail; 9489 goto out_fail;
9489 9490
@@ -9581,7 +9582,7 @@ static int btrfs_rename_exchange(struct inode *old_dir,
9581 goto out_fail; 9582 goto out_fail;
9582 } 9583 }
9583 9584
9584 ret = btrfs_add_link(trans, new_dir, old_inode, 9585 ret = btrfs_add_link(trans, BTRFS_I(new_dir), BTRFS_I(old_inode),
9585 new_dentry->d_name.name, 9586 new_dentry->d_name.name,
9586 new_dentry->d_name.len, 0, old_idx); 9587 new_dentry->d_name.len, 0, old_idx);
9587 if (ret) { 9588 if (ret) {
@@ -9589,7 +9590,7 @@ static int btrfs_rename_exchange(struct inode *old_dir,
9589 goto out_fail; 9590 goto out_fail;
9590 } 9591 }
9591 9592
9592 ret = btrfs_add_link(trans, old_dir, new_inode, 9593 ret = btrfs_add_link(trans, BTRFS_I(old_dir), BTRFS_I(new_inode),
9593 old_dentry->d_name.name, 9594 old_dentry->d_name.name,
9594 old_dentry->d_name.len, 0, new_idx); 9595 old_dentry->d_name.len, 0, new_idx);
9595 if (ret) { 9596 if (ret) {
@@ -9691,8 +9692,8 @@ static int btrfs_whiteout_for_rename(struct btrfs_trans_handle *trans,
9691 if (ret) 9692 if (ret)
9692 goto out; 9693 goto out;
9693 9694
9694 ret = btrfs_add_nondir(trans, dir, dentry, 9695 ret = btrfs_add_nondir(trans, BTRFS_I(dir), dentry,
9695 inode, 0, index); 9696 BTRFS_I(inode), 0, index);
9696 if (ret) 9697 if (ret)
9697 goto out; 9698 goto out;
9698 9699
@@ -9791,7 +9792,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
9791 if (dest != root) 9792 if (dest != root)
9792 btrfs_record_root_in_trans(trans, dest); 9793 btrfs_record_root_in_trans(trans, dest);
9793 9794
9794 ret = btrfs_set_inode_index(new_dir, &index); 9795 ret = btrfs_set_inode_index(BTRFS_I(new_dir), &index);
9795 if (ret) 9796 if (ret)
9796 goto out_fail; 9797 goto out_fail;
9797 9798
@@ -9858,14 +9859,15 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
9858 new_dentry->d_name.len); 9859 new_dentry->d_name.len);
9859 } 9860 }
9860 if (!ret && new_inode->i_nlink == 0) 9861 if (!ret && new_inode->i_nlink == 0)
9861 ret = btrfs_orphan_add(trans, d_inode(new_dentry)); 9862 ret = btrfs_orphan_add(trans,
9863 BTRFS_I(d_inode(new_dentry)));
9862 if (ret) { 9864 if (ret) {
9863 btrfs_abort_transaction(trans, ret); 9865 btrfs_abort_transaction(trans, ret);
9864 goto out_fail; 9866 goto out_fail;
9865 } 9867 }
9866 } 9868 }
9867 9869
9868 ret = btrfs_add_link(trans, new_dir, old_inode, 9870 ret = btrfs_add_link(trans, BTRFS_I(new_dir), BTRFS_I(old_inode),
9869 new_dentry->d_name.name, 9871 new_dentry->d_name.name,
9870 new_dentry->d_name.len, 0, index); 9872 new_dentry->d_name.len, 0, index);
9871 if (ret) { 9873 if (ret) {
@@ -10232,7 +10234,7 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
10232 inode_nohighmem(inode); 10234 inode_nohighmem(inode);
10233 inode->i_mapping->a_ops = &btrfs_symlink_aops; 10235 inode->i_mapping->a_ops = &btrfs_symlink_aops;
10234 inode_set_bytes(inode, name_len); 10236 inode_set_bytes(inode, name_len);
10235 btrfs_i_size_write(inode, name_len); 10237 btrfs_i_size_write(BTRFS_I(inode), name_len);
10236 err = btrfs_update_inode(trans, root, inode); 10238 err = btrfs_update_inode(trans, root, inode);
10237 /* 10239 /*
10238 * Last step, add directory indexes for our symlink inode. This is the 10240 * Last step, add directory indexes for our symlink inode. This is the
@@ -10240,7 +10242,8 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
10240 * elsewhere above. 10242 * elsewhere above.
10241 */ 10243 */
10242 if (!err) 10244 if (!err)
10243 err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index); 10245 err = btrfs_add_nondir(trans, BTRFS_I(dir), dentry,
10246 BTRFS_I(inode), 0, index);
10244 if (err) { 10247 if (err) {
10245 drop_inode = 1; 10248 drop_inode = 1;
10246 goto out_unlock_inode; 10249 goto out_unlock_inode;
@@ -10326,7 +10329,7 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
10326 break; 10329 break;
10327 } 10330 }
10328 10331
10329 btrfs_drop_extent_cache(inode, cur_offset, 10332 btrfs_drop_extent_cache(BTRFS_I(inode), cur_offset,
10330 cur_offset + ins.offset -1, 0); 10333 cur_offset + ins.offset -1, 0);
10331 10334
10332 em = alloc_extent_map(); 10335 em = alloc_extent_map();
@@ -10353,7 +10356,7 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
10353 write_unlock(&em_tree->lock); 10356 write_unlock(&em_tree->lock);
10354 if (ret != -EEXIST) 10357 if (ret != -EEXIST)
10355 break; 10358 break;
10356 btrfs_drop_extent_cache(inode, cur_offset, 10359 btrfs_drop_extent_cache(BTRFS_I(inode), cur_offset,
10357 cur_offset + ins.offset - 1, 10360 cur_offset + ins.offset - 1,
10358 0); 10361 0);
10359 } 10362 }
@@ -10475,7 +10478,7 @@ static int btrfs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
10475 ret = btrfs_update_inode(trans, root, inode); 10478 ret = btrfs_update_inode(trans, root, inode);
10476 if (ret) 10479 if (ret)
10477 goto out_inode; 10480 goto out_inode;
10478 ret = btrfs_orphan_add(trans, inode); 10481 ret = btrfs_orphan_add(trans, BTRFS_I(inode));
10479 if (ret) 10482 if (ret)
10480 goto out_inode; 10483 goto out_inode;
10481 10484
@@ -10505,6 +10508,12 @@ out_inode:
10505 10508
10506} 10509}
10507 10510
10511__attribute__((const))
10512static int dummy_readpage_io_failed_hook(struct page *page, int failed_mirror)
10513{
10514 return 0;
10515}
10516
10508static const struct inode_operations btrfs_dir_inode_operations = { 10517static const struct inode_operations btrfs_dir_inode_operations = {
10509 .getattr = btrfs_getattr, 10518 .getattr = btrfs_getattr,
10510 .lookup = btrfs_lookup, 10519 .lookup = btrfs_lookup,
@@ -10543,10 +10552,14 @@ static const struct file_operations btrfs_dir_file_operations = {
10543}; 10552};
10544 10553
10545static const struct extent_io_ops btrfs_extent_io_ops = { 10554static const struct extent_io_ops btrfs_extent_io_ops = {
10546 .fill_delalloc = run_delalloc_range, 10555 /* mandatory callbacks */
10547 .submit_bio_hook = btrfs_submit_bio_hook, 10556 .submit_bio_hook = btrfs_submit_bio_hook,
10548 .merge_bio_hook = btrfs_merge_bio_hook,
10549 .readpage_end_io_hook = btrfs_readpage_end_io_hook, 10557 .readpage_end_io_hook = btrfs_readpage_end_io_hook,
10558 .merge_bio_hook = btrfs_merge_bio_hook,
10559 .readpage_io_failed_hook = dummy_readpage_io_failed_hook,
10560
10561 /* optional callbacks */
10562 .fill_delalloc = run_delalloc_range,
10550 .writepage_end_io_hook = btrfs_writepage_end_io_hook, 10563 .writepage_end_io_hook = btrfs_writepage_end_io_hook,
10551 .writepage_start_hook = btrfs_writepage_start_hook, 10564 .writepage_start_hook = btrfs_writepage_start_hook,
10552 .set_bit_hook = btrfs_set_bit_hook, 10565 .set_bit_hook = btrfs_set_bit_hook,
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index d8539979b44f..dabfc7ac48a6 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -434,7 +434,7 @@ int btrfs_is_empty_uuid(u8 *uuid)
434 434
435static noinline int create_subvol(struct inode *dir, 435static noinline int create_subvol(struct inode *dir,
436 struct dentry *dentry, 436 struct dentry *dentry,
437 char *name, int namelen, 437 const char *name, int namelen,
438 u64 *async_transid, 438 u64 *async_transid,
439 struct btrfs_qgroup_inherit *inherit) 439 struct btrfs_qgroup_inherit *inherit)
440{ 440{
@@ -580,21 +580,21 @@ static noinline int create_subvol(struct inode *dir,
580 /* 580 /*
581 * insert the directory item 581 * insert the directory item
582 */ 582 */
583 ret = btrfs_set_inode_index(dir, &index); 583 ret = btrfs_set_inode_index(BTRFS_I(dir), &index);
584 if (ret) { 584 if (ret) {
585 btrfs_abort_transaction(trans, ret); 585 btrfs_abort_transaction(trans, ret);
586 goto fail; 586 goto fail;
587 } 587 }
588 588
589 ret = btrfs_insert_dir_item(trans, root, 589 ret = btrfs_insert_dir_item(trans, root,
590 name, namelen, dir, &key, 590 name, namelen, BTRFS_I(dir), &key,
591 BTRFS_FT_DIR, index); 591 BTRFS_FT_DIR, index);
592 if (ret) { 592 if (ret) {
593 btrfs_abort_transaction(trans, ret); 593 btrfs_abort_transaction(trans, ret);
594 goto fail; 594 goto fail;
595 } 595 }
596 596
597 btrfs_i_size_write(dir, dir->i_size + namelen * 2); 597 btrfs_i_size_write(BTRFS_I(dir), dir->i_size + namelen * 2);
598 ret = btrfs_update_inode(trans, root, dir); 598 ret = btrfs_update_inode(trans, root, dir);
599 BUG_ON(ret); 599 BUG_ON(ret);
600 600
@@ -832,7 +832,7 @@ static inline int btrfs_may_create(struct inode *dir, struct dentry *child)
832 * inside this filesystem so it's quite a bit simpler. 832 * inside this filesystem so it's quite a bit simpler.
833 */ 833 */
834static noinline int btrfs_mksubvol(const struct path *parent, 834static noinline int btrfs_mksubvol(const struct path *parent,
835 char *name, int namelen, 835 const char *name, int namelen,
836 struct btrfs_root *snap_src, 836 struct btrfs_root *snap_src,
837 u64 *async_transid, bool readonly, 837 u64 *async_transid, bool readonly,
838 struct btrfs_qgroup_inherit *inherit) 838 struct btrfs_qgroup_inherit *inherit)
@@ -1009,7 +1009,7 @@ static struct extent_map *defrag_lookup_extent(struct inode *inode, u64 start)
1009 1009
1010 /* get the big lock and read metadata off disk */ 1010 /* get the big lock and read metadata off disk */
1011 lock_extent_bits(io_tree, start, end, &cached); 1011 lock_extent_bits(io_tree, start, end, &cached);
1012 em = btrfs_get_extent(inode, NULL, 0, start, len, 0); 1012 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, start, len, 0);
1013 unlock_extent_cached(io_tree, start, end, &cached, GFP_NOFS); 1013 unlock_extent_cached(io_tree, start, end, &cached, GFP_NOFS);
1014 1014
1015 if (IS_ERR(em)) 1015 if (IS_ERR(em))
@@ -1625,7 +1625,7 @@ out:
1625} 1625}
1626 1626
1627static noinline int btrfs_ioctl_snap_create_transid(struct file *file, 1627static noinline int btrfs_ioctl_snap_create_transid(struct file *file,
1628 char *name, unsigned long fd, int subvol, 1628 const char *name, unsigned long fd, int subvol,
1629 u64 *transid, bool readonly, 1629 u64 *transid, bool readonly,
1630 struct btrfs_qgroup_inherit *inherit) 1630 struct btrfs_qgroup_inherit *inherit)
1631{ 1631{
@@ -3298,7 +3298,7 @@ static int clone_finish_inode_update(struct btrfs_trans_handle *trans,
3298 if (endoff > destoff + olen) 3298 if (endoff > destoff + olen)
3299 endoff = destoff + olen; 3299 endoff = destoff + olen;
3300 if (endoff > inode->i_size) 3300 if (endoff > inode->i_size)
3301 btrfs_i_size_write(inode, endoff); 3301 btrfs_i_size_write(BTRFS_I(inode), endoff);
3302 3302
3303 ret = btrfs_update_inode(trans, root, inode); 3303 ret = btrfs_update_inode(trans, root, inode);
3304 if (ret) { 3304 if (ret) {
@@ -3311,20 +3311,19 @@ out:
3311 return ret; 3311 return ret;
3312} 3312}
3313 3313
3314static void clone_update_extent_map(struct inode *inode, 3314static void clone_update_extent_map(struct btrfs_inode *inode,
3315 const struct btrfs_trans_handle *trans, 3315 const struct btrfs_trans_handle *trans,
3316 const struct btrfs_path *path, 3316 const struct btrfs_path *path,
3317 const u64 hole_offset, 3317 const u64 hole_offset,
3318 const u64 hole_len) 3318 const u64 hole_len)
3319{ 3319{
3320 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 3320 struct extent_map_tree *em_tree = &inode->extent_tree;
3321 struct extent_map *em; 3321 struct extent_map *em;
3322 int ret; 3322 int ret;
3323 3323
3324 em = alloc_extent_map(); 3324 em = alloc_extent_map();
3325 if (!em) { 3325 if (!em) {
3326 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, 3326 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &inode->runtime_flags);
3327 &BTRFS_I(inode)->runtime_flags);
3328 return; 3327 return;
3329 } 3328 }
3330 3329
@@ -3338,7 +3337,7 @@ static void clone_update_extent_map(struct inode *inode,
3338 if (btrfs_file_extent_type(path->nodes[0], fi) == 3337 if (btrfs_file_extent_type(path->nodes[0], fi) ==
3339 BTRFS_FILE_EXTENT_INLINE) 3338 BTRFS_FILE_EXTENT_INLINE)
3340 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, 3339 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
3341 &BTRFS_I(inode)->runtime_flags); 3340 &inode->runtime_flags);
3342 } else { 3341 } else {
3343 em->start = hole_offset; 3342 em->start = hole_offset;
3344 em->len = hole_len; 3343 em->len = hole_len;
@@ -3364,8 +3363,7 @@ static void clone_update_extent_map(struct inode *inode,
3364 } 3363 }
3365 3364
3366 if (ret) 3365 if (ret)
3367 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, 3366 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &inode->runtime_flags);
3368 &BTRFS_I(inode)->runtime_flags);
3369} 3367}
3370 3368
3371/* 3369/*
@@ -3791,11 +3789,12 @@ process_slot:
3791 3789
3792 /* If we have an implicit hole (NO_HOLES feature). */ 3790 /* If we have an implicit hole (NO_HOLES feature). */
3793 if (drop_start < new_key.offset) 3791 if (drop_start < new_key.offset)
3794 clone_update_extent_map(inode, trans, 3792 clone_update_extent_map(BTRFS_I(inode), trans,
3795 NULL, drop_start, 3793 NULL, drop_start,
3796 new_key.offset - drop_start); 3794 new_key.offset - drop_start);
3797 3795
3798 clone_update_extent_map(inode, trans, path, 0, 0); 3796 clone_update_extent_map(BTRFS_I(inode), trans,
3797 path, 0, 0);
3799 3798
3800 btrfs_mark_buffer_dirty(leaf); 3799 btrfs_mark_buffer_dirty(leaf);
3801 btrfs_release_path(path); 3800 btrfs_release_path(path);
@@ -3845,8 +3844,9 @@ process_slot:
3845 btrfs_end_transaction(trans); 3844 btrfs_end_transaction(trans);
3846 goto out; 3845 goto out;
3847 } 3846 }
3848 clone_update_extent_map(inode, trans, NULL, last_dest_end, 3847 clone_update_extent_map(BTRFS_I(inode), trans, NULL,
3849 destoff + len - last_dest_end); 3848 last_dest_end,
3849 destoff + len - last_dest_end);
3850 ret = clone_finish_inode_update(trans, inode, destoff + len, 3850 ret = clone_finish_inode_update(trans, inode, destoff + len,
3851 destoff, olen, no_time_update); 3851 destoff, olen, no_time_update);
3852 } 3852 }
diff --git a/fs/btrfs/lzo.c b/fs/btrfs/lzo.c
index 45d26980caf9..f48c8c14dc14 100644
--- a/fs/btrfs/lzo.c
+++ b/fs/btrfs/lzo.c
@@ -76,7 +76,7 @@ static inline void write_compress_length(char *buf, size_t len)
76 memcpy(buf, &dlen, LZO_LEN); 76 memcpy(buf, &dlen, LZO_LEN);
77} 77}
78 78
79static inline size_t read_compress_length(char *buf) 79static inline size_t read_compress_length(const char *buf)
80{ 80{
81 __le32 dlen; 81 __le32 dlen;
82 82
@@ -86,13 +86,11 @@ static inline size_t read_compress_length(char *buf)
86 86
87static int lzo_compress_pages(struct list_head *ws, 87static int lzo_compress_pages(struct list_head *ws,
88 struct address_space *mapping, 88 struct address_space *mapping,
89 u64 start, unsigned long len, 89 u64 start,
90 struct page **pages, 90 struct page **pages,
91 unsigned long nr_dest_pages,
92 unsigned long *out_pages, 91 unsigned long *out_pages,
93 unsigned long *total_in, 92 unsigned long *total_in,
94 unsigned long *total_out, 93 unsigned long *total_out)
95 unsigned long max_out)
96{ 94{
97 struct workspace *workspace = list_entry(ws, struct workspace, list); 95 struct workspace *workspace = list_entry(ws, struct workspace, list);
98 int ret = 0; 96 int ret = 0;
@@ -102,7 +100,9 @@ static int lzo_compress_pages(struct list_head *ws,
102 struct page *in_page = NULL; 100 struct page *in_page = NULL;
103 struct page *out_page = NULL; 101 struct page *out_page = NULL;
104 unsigned long bytes_left; 102 unsigned long bytes_left;
105 103 unsigned long len = *total_out;
104 unsigned long nr_dest_pages = *out_pages;
105 const unsigned long max_out = nr_dest_pages * PAGE_SIZE;
106 size_t in_len; 106 size_t in_len;
107 size_t out_len; 107 size_t out_len;
108 char *buf; 108 char *buf;
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index bc2aba810629..9a46878ba60f 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -879,15 +879,14 @@ out:
879/* Since the DIO code tries to lock a wide area we need to look for any ordered 879/* Since the DIO code tries to lock a wide area we need to look for any ordered
880 * extents that exist in the range, rather than just the start of the range. 880 * extents that exist in the range, rather than just the start of the range.
881 */ 881 */
882struct btrfs_ordered_extent *btrfs_lookup_ordered_range(struct inode *inode, 882struct btrfs_ordered_extent *btrfs_lookup_ordered_range(
883 u64 file_offset, 883 struct btrfs_inode *inode, u64 file_offset, u64 len)
884 u64 len)
885{ 884{
886 struct btrfs_ordered_inode_tree *tree; 885 struct btrfs_ordered_inode_tree *tree;
887 struct rb_node *node; 886 struct rb_node *node;
888 struct btrfs_ordered_extent *entry = NULL; 887 struct btrfs_ordered_extent *entry = NULL;
889 888
890 tree = &BTRFS_I(inode)->ordered_tree; 889 tree = &inode->ordered_tree;
891 spin_lock_irq(&tree->lock); 890 spin_lock_irq(&tree->lock);
892 node = tree_search(tree, file_offset); 891 node = tree_search(tree, file_offset);
893 if (!node) { 892 if (!node) {
@@ -923,7 +922,7 @@ bool btrfs_have_ordered_extents_in_range(struct inode *inode,
923{ 922{
924 struct btrfs_ordered_extent *oe; 923 struct btrfs_ordered_extent *oe;
925 924
926 oe = btrfs_lookup_ordered_range(inode, file_offset, len); 925 oe = btrfs_lookup_ordered_range(BTRFS_I(inode), file_offset, len);
927 if (oe) { 926 if (oe) {
928 btrfs_put_ordered_extent(oe); 927 btrfs_put_ordered_extent(oe);
929 return true; 928 return true;
diff --git a/fs/btrfs/ordered-data.h b/fs/btrfs/ordered-data.h
index a8cb8efe6fae..195c93b67fe0 100644
--- a/fs/btrfs/ordered-data.h
+++ b/fs/btrfs/ordered-data.h
@@ -189,9 +189,10 @@ void btrfs_start_ordered_extent(struct inode *inode,
189int btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len); 189int btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len);
190struct btrfs_ordered_extent * 190struct btrfs_ordered_extent *
191btrfs_lookup_first_ordered_extent(struct inode * inode, u64 file_offset); 191btrfs_lookup_first_ordered_extent(struct inode * inode, u64 file_offset);
192struct btrfs_ordered_extent *btrfs_lookup_ordered_range(struct inode *inode, 192struct btrfs_ordered_extent *btrfs_lookup_ordered_range(
193 u64 file_offset, 193 struct btrfs_inode *inode,
194 u64 len); 194 u64 file_offset,
195 u64 len);
195bool btrfs_have_ordered_extents_in_range(struct inode *inode, 196bool btrfs_have_ordered_extents_in_range(struct inode *inode,
196 u64 file_offset, 197 u64 file_offset,
197 u64 len); 198 u64 len);
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index ddbde0f08365..d60df51959f7 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -1714,8 +1714,8 @@ int replace_file_extents(struct btrfs_trans_handle *trans,
1714 if (!ret) 1714 if (!ret)
1715 continue; 1715 continue;
1716 1716
1717 btrfs_drop_extent_cache(inode, key.offset, end, 1717 btrfs_drop_extent_cache(BTRFS_I(inode),
1718 1); 1718 key.offset, end, 1);
1719 unlock_extent(&BTRFS_I(inode)->io_tree, 1719 unlock_extent(&BTRFS_I(inode)->io_tree,
1720 key.offset, end); 1720 key.offset, end);
1721 } 1721 }
@@ -2130,7 +2130,7 @@ static int invalidate_extent_cache(struct btrfs_root *root,
2130 2130
2131 /* the lock_extent waits for readpage to complete */ 2131 /* the lock_extent waits for readpage to complete */
2132 lock_extent(&BTRFS_I(inode)->io_tree, start, end); 2132 lock_extent(&BTRFS_I(inode)->io_tree, start, end);
2133 btrfs_drop_extent_cache(inode, start, end, 1); 2133 btrfs_drop_extent_cache(BTRFS_I(inode), start, end, 1);
2134 unlock_extent(&BTRFS_I(inode)->io_tree, start, end); 2134 unlock_extent(&BTRFS_I(inode)->io_tree, start, end);
2135 } 2135 }
2136 return 0; 2136 return 0;
@@ -3161,7 +3161,7 @@ int setup_extent_mapping(struct inode *inode, u64 start, u64 end,
3161 free_extent_map(em); 3161 free_extent_map(em);
3162 break; 3162 break;
3163 } 3163 }
3164 btrfs_drop_extent_cache(inode, start, end, 0); 3164 btrfs_drop_extent_cache(BTRFS_I(inode), start, end, 0);
3165 } 3165 }
3166 unlock_extent(&BTRFS_I(inode)->io_tree, start, end); 3166 unlock_extent(&BTRFS_I(inode)->io_tree, start, end);
3167 return ret; 3167 return ret;
@@ -3203,7 +3203,8 @@ static int relocate_file_extent_cluster(struct inode *inode,
3203 index = (cluster->start - offset) >> PAGE_SHIFT; 3203 index = (cluster->start - offset) >> PAGE_SHIFT;
3204 last_index = (cluster->end - offset) >> PAGE_SHIFT; 3204 last_index = (cluster->end - offset) >> PAGE_SHIFT;
3205 while (index <= last_index) { 3205 while (index <= last_index) {
3206 ret = btrfs_delalloc_reserve_metadata(inode, PAGE_SIZE); 3206 ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode),
3207 PAGE_SIZE);
3207 if (ret) 3208 if (ret)
3208 goto out; 3209 goto out;
3209 3210
@@ -3215,7 +3216,7 @@ static int relocate_file_extent_cluster(struct inode *inode,
3215 page = find_or_create_page(inode->i_mapping, index, 3216 page = find_or_create_page(inode->i_mapping, index,
3216 mask); 3217 mask);
3217 if (!page) { 3218 if (!page) {
3218 btrfs_delalloc_release_metadata(inode, 3219 btrfs_delalloc_release_metadata(BTRFS_I(inode),
3219 PAGE_SIZE); 3220 PAGE_SIZE);
3220 ret = -ENOMEM; 3221 ret = -ENOMEM;
3221 goto out; 3222 goto out;
@@ -3234,7 +3235,7 @@ static int relocate_file_extent_cluster(struct inode *inode,
3234 if (!PageUptodate(page)) { 3235 if (!PageUptodate(page)) {
3235 unlock_page(page); 3236 unlock_page(page);
3236 put_page(page); 3237 put_page(page);
3237 btrfs_delalloc_release_metadata(inode, 3238 btrfs_delalloc_release_metadata(BTRFS_I(inode),
3238 PAGE_SIZE); 3239 PAGE_SIZE);
3239 ret = -EIO; 3240 ret = -EIO;
3240 goto out; 3241 goto out;
@@ -4245,7 +4246,7 @@ struct inode *create_reloc_inode(struct btrfs_fs_info *fs_info,
4245 BUG_ON(IS_ERR(inode) || is_bad_inode(inode)); 4246 BUG_ON(IS_ERR(inode) || is_bad_inode(inode));
4246 BTRFS_I(inode)->index_cnt = group->key.objectid; 4247 BTRFS_I(inode)->index_cnt = group->key.objectid;
4247 4248
4248 err = btrfs_orphan_add(trans, inode); 4249 err = btrfs_orphan_add(trans, BTRFS_I(inode));
4249out: 4250out:
4250 btrfs_end_transaction(trans); 4251 btrfs_end_transaction(trans);
4251 btrfs_btree_balance_dirty(fs_info); 4252 btrfs_btree_balance_dirty(fs_info);
diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index ff9a11c39f5e..b0251eb1239f 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -731,7 +731,7 @@ static int scrub_fixup_readpage(u64 inum, u64 offset, u64 root, void *fixup_ctx)
731 ret = -EIO; 731 ret = -EIO;
732 goto out; 732 goto out;
733 } 733 }
734 ret = repair_io_failure(inode, offset, PAGE_SIZE, 734 ret = repair_io_failure(BTRFS_I(inode), offset, PAGE_SIZE,
735 fixup->logical, page, 735 fixup->logical, page,
736 offset - page_offset(page), 736 offset - page_offset(page),
737 fixup->mirror_num); 737 fixup->mirror_num);
@@ -4236,7 +4236,7 @@ out:
4236 scrub_pending_trans_workers_dec(sctx); 4236 scrub_pending_trans_workers_dec(sctx);
4237} 4237}
4238 4238
4239static int check_extent_to_block(struct inode *inode, u64 start, u64 len, 4239static int check_extent_to_block(struct btrfs_inode *inode, u64 start, u64 len,
4240 u64 logical) 4240 u64 logical)
4241{ 4241{
4242 struct extent_state *cached_state = NULL; 4242 struct extent_state *cached_state = NULL;
@@ -4246,7 +4246,7 @@ static int check_extent_to_block(struct inode *inode, u64 start, u64 len,
4246 u64 lockstart = start, lockend = start + len - 1; 4246 u64 lockstart = start, lockend = start + len - 1;
4247 int ret = 0; 4247 int ret = 0;
4248 4248
4249 io_tree = &BTRFS_I(inode)->io_tree; 4249 io_tree = &inode->io_tree;
4250 4250
4251 lock_extent_bits(io_tree, lockstart, lockend, &cached_state); 4251 lock_extent_bits(io_tree, lockstart, lockend, &cached_state);
4252 ordered = btrfs_lookup_ordered_range(inode, lockstart, len); 4252 ordered = btrfs_lookup_ordered_range(inode, lockstart, len);
@@ -4325,7 +4325,8 @@ static int copy_nocow_pages_for_inode(u64 inum, u64 offset, u64 root,
4325 io_tree = &BTRFS_I(inode)->io_tree; 4325 io_tree = &BTRFS_I(inode)->io_tree;
4326 nocow_ctx_logical = nocow_ctx->logical; 4326 nocow_ctx_logical = nocow_ctx->logical;
4327 4327
4328 ret = check_extent_to_block(inode, offset, len, nocow_ctx_logical); 4328 ret = check_extent_to_block(BTRFS_I(inode), offset, len,
4329 nocow_ctx_logical);
4329 if (ret) { 4330 if (ret) {
4330 ret = ret > 0 ? 0 : ret; 4331 ret = ret > 0 ? 0 : ret;
4331 goto out; 4332 goto out;
@@ -4372,7 +4373,7 @@ again:
4372 } 4373 }
4373 } 4374 }
4374 4375
4375 ret = check_extent_to_block(inode, offset, len, 4376 ret = check_extent_to_block(BTRFS_I(inode), offset, len,
4376 nocow_ctx_logical); 4377 nocow_ctx_logical);
4377 if (ret) { 4378 if (ret) {
4378 ret = ret > 0 ? 0 : ret; 4379 ret = ret > 0 ? 0 : ret;
diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index d145ce804620..456c8901489b 100644
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -1681,6 +1681,9 @@ static int is_inode_existent(struct send_ctx *sctx, u64 ino, u64 gen)
1681{ 1681{
1682 int ret; 1682 int ret;
1683 1683
1684 if (ino == BTRFS_FIRST_FREE_OBJECTID)
1685 return 1;
1686
1684 ret = get_cur_inode_state(sctx, ino, gen); 1687 ret = get_cur_inode_state(sctx, ino, gen);
1685 if (ret < 0) 1688 if (ret < 0)
1686 goto out; 1689 goto out;
@@ -1866,7 +1869,7 @@ static int will_overwrite_ref(struct send_ctx *sctx, u64 dir, u64 dir_gen,
1866 * not deleted and then re-created, if it was then we have no overwrite 1869 * not deleted and then re-created, if it was then we have no overwrite
1867 * and we can just unlink this entry. 1870 * and we can just unlink this entry.
1868 */ 1871 */
1869 if (sctx->parent_root) { 1872 if (sctx->parent_root && dir != BTRFS_FIRST_FREE_OBJECTID) {
1870 ret = get_inode_info(sctx->parent_root, dir, NULL, &gen, NULL, 1873 ret = get_inode_info(sctx->parent_root, dir, NULL, &gen, NULL,
1871 NULL, NULL, NULL); 1874 NULL, NULL, NULL);
1872 if (ret < 0 && ret != -ENOENT) 1875 if (ret < 0 && ret != -ENOENT)
@@ -1934,6 +1937,19 @@ static int did_overwrite_ref(struct send_ctx *sctx,
1934 if (ret <= 0) 1937 if (ret <= 0)
1935 goto out; 1938 goto out;
1936 1939
1940 if (dir != BTRFS_FIRST_FREE_OBJECTID) {
1941 ret = get_inode_info(sctx->send_root, dir, NULL, &gen, NULL,
1942 NULL, NULL, NULL);
1943 if (ret < 0 && ret != -ENOENT)
1944 goto out;
1945 if (ret) {
1946 ret = 0;
1947 goto out;
1948 }
1949 if (gen != dir_gen)
1950 goto out;
1951 }
1952
1937 /* check if the ref was overwritten by another ref */ 1953 /* check if the ref was overwritten by another ref */
1938 ret = lookup_dir_item_inode(sctx->send_root, dir, name, name_len, 1954 ret = lookup_dir_item_inode(sctx->send_root, dir, name, name_len,
1939 &ow_inode, &other_type); 1955 &ow_inode, &other_type);
@@ -3556,6 +3572,7 @@ static int wait_for_parent_move(struct send_ctx *sctx,
3556{ 3572{
3557 int ret = 0; 3573 int ret = 0;
3558 u64 ino = parent_ref->dir; 3574 u64 ino = parent_ref->dir;
3575 u64 ino_gen = parent_ref->dir_gen;
3559 u64 parent_ino_before, parent_ino_after; 3576 u64 parent_ino_before, parent_ino_after;
3560 struct fs_path *path_before = NULL; 3577 struct fs_path *path_before = NULL;
3561 struct fs_path *path_after = NULL; 3578 struct fs_path *path_after = NULL;
@@ -3576,6 +3593,8 @@ static int wait_for_parent_move(struct send_ctx *sctx,
3576 * at get_cur_path()). 3593 * at get_cur_path()).
3577 */ 3594 */
3578 while (ino > BTRFS_FIRST_FREE_OBJECTID) { 3595 while (ino > BTRFS_FIRST_FREE_OBJECTID) {
3596 u64 parent_ino_after_gen;
3597
3579 if (is_waiting_for_move(sctx, ino)) { 3598 if (is_waiting_for_move(sctx, ino)) {
3580 /* 3599 /*
3581 * If the current inode is an ancestor of ino in the 3600 * If the current inode is an ancestor of ino in the
@@ -3598,7 +3617,7 @@ static int wait_for_parent_move(struct send_ctx *sctx,
3598 fs_path_reset(path_after); 3617 fs_path_reset(path_after);
3599 3618
3600 ret = get_first_ref(sctx->send_root, ino, &parent_ino_after, 3619 ret = get_first_ref(sctx->send_root, ino, &parent_ino_after,
3601 NULL, path_after); 3620 &parent_ino_after_gen, path_after);
3602 if (ret < 0) 3621 if (ret < 0)
3603 goto out; 3622 goto out;
3604 ret = get_first_ref(sctx->parent_root, ino, &parent_ino_before, 3623 ret = get_first_ref(sctx->parent_root, ino, &parent_ino_before,
@@ -3615,10 +3634,20 @@ static int wait_for_parent_move(struct send_ctx *sctx,
3615 if (ino > sctx->cur_ino && 3634 if (ino > sctx->cur_ino &&
3616 (parent_ino_before != parent_ino_after || len1 != len2 || 3635 (parent_ino_before != parent_ino_after || len1 != len2 ||
3617 memcmp(path_before->start, path_after->start, len1))) { 3636 memcmp(path_before->start, path_after->start, len1))) {
3618 ret = 1; 3637 u64 parent_ino_gen;
3619 break; 3638
3639 ret = get_inode_info(sctx->parent_root, ino, NULL,
3640 &parent_ino_gen, NULL, NULL, NULL,
3641 NULL);
3642 if (ret < 0)
3643 goto out;
3644 if (ino_gen == parent_ino_gen) {
3645 ret = 1;
3646 break;
3647 }
3620 } 3648 }
3621 ino = parent_ino_after; 3649 ino = parent_ino_after;
3650 ino_gen = parent_ino_after_gen;
3622 } 3651 }
3623 3652
3624out: 3653out:
@@ -5277,6 +5306,81 @@ out:
5277 return ret; 5306 return ret;
5278} 5307}
5279 5308
5309static int range_is_hole_in_parent(struct send_ctx *sctx,
5310 const u64 start,
5311 const u64 end)
5312{
5313 struct btrfs_path *path;
5314 struct btrfs_key key;
5315 struct btrfs_root *root = sctx->parent_root;
5316 u64 search_start = start;
5317 int ret;
5318
5319 path = alloc_path_for_send();
5320 if (!path)
5321 return -ENOMEM;
5322
5323 key.objectid = sctx->cur_ino;
5324 key.type = BTRFS_EXTENT_DATA_KEY;
5325 key.offset = search_start;
5326 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5327 if (ret < 0)
5328 goto out;
5329 if (ret > 0 && path->slots[0] > 0)
5330 path->slots[0]--;
5331
5332 while (search_start < end) {
5333 struct extent_buffer *leaf = path->nodes[0];
5334 int slot = path->slots[0];
5335 struct btrfs_file_extent_item *fi;
5336 u64 extent_end;
5337
5338 if (slot >= btrfs_header_nritems(leaf)) {
5339 ret = btrfs_next_leaf(root, path);
5340 if (ret < 0)
5341 goto out;
5342 else if (ret > 0)
5343 break;
5344 continue;
5345 }
5346
5347 btrfs_item_key_to_cpu(leaf, &key, slot);
5348 if (key.objectid < sctx->cur_ino ||
5349 key.type < BTRFS_EXTENT_DATA_KEY)
5350 goto next;
5351 if (key.objectid > sctx->cur_ino ||
5352 key.type > BTRFS_EXTENT_DATA_KEY ||
5353 key.offset >= end)
5354 break;
5355
5356 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
5357 if (btrfs_file_extent_type(leaf, fi) ==
5358 BTRFS_FILE_EXTENT_INLINE) {
5359 u64 size = btrfs_file_extent_inline_len(leaf, slot, fi);
5360
5361 extent_end = ALIGN(key.offset + size,
5362 root->fs_info->sectorsize);
5363 } else {
5364 extent_end = key.offset +
5365 btrfs_file_extent_num_bytes(leaf, fi);
5366 }
5367 if (extent_end <= start)
5368 goto next;
5369 if (btrfs_file_extent_disk_bytenr(leaf, fi) == 0) {
5370 search_start = extent_end;
5371 goto next;
5372 }
5373 ret = 0;
5374 goto out;
5375next:
5376 path->slots[0]++;
5377 }
5378 ret = 1;
5379out:
5380 btrfs_free_path(path);
5381 return ret;
5382}
5383
5280static int maybe_send_hole(struct send_ctx *sctx, struct btrfs_path *path, 5384static int maybe_send_hole(struct send_ctx *sctx, struct btrfs_path *path,
5281 struct btrfs_key *key) 5385 struct btrfs_key *key)
5282{ 5386{
@@ -5321,8 +5425,17 @@ static int maybe_send_hole(struct send_ctx *sctx, struct btrfs_path *path,
5321 return ret; 5425 return ret;
5322 } 5426 }
5323 5427
5324 if (sctx->cur_inode_last_extent < key->offset) 5428 if (sctx->cur_inode_last_extent < key->offset) {
5325 ret = send_hole(sctx, key->offset); 5429 ret = range_is_hole_in_parent(sctx,
5430 sctx->cur_inode_last_extent,
5431 key->offset);
5432 if (ret < 0)
5433 return ret;
5434 else if (ret == 0)
5435 ret = send_hole(sctx, key->offset);
5436 else
5437 ret = 0;
5438 }
5326 sctx->cur_inode_last_extent = extent_end; 5439 sctx->cur_inode_last_extent = extent_end;
5327 return ret; 5440 return ret;
5328} 5441}
diff --git a/fs/btrfs/tests/inode-tests.c b/fs/btrfs/tests/inode-tests.c
index 4d0f038e14f1..8c91d03cc82d 100644
--- a/fs/btrfs/tests/inode-tests.c
+++ b/fs/btrfs/tests/inode-tests.c
@@ -278,7 +278,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
278 278
279 /* First with no extents */ 279 /* First with no extents */
280 BTRFS_I(inode)->root = root; 280 BTRFS_I(inode)->root = root;
281 em = btrfs_get_extent(inode, NULL, 0, 0, sectorsize, 0); 281 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, 0, sectorsize, 0);
282 if (IS_ERR(em)) { 282 if (IS_ERR(em)) {
283 em = NULL; 283 em = NULL;
284 test_msg("Got an error when we shouldn't have\n"); 284 test_msg("Got an error when we shouldn't have\n");
@@ -293,7 +293,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
293 goto out; 293 goto out;
294 } 294 }
295 free_extent_map(em); 295 free_extent_map(em);
296 btrfs_drop_extent_cache(inode, 0, (u64)-1, 0); 296 btrfs_drop_extent_cache(BTRFS_I(inode), 0, (u64)-1, 0);
297 297
298 /* 298 /*
299 * All of the magic numbers are based on the mapping setup in 299 * All of the magic numbers are based on the mapping setup in
@@ -302,7 +302,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
302 */ 302 */
303 setup_file_extents(root, sectorsize); 303 setup_file_extents(root, sectorsize);
304 304
305 em = btrfs_get_extent(inode, NULL, 0, 0, (u64)-1, 0); 305 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, 0, (u64)-1, 0);
306 if (IS_ERR(em)) { 306 if (IS_ERR(em)) {
307 test_msg("Got an error when we shouldn't have\n"); 307 test_msg("Got an error when we shouldn't have\n");
308 goto out; 308 goto out;
@@ -323,7 +323,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
323 offset = em->start + em->len; 323 offset = em->start + em->len;
324 free_extent_map(em); 324 free_extent_map(em);
325 325
326 em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize, 0); 326 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
327 if (IS_ERR(em)) { 327 if (IS_ERR(em)) {
328 test_msg("Got an error when we shouldn't have\n"); 328 test_msg("Got an error when we shouldn't have\n");
329 goto out; 329 goto out;
@@ -350,7 +350,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
350 offset = em->start + em->len; 350 offset = em->start + em->len;
351 free_extent_map(em); 351 free_extent_map(em);
352 352
353 em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize, 0); 353 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
354 if (IS_ERR(em)) { 354 if (IS_ERR(em)) {
355 test_msg("Got an error when we shouldn't have\n"); 355 test_msg("Got an error when we shouldn't have\n");
356 goto out; 356 goto out;
@@ -372,7 +372,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
372 free_extent_map(em); 372 free_extent_map(em);
373 373
374 /* Regular extent */ 374 /* Regular extent */
375 em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize, 0); 375 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
376 if (IS_ERR(em)) { 376 if (IS_ERR(em)) {
377 test_msg("Got an error when we shouldn't have\n"); 377 test_msg("Got an error when we shouldn't have\n");
378 goto out; 378 goto out;
@@ -399,7 +399,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
399 free_extent_map(em); 399 free_extent_map(em);
400 400
401 /* The next 3 are split extents */ 401 /* The next 3 are split extents */
402 em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize, 0); 402 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
403 if (IS_ERR(em)) { 403 if (IS_ERR(em)) {
404 test_msg("Got an error when we shouldn't have\n"); 404 test_msg("Got an error when we shouldn't have\n");
405 goto out; 405 goto out;
@@ -428,7 +428,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
428 offset = em->start + em->len; 428 offset = em->start + em->len;
429 free_extent_map(em); 429 free_extent_map(em);
430 430
431 em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize, 0); 431 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
432 if (IS_ERR(em)) { 432 if (IS_ERR(em)) {
433 test_msg("Got an error when we shouldn't have\n"); 433 test_msg("Got an error when we shouldn't have\n");
434 goto out; 434 goto out;
@@ -450,7 +450,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
450 offset = em->start + em->len; 450 offset = em->start + em->len;
451 free_extent_map(em); 451 free_extent_map(em);
452 452
453 em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize, 0); 453 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
454 if (IS_ERR(em)) { 454 if (IS_ERR(em)) {
455 test_msg("Got an error when we shouldn't have\n"); 455 test_msg("Got an error when we shouldn't have\n");
456 goto out; 456 goto out;
@@ -484,7 +484,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
484 free_extent_map(em); 484 free_extent_map(em);
485 485
486 /* Prealloc extent */ 486 /* Prealloc extent */
487 em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize, 0); 487 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
488 if (IS_ERR(em)) { 488 if (IS_ERR(em)) {
489 test_msg("Got an error when we shouldn't have\n"); 489 test_msg("Got an error when we shouldn't have\n");
490 goto out; 490 goto out;
@@ -513,7 +513,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
513 free_extent_map(em); 513 free_extent_map(em);
514 514
515 /* The next 3 are a half written prealloc extent */ 515 /* The next 3 are a half written prealloc extent */
516 em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize, 0); 516 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
517 if (IS_ERR(em)) { 517 if (IS_ERR(em)) {
518 test_msg("Got an error when we shouldn't have\n"); 518 test_msg("Got an error when we shouldn't have\n");
519 goto out; 519 goto out;
@@ -543,7 +543,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
543 offset = em->start + em->len; 543 offset = em->start + em->len;
544 free_extent_map(em); 544 free_extent_map(em);
545 545
546 em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize, 0); 546 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
547 if (IS_ERR(em)) { 547 if (IS_ERR(em)) {
548 test_msg("Got an error when we shouldn't have\n"); 548 test_msg("Got an error when we shouldn't have\n");
549 goto out; 549 goto out;
@@ -576,7 +576,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
576 offset = em->start + em->len; 576 offset = em->start + em->len;
577 free_extent_map(em); 577 free_extent_map(em);
578 578
579 em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize, 0); 579 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
580 if (IS_ERR(em)) { 580 if (IS_ERR(em)) {
581 test_msg("Got an error when we shouldn't have\n"); 581 test_msg("Got an error when we shouldn't have\n");
582 goto out; 582 goto out;
@@ -611,7 +611,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
611 free_extent_map(em); 611 free_extent_map(em);
612 612
613 /* Now for the compressed extent */ 613 /* Now for the compressed extent */
614 em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize, 0); 614 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
615 if (IS_ERR(em)) { 615 if (IS_ERR(em)) {
616 test_msg("Got an error when we shouldn't have\n"); 616 test_msg("Got an error when we shouldn't have\n");
617 goto out; 617 goto out;
@@ -645,7 +645,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
645 free_extent_map(em); 645 free_extent_map(em);
646 646
647 /* Split compressed extent */ 647 /* Split compressed extent */
648 em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize, 0); 648 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
649 if (IS_ERR(em)) { 649 if (IS_ERR(em)) {
650 test_msg("Got an error when we shouldn't have\n"); 650 test_msg("Got an error when we shouldn't have\n");
651 goto out; 651 goto out;
@@ -680,7 +680,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
680 offset = em->start + em->len; 680 offset = em->start + em->len;
681 free_extent_map(em); 681 free_extent_map(em);
682 682
683 em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize, 0); 683 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
684 if (IS_ERR(em)) { 684 if (IS_ERR(em)) {
685 test_msg("Got an error when we shouldn't have\n"); 685 test_msg("Got an error when we shouldn't have\n");
686 goto out; 686 goto out;
@@ -707,7 +707,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
707 offset = em->start + em->len; 707 offset = em->start + em->len;
708 free_extent_map(em); 708 free_extent_map(em);
709 709
710 em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize, 0); 710 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
711 if (IS_ERR(em)) { 711 if (IS_ERR(em)) {
712 test_msg("Got an error when we shouldn't have\n"); 712 test_msg("Got an error when we shouldn't have\n");
713 goto out; 713 goto out;
@@ -742,7 +742,8 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
742 free_extent_map(em); 742 free_extent_map(em);
743 743
744 /* A hole between regular extents but no hole extent */ 744 /* A hole between regular extents but no hole extent */
745 em = btrfs_get_extent(inode, NULL, 0, offset + 6, sectorsize, 0); 745 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset + 6,
746 sectorsize, 0);
746 if (IS_ERR(em)) { 747 if (IS_ERR(em)) {
747 test_msg("Got an error when we shouldn't have\n"); 748 test_msg("Got an error when we shouldn't have\n");
748 goto out; 749 goto out;
@@ -769,7 +770,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
769 offset = em->start + em->len; 770 offset = em->start + em->len;
770 free_extent_map(em); 771 free_extent_map(em);
771 772
772 em = btrfs_get_extent(inode, NULL, 0, offset, 4096 * 1024, 0); 773 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, 4096 * 1024, 0);
773 if (IS_ERR(em)) { 774 if (IS_ERR(em)) {
774 test_msg("Got an error when we shouldn't have\n"); 775 test_msg("Got an error when we shouldn't have\n");
775 goto out; 776 goto out;
@@ -802,7 +803,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
802 offset = em->start + em->len; 803 offset = em->start + em->len;
803 free_extent_map(em); 804 free_extent_map(em);
804 805
805 em = btrfs_get_extent(inode, NULL, 0, offset, sectorsize, 0); 806 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
806 if (IS_ERR(em)) { 807 if (IS_ERR(em)) {
807 test_msg("Got an error when we shouldn't have\n"); 808 test_msg("Got an error when we shouldn't have\n");
808 goto out; 809 goto out;
@@ -885,7 +886,7 @@ static int test_hole_first(u32 sectorsize, u32 nodesize)
885 insert_inode_item_key(root); 886 insert_inode_item_key(root);
886 insert_extent(root, sectorsize, sectorsize, sectorsize, 0, sectorsize, 887 insert_extent(root, sectorsize, sectorsize, sectorsize, 0, sectorsize,
887 sectorsize, BTRFS_FILE_EXTENT_REG, 0, 1); 888 sectorsize, BTRFS_FILE_EXTENT_REG, 0, 1);
888 em = btrfs_get_extent(inode, NULL, 0, 0, 2 * sectorsize, 0); 889 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, 0, 2 * sectorsize, 0);
889 if (IS_ERR(em)) { 890 if (IS_ERR(em)) {
890 test_msg("Got an error when we shouldn't have\n"); 891 test_msg("Got an error when we shouldn't have\n");
891 goto out; 892 goto out;
@@ -907,7 +908,8 @@ static int test_hole_first(u32 sectorsize, u32 nodesize)
907 } 908 }
908 free_extent_map(em); 909 free_extent_map(em);
909 910
910 em = btrfs_get_extent(inode, NULL, 0, sectorsize, 2 * sectorsize, 0); 911 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, sectorsize,
912 2 * sectorsize, 0);
911 if (IS_ERR(em)) { 913 if (IS_ERR(em)) {
912 test_msg("Got an error when we shouldn't have\n"); 914 test_msg("Got an error when we shouldn't have\n");
913 goto out; 915 goto out;
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 6b3e0fc2fe7a..61b807de3e16 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -1505,7 +1505,7 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
1505 /* 1505 /*
1506 * insert the directory item 1506 * insert the directory item
1507 */ 1507 */
1508 ret = btrfs_set_inode_index(parent_inode, &index); 1508 ret = btrfs_set_inode_index(BTRFS_I(parent_inode), &index);
1509 BUG_ON(ret); /* -ENOMEM */ 1509 BUG_ON(ret); /* -ENOMEM */
1510 1510
1511 /* check if there is a file/dir which has the same name. */ 1511 /* check if there is a file/dir which has the same name. */
@@ -1644,7 +1644,7 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
1644 1644
1645 ret = btrfs_insert_dir_item(trans, parent_root, 1645 ret = btrfs_insert_dir_item(trans, parent_root,
1646 dentry->d_name.name, dentry->d_name.len, 1646 dentry->d_name.name, dentry->d_name.len,
1647 parent_inode, &key, 1647 BTRFS_I(parent_inode), &key,
1648 BTRFS_FT_DIR, index); 1648 BTRFS_FT_DIR, index);
1649 /* We have check then name at the beginning, so it is impossible. */ 1649 /* We have check then name at the beginning, so it is impossible. */
1650 BUG_ON(ret == -EEXIST || ret == -EOVERFLOW); 1650 BUG_ON(ret == -EEXIST || ret == -EOVERFLOW);
@@ -1653,7 +1653,7 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
1653 goto fail; 1653 goto fail;
1654 } 1654 }
1655 1655
1656 btrfs_i_size_write(parent_inode, parent_inode->i_size + 1656 btrfs_i_size_write(BTRFS_I(parent_inode), parent_inode->i_size +
1657 dentry->d_name.len * 2); 1657 dentry->d_name.len * 2);
1658 parent_inode->i_mtime = parent_inode->i_ctime = 1658 parent_inode->i_mtime = parent_inode->i_ctime =
1659 current_time(parent_inode); 1659 current_time(parent_inode);
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 3806853cde08..a59674c3e69e 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -673,6 +673,10 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
673 unsigned long dest_offset; 673 unsigned long dest_offset;
674 struct btrfs_key ins; 674 struct btrfs_key ins;
675 675
676 if (btrfs_file_extent_disk_bytenr(eb, item) == 0 &&
677 btrfs_fs_incompat(fs_info, NO_HOLES))
678 goto update_inode;
679
676 ret = btrfs_insert_empty_item(trans, root, path, key, 680 ret = btrfs_insert_empty_item(trans, root, path, key,
677 sizeof(*item)); 681 sizeof(*item));
678 if (ret) 682 if (ret)
@@ -825,6 +829,7 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
825 } 829 }
826 830
827 inode_add_bytes(inode, nbytes); 831 inode_add_bytes(inode, nbytes);
832update_inode:
828 ret = btrfs_update_inode(trans, root, inode); 833 ret = btrfs_update_inode(trans, root, inode);
829out: 834out:
830 if (inode) 835 if (inode)
@@ -1322,8 +1327,9 @@ static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
1322 } 1327 }
1323 1328
1324 /* insert our name */ 1329 /* insert our name */
1325 ret = btrfs_add_link(trans, dir, inode, name, namelen, 1330 ret = btrfs_add_link(trans, BTRFS_I(dir),
1326 0, ref_index); 1331 BTRFS_I(inode),
1332 name, namelen, 0, ref_index);
1327 if (ret) 1333 if (ret)
1328 goto out; 1334 goto out;
1329 1335
@@ -1641,7 +1647,8 @@ static noinline int insert_one_name(struct btrfs_trans_handle *trans,
1641 return -EIO; 1647 return -EIO;
1642 } 1648 }
1643 1649
1644 ret = btrfs_add_link(trans, dir, inode, name, name_len, 1, index); 1650 ret = btrfs_add_link(trans, BTRFS_I(dir), BTRFS_I(inode), name,
1651 name_len, 1, index);
1645 1652
1646 /* FIXME, put inode into FIXUP list */ 1653 /* FIXME, put inode into FIXUP list */
1647 1654
@@ -1780,7 +1787,7 @@ static noinline int replay_one_name(struct btrfs_trans_handle *trans,
1780out: 1787out:
1781 btrfs_release_path(path); 1788 btrfs_release_path(path);
1782 if (!ret && update_size) { 1789 if (!ret && update_size) {
1783 btrfs_i_size_write(dir, dir->i_size + name_len * 2); 1790 btrfs_i_size_write(BTRFS_I(dir), dir->i_size + name_len * 2);
1784 ret = btrfs_update_inode(trans, root, dir); 1791 ret = btrfs_update_inode(trans, root, dir);
1785 } 1792 }
1786 kfree(name); 1793 kfree(name);
@@ -5045,14 +5052,14 @@ static bool btrfs_must_commit_transaction(struct btrfs_trans_handle *trans,
5045 * a full commit is required. 5052 * a full commit is required.
5046 */ 5053 */
5047static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans, 5054static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
5048 struct inode *inode, 5055 struct btrfs_inode *inode,
5049 struct dentry *parent, 5056 struct dentry *parent,
5050 struct super_block *sb, 5057 struct super_block *sb,
5051 u64 last_committed) 5058 u64 last_committed)
5052{ 5059{
5053 int ret = 0; 5060 int ret = 0;
5054 struct dentry *old_parent = NULL; 5061 struct dentry *old_parent = NULL;
5055 struct inode *orig_inode = inode; 5062 struct btrfs_inode *orig_inode = inode;
5056 5063
5057 /* 5064 /*
5058 * for regular files, if its inode is already on disk, we don't 5065 * for regular files, if its inode is already on disk, we don't
@@ -5060,15 +5067,15 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
5060 * we can use the last_unlink_trans field to record renames 5067 * we can use the last_unlink_trans field to record renames
5061 * and other fun in this file. 5068 * and other fun in this file.
5062 */ 5069 */
5063 if (S_ISREG(inode->i_mode) && 5070 if (S_ISREG(inode->vfs_inode.i_mode) &&
5064 BTRFS_I(inode)->generation <= last_committed && 5071 inode->generation <= last_committed &&
5065 BTRFS_I(inode)->last_unlink_trans <= last_committed) 5072 inode->last_unlink_trans <= last_committed)
5066 goto out; 5073 goto out;
5067 5074
5068 if (!S_ISDIR(inode->i_mode)) { 5075 if (!S_ISDIR(inode->vfs_inode.i_mode)) {
5069 if (!parent || d_really_is_negative(parent) || sb != parent->d_sb) 5076 if (!parent || d_really_is_negative(parent) || sb != parent->d_sb)
5070 goto out; 5077 goto out;
5071 inode = d_inode(parent); 5078 inode = BTRFS_I(d_inode(parent));
5072 } 5079 }
5073 5080
5074 while (1) { 5081 while (1) {
@@ -5079,10 +5086,10 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
5079 * think this inode has already been logged. 5086 * think this inode has already been logged.
5080 */ 5087 */
5081 if (inode != orig_inode) 5088 if (inode != orig_inode)
5082 BTRFS_I(inode)->logged_trans = trans->transid; 5089 inode->logged_trans = trans->transid;
5083 smp_mb(); 5090 smp_mb();
5084 5091
5085 if (btrfs_must_commit_transaction(trans, BTRFS_I(inode))) { 5092 if (btrfs_must_commit_transaction(trans, inode)) {
5086 ret = 1; 5093 ret = 1;
5087 break; 5094 break;
5088 } 5095 }
@@ -5091,8 +5098,8 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
5091 break; 5098 break;
5092 5099
5093 if (IS_ROOT(parent)) { 5100 if (IS_ROOT(parent)) {
5094 inode = d_inode(parent); 5101 inode = BTRFS_I(d_inode(parent));
5095 if (btrfs_must_commit_transaction(trans, BTRFS_I(inode))) 5102 if (btrfs_must_commit_transaction(trans, inode))
5096 ret = 1; 5103 ret = 1;
5097 break; 5104 break;
5098 } 5105 }
@@ -5100,7 +5107,7 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
5100 parent = dget_parent(parent); 5107 parent = dget_parent(parent);
5101 dput(old_parent); 5108 dput(old_parent);
5102 old_parent = parent; 5109 old_parent = parent;
5103 inode = d_inode(parent); 5110 inode = BTRFS_I(d_inode(parent));
5104 5111
5105 } 5112 }
5106 dput(old_parent); 5113 dput(old_parent);
@@ -5287,15 +5294,15 @@ next_dir_inode:
5287} 5294}
5288 5295
5289static int btrfs_log_all_parents(struct btrfs_trans_handle *trans, 5296static int btrfs_log_all_parents(struct btrfs_trans_handle *trans,
5290 struct inode *inode, 5297 struct btrfs_inode *inode,
5291 struct btrfs_log_ctx *ctx) 5298 struct btrfs_log_ctx *ctx)
5292{ 5299{
5293 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 5300 struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
5294 int ret; 5301 int ret;
5295 struct btrfs_path *path; 5302 struct btrfs_path *path;
5296 struct btrfs_key key; 5303 struct btrfs_key key;
5297 struct btrfs_root *root = BTRFS_I(inode)->root; 5304 struct btrfs_root *root = inode->root;
5298 const u64 ino = btrfs_ino(BTRFS_I(inode)); 5305 const u64 ino = btrfs_ino(inode);
5299 5306
5300 path = btrfs_alloc_path(); 5307 path = btrfs_alloc_path();
5301 if (!path) 5308 if (!path)
@@ -5390,7 +5397,8 @@ out:
5390 * the last committed transaction 5397 * the last committed transaction
5391 */ 5398 */
5392static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans, 5399static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
5393 struct btrfs_root *root, struct inode *inode, 5400 struct btrfs_root *root,
5401 struct btrfs_inode *inode,
5394 struct dentry *parent, 5402 struct dentry *parent,
5395 const loff_t start, 5403 const loff_t start,
5396 const loff_t end, 5404 const loff_t end,
@@ -5404,9 +5412,9 @@ static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
5404 int ret = 0; 5412 int ret = 0;
5405 u64 last_committed = fs_info->last_trans_committed; 5413 u64 last_committed = fs_info->last_trans_committed;
5406 bool log_dentries = false; 5414 bool log_dentries = false;
5407 struct inode *orig_inode = inode; 5415 struct btrfs_inode *orig_inode = inode;
5408 5416
5409 sb = inode->i_sb; 5417 sb = inode->vfs_inode.i_sb;
5410 5418
5411 if (btrfs_test_opt(fs_info, NOTREELOG)) { 5419 if (btrfs_test_opt(fs_info, NOTREELOG)) {
5412 ret = 1; 5420 ret = 1;
@@ -5423,18 +5431,17 @@ static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
5423 goto end_no_trans; 5431 goto end_no_trans;
5424 } 5432 }
5425 5433
5426 if (root != BTRFS_I(inode)->root || 5434 if (root != inode->root || btrfs_root_refs(&root->root_item) == 0) {
5427 btrfs_root_refs(&root->root_item) == 0) {
5428 ret = 1; 5435 ret = 1;
5429 goto end_no_trans; 5436 goto end_no_trans;
5430 } 5437 }
5431 5438
5432 ret = check_parent_dirs_for_sync(trans, inode, parent, 5439 ret = check_parent_dirs_for_sync(trans, inode, parent, sb,
5433 sb, last_committed); 5440 last_committed);
5434 if (ret) 5441 if (ret)
5435 goto end_no_trans; 5442 goto end_no_trans;
5436 5443
5437 if (btrfs_inode_in_log(BTRFS_I(inode), trans->transid)) { 5444 if (btrfs_inode_in_log(inode, trans->transid)) {
5438 ret = BTRFS_NO_LOG_SYNC; 5445 ret = BTRFS_NO_LOG_SYNC;
5439 goto end_no_trans; 5446 goto end_no_trans;
5440 } 5447 }
@@ -5443,8 +5450,7 @@ static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
5443 if (ret) 5450 if (ret)
5444 goto end_no_trans; 5451 goto end_no_trans;
5445 5452
5446 ret = btrfs_log_inode(trans, root, BTRFS_I(inode), inode_only, 5453 ret = btrfs_log_inode(trans, root, inode, inode_only, start, end, ctx);
5447 start, end, ctx);
5448 if (ret) 5454 if (ret)
5449 goto end_trans; 5455 goto end_trans;
5450 5456
@@ -5454,14 +5460,14 @@ static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
5454 * we can use the last_unlink_trans field to record renames 5460 * we can use the last_unlink_trans field to record renames
5455 * and other fun in this file. 5461 * and other fun in this file.
5456 */ 5462 */
5457 if (S_ISREG(inode->i_mode) && 5463 if (S_ISREG(inode->vfs_inode.i_mode) &&
5458 BTRFS_I(inode)->generation <= last_committed && 5464 inode->generation <= last_committed &&
5459 BTRFS_I(inode)->last_unlink_trans <= last_committed) { 5465 inode->last_unlink_trans <= last_committed) {
5460 ret = 0; 5466 ret = 0;
5461 goto end_trans; 5467 goto end_trans;
5462 } 5468 }
5463 5469
5464 if (S_ISDIR(inode->i_mode) && ctx && ctx->log_new_dentries) 5470 if (S_ISDIR(inode->vfs_inode.i_mode) && ctx && ctx->log_new_dentries)
5465 log_dentries = true; 5471 log_dentries = true;
5466 5472
5467 /* 5473 /*
@@ -5505,7 +5511,7 @@ static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
5505 * but the file inode does not have a matching BTRFS_INODE_REF_KEY item 5511 * but the file inode does not have a matching BTRFS_INODE_REF_KEY item
5506 * and has a link count of 2. 5512 * and has a link count of 2.
5507 */ 5513 */
5508 if (BTRFS_I(inode)->last_unlink_trans > last_committed) { 5514 if (inode->last_unlink_trans > last_committed) {
5509 ret = btrfs_log_all_parents(trans, orig_inode, ctx); 5515 ret = btrfs_log_all_parents(trans, orig_inode, ctx);
5510 if (ret) 5516 if (ret)
5511 goto end_trans; 5517 goto end_trans;
@@ -5515,14 +5521,13 @@ static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
5515 if (!parent || d_really_is_negative(parent) || sb != parent->d_sb) 5521 if (!parent || d_really_is_negative(parent) || sb != parent->d_sb)
5516 break; 5522 break;
5517 5523
5518 inode = d_inode(parent); 5524 inode = BTRFS_I(d_inode(parent));
5519 if (root != BTRFS_I(inode)->root) 5525 if (root != inode->root)
5520 break; 5526 break;
5521 5527
5522 if (BTRFS_I(inode)->generation > last_committed) { 5528 if (inode->generation > last_committed) {
5523 ret = btrfs_log_inode(trans, root, BTRFS_I(inode), 5529 ret = btrfs_log_inode(trans, root, inode,
5524 LOG_INODE_EXISTS, 5530 LOG_INODE_EXISTS, 0, LLONG_MAX, ctx);
5525 0, LLONG_MAX, ctx);
5526 if (ret) 5531 if (ret)
5527 goto end_trans; 5532 goto end_trans;
5528 } 5533 }
@@ -5534,7 +5539,7 @@ static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
5534 old_parent = parent; 5539 old_parent = parent;
5535 } 5540 }
5536 if (log_dentries) 5541 if (log_dentries)
5537 ret = log_new_dir_dentries(trans, root, BTRFS_I(orig_inode), ctx); 5542 ret = log_new_dir_dentries(trans, root, orig_inode, ctx);
5538 else 5543 else
5539 ret = 0; 5544 ret = 0;
5540end_trans: 5545end_trans:
@@ -5566,8 +5571,8 @@ int btrfs_log_dentry_safe(struct btrfs_trans_handle *trans,
5566 struct dentry *parent = dget_parent(dentry); 5571 struct dentry *parent = dget_parent(dentry);
5567 int ret; 5572 int ret;
5568 5573
5569 ret = btrfs_log_inode_parent(trans, root, d_inode(dentry), parent, 5574 ret = btrfs_log_inode_parent(trans, root, BTRFS_I(d_inode(dentry)),
5570 start, end, 0, ctx); 5575 parent, start, end, 0, ctx);
5571 dput(parent); 5576 dput(parent);
5572 5577
5573 return ret; 5578 return ret;
@@ -5829,7 +5834,7 @@ int btrfs_log_new_name(struct btrfs_trans_handle *trans,
5829 (!old_dir || old_dir->logged_trans <= fs_info->last_trans_committed)) 5834 (!old_dir || old_dir->logged_trans <= fs_info->last_trans_committed))
5830 return 0; 5835 return 0;
5831 5836
5832 return btrfs_log_inode_parent(trans, root, &inode->vfs_inode, parent, 0, 5837 return btrfs_log_inode_parent(trans, root, inode, parent, 0,
5833 LLONG_MAX, 1, NULL); 5838 LLONG_MAX, 1, NULL);
5834} 5839}
5835 5840
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 13e55d13045d..73d56eef5e60 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -1725,7 +1725,7 @@ out:
1725 * Function to update ctime/mtime for a given device path. 1725 * Function to update ctime/mtime for a given device path.
1726 * Mainly used for ctime/mtime based probe like libblkid. 1726 * Mainly used for ctime/mtime based probe like libblkid.
1727 */ 1727 */
1728static void update_dev_time(char *path_name) 1728static void update_dev_time(const char *path_name)
1729{ 1729{
1730 struct file *filp; 1730 struct file *filp;
1731 1731
@@ -1851,7 +1851,8 @@ void btrfs_assign_next_active_device(struct btrfs_fs_info *fs_info,
1851 fs_info->fs_devices->latest_bdev = next_device->bdev; 1851 fs_info->fs_devices->latest_bdev = next_device->bdev;
1852} 1852}
1853 1853
1854int btrfs_rm_device(struct btrfs_fs_info *fs_info, char *device_path, u64 devid) 1854int btrfs_rm_device(struct btrfs_fs_info *fs_info, const char *device_path,
1855 u64 devid)
1855{ 1856{
1856 struct btrfs_device *device; 1857 struct btrfs_device *device;
1857 struct btrfs_fs_devices *cur_devices; 1858 struct btrfs_fs_devices *cur_devices;
@@ -2091,7 +2092,7 @@ void btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
2091} 2092}
2092 2093
2093static int btrfs_find_device_by_path(struct btrfs_fs_info *fs_info, 2094static int btrfs_find_device_by_path(struct btrfs_fs_info *fs_info,
2094 char *device_path, 2095 const char *device_path,
2095 struct btrfs_device **device) 2096 struct btrfs_device **device)
2096{ 2097{
2097 int ret = 0; 2098 int ret = 0;
@@ -2118,7 +2119,7 @@ static int btrfs_find_device_by_path(struct btrfs_fs_info *fs_info,
2118} 2119}
2119 2120
2120int btrfs_find_device_missing_or_by_path(struct btrfs_fs_info *fs_info, 2121int btrfs_find_device_missing_or_by_path(struct btrfs_fs_info *fs_info,
2121 char *device_path, 2122 const char *device_path,
2122 struct btrfs_device **device) 2123 struct btrfs_device **device)
2123{ 2124{
2124 *device = NULL; 2125 *device = NULL;
@@ -2151,7 +2152,8 @@ int btrfs_find_device_missing_or_by_path(struct btrfs_fs_info *fs_info,
2151 * Lookup a device given by device id, or the path if the id is 0. 2152 * Lookup a device given by device id, or the path if the id is 0.
2152 */ 2153 */
2153int btrfs_find_device_by_devspec(struct btrfs_fs_info *fs_info, u64 devid, 2154int btrfs_find_device_by_devspec(struct btrfs_fs_info *fs_info, u64 devid,
2154 char *devpath, struct btrfs_device **device) 2155 const char *devpath,
2156 struct btrfs_device **device)
2155{ 2157{
2156 int ret; 2158 int ret;
2157 2159
@@ -2307,7 +2309,7 @@ error:
2307 return ret; 2309 return ret;
2308} 2310}
2309 2311
2310int btrfs_init_new_device(struct btrfs_fs_info *fs_info, char *device_path) 2312int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path)
2311{ 2313{
2312 struct btrfs_root *root = fs_info->dev_root; 2314 struct btrfs_root *root = fs_info->dev_root;
2313 struct request_queue *q; 2315 struct request_queue *q;
@@ -2515,7 +2517,7 @@ error:
2515} 2517}
2516 2518
2517int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info, 2519int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
2518 char *device_path, 2520 const char *device_path,
2519 struct btrfs_device *srcdev, 2521 struct btrfs_device *srcdev,
2520 struct btrfs_device **device_out) 2522 struct btrfs_device **device_out)
2521{ 2523{
@@ -6954,7 +6956,8 @@ static int update_dev_stat_item(struct btrfs_trans_handle *trans,
6954 key.offset = device->devid; 6956 key.offset = device->devid;
6955 6957
6956 path = btrfs_alloc_path(); 6958 path = btrfs_alloc_path();
6957 BUG_ON(!path); 6959 if (!path)
6960 return -ENOMEM;
6958 ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1); 6961 ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1);
6959 if (ret < 0) { 6962 if (ret < 0) {
6960 btrfs_warn_in_rcu(fs_info, 6963 btrfs_warn_in_rcu(fs_info,
@@ -7102,7 +7105,7 @@ int btrfs_get_dev_stats(struct btrfs_fs_info *fs_info,
7102 return 0; 7105 return 0;
7103} 7106}
7104 7107
7105void btrfs_scratch_superblocks(struct block_device *bdev, char *device_path) 7108void btrfs_scratch_superblocks(struct block_device *bdev, const char *device_path)
7106{ 7109{
7107 struct buffer_head *bh; 7110 struct buffer_head *bh;
7108 struct btrfs_super_block *disk_super; 7111 struct btrfs_super_block *disk_super;
diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h
index 24ba6bc3ec34..59be81206dd7 100644
--- a/fs/btrfs/volumes.h
+++ b/fs/btrfs/volumes.h
@@ -422,16 +422,16 @@ void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices, int step);
422void btrfs_assign_next_active_device(struct btrfs_fs_info *fs_info, 422void btrfs_assign_next_active_device(struct btrfs_fs_info *fs_info,
423 struct btrfs_device *device, struct btrfs_device *this_dev); 423 struct btrfs_device *device, struct btrfs_device *this_dev);
424int btrfs_find_device_missing_or_by_path(struct btrfs_fs_info *fs_info, 424int btrfs_find_device_missing_or_by_path(struct btrfs_fs_info *fs_info,
425 char *device_path, 425 const char *device_path,
426 struct btrfs_device **device); 426 struct btrfs_device **device);
427int btrfs_find_device_by_devspec(struct btrfs_fs_info *fs_info, u64 devid, 427int btrfs_find_device_by_devspec(struct btrfs_fs_info *fs_info, u64 devid,
428 char *devpath, 428 const char *devpath,
429 struct btrfs_device **device); 429 struct btrfs_device **device);
430struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info, 430struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,
431 const u64 *devid, 431 const u64 *devid,
432 const u8 *uuid); 432 const u8 *uuid);
433int btrfs_rm_device(struct btrfs_fs_info *fs_info, 433int btrfs_rm_device(struct btrfs_fs_info *fs_info,
434 char *device_path, u64 devid); 434 const char *device_path, u64 devid);
435void btrfs_cleanup_fs_uuids(void); 435void btrfs_cleanup_fs_uuids(void);
436int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len); 436int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);
437int btrfs_grow_device(struct btrfs_trans_handle *trans, 437int btrfs_grow_device(struct btrfs_trans_handle *trans,
@@ -439,9 +439,9 @@ int btrfs_grow_device(struct btrfs_trans_handle *trans,
439struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid, 439struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
440 u8 *uuid, u8 *fsid); 440 u8 *uuid, u8 *fsid);
441int btrfs_shrink_device(struct btrfs_device *device, u64 new_size); 441int btrfs_shrink_device(struct btrfs_device *device, u64 new_size);
442int btrfs_init_new_device(struct btrfs_fs_info *fs_info, char *path); 442int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *path);
443int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info, 443int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
444 char *device_path, 444 const char *device_path,
445 struct btrfs_device *srcdev, 445 struct btrfs_device *srcdev,
446 struct btrfs_device **device_out); 446 struct btrfs_device **device_out);
447int btrfs_balance(struct btrfs_balance_control *bctl, 447int btrfs_balance(struct btrfs_balance_control *bctl,
@@ -474,7 +474,7 @@ void btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
474 struct btrfs_device *tgtdev); 474 struct btrfs_device *tgtdev);
475void btrfs_init_dev_replace_tgtdev_for_resume(struct btrfs_fs_info *fs_info, 475void btrfs_init_dev_replace_tgtdev_for_resume(struct btrfs_fs_info *fs_info,
476 struct btrfs_device *tgtdev); 476 struct btrfs_device *tgtdev);
477void btrfs_scratch_superblocks(struct block_device *bdev, char *device_path); 477void btrfs_scratch_superblocks(struct block_device *bdev, const char *device_path);
478int btrfs_is_parity_mirror(struct btrfs_mapping_tree *map_tree, 478int btrfs_is_parity_mirror(struct btrfs_mapping_tree *map_tree,
479 u64 logical, u64 len, int mirror_num); 479 u64 logical, u64 len, int mirror_num);
480unsigned long btrfs_full_stripe_len(struct btrfs_fs_info *fs_info, 480unsigned long btrfs_full_stripe_len(struct btrfs_fs_info *fs_info,
diff --git a/fs/btrfs/zlib.c b/fs/btrfs/zlib.c
index da497f184ff4..135b10823c6d 100644
--- a/fs/btrfs/zlib.c
+++ b/fs/btrfs/zlib.c
@@ -73,13 +73,11 @@ fail:
73 73
74static int zlib_compress_pages(struct list_head *ws, 74static int zlib_compress_pages(struct list_head *ws,
75 struct address_space *mapping, 75 struct address_space *mapping,
76 u64 start, unsigned long len, 76 u64 start,
77 struct page **pages, 77 struct page **pages,
78 unsigned long nr_dest_pages,
79 unsigned long *out_pages, 78 unsigned long *out_pages,
80 unsigned long *total_in, 79 unsigned long *total_in,
81 unsigned long *total_out, 80 unsigned long *total_out)
82 unsigned long max_out)
83{ 81{
84 struct workspace *workspace = list_entry(ws, struct workspace, list); 82 struct workspace *workspace = list_entry(ws, struct workspace, list);
85 int ret; 83 int ret;
@@ -89,6 +87,9 @@ static int zlib_compress_pages(struct list_head *ws,
89 struct page *in_page = NULL; 87 struct page *in_page = NULL;
90 struct page *out_page = NULL; 88 struct page *out_page = NULL;
91 unsigned long bytes_left; 89 unsigned long bytes_left;
90 unsigned long len = *total_out;
91 unsigned long nr_dest_pages = *out_pages;
92 const unsigned long max_out = nr_dest_pages * PAGE_SIZE;
92 93
93 *out_pages = 0; 94 *out_pages = 0;
94 *total_out = 0; 95 *total_out = 0;
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-10 07:23:24 -0500