btrfs: Get rid of the confusing btrfs_file_extent_inline_len

We used to call btrfs_file_extent_inline_len() to get the uncompressed
data size of an inlined extent.

However this function is hiding evil, for compressed extent, it has no
choice but to directly read out ram_bytes from btrfs_file_extent_item.
While for uncompressed extent, it uses item size to calculate the real
data size, and ignoring ram_bytes completely.

In fact, for corrupted ram_bytes, due to above behavior kernel
btrfs_print_leaf() can't even print correct ram_bytes to expose the bug.

Since we have the tree-checker to verify all EXTENT_DATA, such mismatch
can be detected pretty easily, thus we can trust ram_bytes without the
evil btrfs_file_extent_inline_len().

Signed-off-by: Qu Wenruo <wqu@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

7 files changed, 21 insertions, 55 deletions

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 12cb327cd16e..41ba770b9db9 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -2428,32 +2428,6 @@ static inline u32 btrfs_file_extent_inline_item_len(
         return btrfs_item_size(eb, e) - BTRFS_FILE_EXTENT_INLINE_DATA_START;
 }
 
-/* this returns the number of file bytes represented by the inline item.
- * If an item is compressed, this is the uncompressed size
- */
-static inline u32 btrfs_file_extent_inline_len(const struct extent_buffer *eb,
-                                        int slot,
-                                        const struct btrfs_file_extent_item *fi)
-{
-        struct btrfs_map_token token;
-
-        btrfs_init_map_token(&token);
-        /*
-         * return the space used on disk if this item isn't
-         * compressed or encoded
-         */
-        if (btrfs_token_file_extent_compression(eb, fi, &token) == 0 &&
-            btrfs_token_file_extent_encryption(eb, fi, &token) == 0 &&
-            btrfs_token_file_extent_other_encoding(eb, fi, &token) == 0) {
-                return btrfs_file_extent_inline_item_len(eb,
-                                                         btrfs_item_nr(slot));
-        }
-
-        /* otherwise use the ram bytes field */
-        return btrfs_token_file_extent_ram_bytes(eb, fi, &token);
-}
-
-
 /* btrfs_dev_stats_item */
 static inline u64 btrfs_dev_stats_value(const struct extent_buffer *eb,
                                         const struct btrfs_dev_stats_item *ptr,
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index f9dd6d1836a3..8c3cd7072caf 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -942,7 +942,7 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
                         btrfs_file_extent_num_bytes(leaf, fi);
         } else if (type == BTRFS_FILE_EXTENT_INLINE) {
                 size_t size;
-                size = btrfs_file_extent_inline_len(leaf, slot, fi);
+                size = btrfs_file_extent_ram_bytes(leaf, fi);
                 extent_end = ALIGN(extent_start + size,
                                    fs_info->sectorsize);
         }
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 975c590c50d8..4cd8af14f915 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -833,8 +833,7 @@ next_slot:
                                 btrfs_file_extent_num_bytes(leaf, fi);
                 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
                         extent_end = key.offset +
-                                btrfs_file_extent_inline_len(leaf,
-                                                     path->slots[0], fi);
+                                btrfs_file_extent_ram_bytes(leaf, fi);
                 } else {
                         /* can't happen */
                         BUG();
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index eba61bcb9bb3..1ade43c02b81 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -1443,8 +1443,7 @@ next_slot:
                         nocow = 1;
                 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
                         extent_end = found_key.offset +
-                                btrfs_file_extent_inline_len(leaf,
-                                                     path->slots[0], fi);
+                                btrfs_file_extent_ram_bytes(leaf, fi);
                         extent_end = ALIGN(extent_end,
                                            fs_info->sectorsize);
                 } else {
@@ -4643,8 +4642,8 @@ search_again:
                                         BTRFS_I(inode), leaf, fi,
                                         found_key.offset);
                         } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
-                                item_end += btrfs_file_extent_inline_len(leaf,
-                                                         path->slots[0], fi);
+                                item_end += btrfs_file_extent_ram_bytes(leaf,
+                                                                        fi);
 
                                 trace_btrfs_truncate_show_fi_inline(
                                         BTRFS_I(inode), leaf, fi, path->slots[0],
@@ -6943,7 +6942,8 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,
                                                        extent_start);
         } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
                 size_t size;
-                size = btrfs_file_extent_inline_len(leaf, path->slots[0], item);
+
+                size = btrfs_file_extent_ram_bytes(leaf, item);
                 extent_end = ALIGN(extent_start + size,
                                    fs_info->sectorsize);
 
@@ -6994,7 +6994,7 @@ next:
                 if (new_inline)
                         goto out;
 
-                size = btrfs_file_extent_inline_len(leaf, path->slots[0], item);
+                size = btrfs_file_extent_ram_bytes(leaf, item);
                 extent_offset = page_offset(page) + pg_offset - extent_start;
                 copy_size = min_t(u64, PAGE_SIZE - pg_offset,
                                   size - extent_offset);
diff --git a/fs/btrfs/print-tree.c b/fs/btrfs/print-tree.c
index a4e11cf04671..59efcf2e0de8 100644
--- a/fs/btrfs/print-tree.c
+++ b/fs/btrfs/print-tree.c
@@ -267,8 +267,8 @@ void btrfs_print_leaf(struct extent_buffer *l)
                                             struct btrfs_file_extent_item);
                         if (btrfs_file_extent_type(l, fi) ==
                             BTRFS_FILE_EXTENT_INLINE) {
-                                pr_info("\t\tinline extent data size %u\n",
-                                       btrfs_file_extent_inline_len(l, i, fi));
+                                pr_info("\t\tinline extent data size %llu\n",
+                                       btrfs_file_extent_ram_bytes(l, fi));
                                 break;
                         }
                         pr_info("\t\textent data disk bytenr %llu nr %llu\n",
diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index c47f62b19226..6ff7a1315e52 100644
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -1500,7 +1500,7 @@ static int read_symlink(struct btrfs_root *root,
         BUG_ON(compression);
 
         off = btrfs_file_extent_inline_start(ei);
-        len = btrfs_file_extent_inline_len(path->nodes[0], path->slots[0], ei);
+        len = btrfs_file_extent_ram_bytes(path->nodes[0], ei);
 
         ret = fs_path_add_from_extent_buffer(dest, path->nodes[0], off, len);
 
@@ -5160,7 +5160,7 @@ static int clone_range(struct send_ctx *sctx,
                 ei = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
                 type = btrfs_file_extent_type(leaf, ei);
                 if (type == BTRFS_FILE_EXTENT_INLINE) {
-                        ext_len = btrfs_file_extent_inline_len(leaf, slot, ei);
+                        ext_len = btrfs_file_extent_ram_bytes(leaf, ei);
                         ext_len = PAGE_ALIGN(ext_len);
                 } else {
                         ext_len = btrfs_file_extent_num_bytes(leaf, ei);
@@ -5236,8 +5236,7 @@ static int send_write_or_clone(struct send_ctx *sctx,
                         struct btrfs_file_extent_item);
         type = btrfs_file_extent_type(path->nodes[0], ei);
         if (type == BTRFS_FILE_EXTENT_INLINE) {
-                len = btrfs_file_extent_inline_len(path->nodes[0],
-                                                   path->slots[0], ei);
+                len = btrfs_file_extent_ram_bytes(path->nodes[0], ei);
                 /*
                  * it is possible the inline item won't cover the whole page,
                  * but there may be items after this page.  Make
@@ -5375,7 +5374,7 @@ static int is_extent_unchanged(struct send_ctx *sctx,
                 }
 
                 if (right_type == BTRFS_FILE_EXTENT_INLINE) {
-                        right_len = btrfs_file_extent_inline_len(eb, slot, ei);
+                        right_len = btrfs_file_extent_ram_bytes(eb, ei);
                         right_len = PAGE_ALIGN(right_len);
                 } else {
                         right_len = btrfs_file_extent_num_bytes(eb, ei);
@@ -5496,8 +5495,7 @@ static int get_last_extent(struct send_ctx *sctx, u64 offset)
                             struct btrfs_file_extent_item);
         type = btrfs_file_extent_type(path->nodes[0], fi);
         if (type == BTRFS_FILE_EXTENT_INLINE) {
-                u64 size = btrfs_file_extent_inline_len(path->nodes[0],
-                                                        path->slots[0], fi);
+                u64 size = btrfs_file_extent_ram_bytes(path->nodes[0], fi);
                 extent_end = ALIGN(key.offset + size,
                                    sctx->send_root->fs_info->sectorsize);
         } else {
@@ -5560,7 +5558,7 @@ static int range_is_hole_in_parent(struct send_ctx *sctx,
                 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
                 if (btrfs_file_extent_type(leaf, fi) ==
                     BTRFS_FILE_EXTENT_INLINE) {
-                        u64 size = btrfs_file_extent_inline_len(leaf, slot, fi);
+                        u64 size = btrfs_file_extent_ram_bytes(leaf, fi);
 
                         extent_end = ALIGN(key.offset + size,
                                            root->fs_info->sectorsize);
@@ -5606,8 +5604,7 @@ static int maybe_send_hole(struct send_ctx *sctx, struct btrfs_path *path,
                             struct btrfs_file_extent_item);
         type = btrfs_file_extent_type(path->nodes[0], fi);
         if (type == BTRFS_FILE_EXTENT_INLINE) {
-                u64 size = btrfs_file_extent_inline_len(path->nodes[0],
-                                                        path->slots[0], fi);
+                u64 size = btrfs_file_extent_ram_bytes(path->nodes[0], fi);
                 extent_end = ALIGN(key->offset + size,
                                    sctx->send_root->fs_info->sectorsize);
         } else {
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index b3b1d424f2d8..6bca8f88ade0 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -597,7 +597,7 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
                 if (btrfs_file_extent_disk_bytenr(eb, item) == 0)
                         nbytes = 0;
         } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
-                size = btrfs_file_extent_inline_len(eb, slot, item);
+                size = btrfs_file_extent_ram_bytes(eb, item);
                 nbytes = btrfs_file_extent_ram_bytes(eb, item);
                 extent_end = ALIGN(start + size,
                                    fs_info->sectorsize);
@@ -3920,9 +3920,7 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
                                         struct btrfs_file_extent_item);
                 if (btrfs_file_extent_type(src, extent) ==
                     BTRFS_FILE_EXTENT_INLINE) {
-                        len = btrfs_file_extent_inline_len(src,
-                                                           src_path->slots[0],
-                                                           extent);
+                        len = btrfs_file_extent_ram_bytes(src, extent);
                         *last_extent = ALIGN(key.offset + len,
                                              fs_info->sectorsize);
                 } else {
@@ -3987,7 +3985,7 @@ fill_holes:
                 extent = btrfs_item_ptr(src, i, struct btrfs_file_extent_item);
                 if (btrfs_file_extent_type(src, extent) ==
                     BTRFS_FILE_EXTENT_INLINE) {
-                        len = btrfs_file_extent_inline_len(src, i, extent);
+                        len = btrfs_file_extent_ram_bytes(src, extent);
                         extent_end = ALIGN(key.offset + len,
                                            fs_info->sectorsize);
                 } else {
@@ -4572,9 +4570,7 @@ static int btrfs_log_trailing_hole(struct btrfs_trans_handle *trans,
 
                 if (btrfs_file_extent_type(leaf, extent) ==
                     BTRFS_FILE_EXTENT_INLINE) {
-                        len = btrfs_file_extent_inline_len(leaf,
-                                                           path->slots[0],
-                                                           extent);
+                        len = btrfs_file_extent_ram_bytes(leaf, extent);
                         ASSERT(len == i_size ||
                                (len == fs_info->sectorsize &&
                                 btrfs_file_extent_compression(leaf, extent) !=