btrfs: Get rid of the confusing btrfs_file_extent_inline_len

BugLink: https://bugs.launchpad.net/bugs/1866678
[ Upstream commit e41ca5897489b1c18af75ff0cc8f5c80260b3281 ]

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>
Signed-off-by: Sasha Levin <sashal@kernel.org>
Signed-off-by: Kamal Mostafa <kamal@canonical.com>
Signed-off-by: Khalid Elmously <khalid.elmously@canonical.com>

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 35c7f95b936f459169e3654a041ab3b930444f70..54a9bdc035571c8b126dd5341e9a91ed871e02a8 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -2412,32 +2412,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 fdcb410026233ecc7c5ec475b8a5d711efc47b3c..702b3606ad0ec4818bf475fdef29e3220b7861c3 100644 (file)
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -955,7 +955,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 73c1647680fef437c5c6fbd3c292728474c903f1..e489b879d22654c9dfcf854a4922f2f118a3f1ed 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -854,8 +854,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 e870bbc8760652d6ad5e681dd552cf39a7b2f7cf..697b793adf46431bd26221fda9fa68a89ebfa634 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -1478,8 +1478,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 {
@@ -4610,8 +4609,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],
@@ -7112,7 +7111,8 @@ again:
                                                       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);
 
@@ -7163,7 +7163,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 569205e651c7dd46c98a8fe3d0798140322d4ec3..47336d4b19d848f665db6e2549c4ad2c0d898253 100644 (file)
--- a/fs/btrfs/print-tree.c
+++ b/fs/btrfs/print-tree.c
@@ -259,8 +259,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 3d482b0e9a4dac39b839a8127a1f12c80fb10e0c..8cd6c85c4cc61103b9bf14ff857f2e28b6d626fc 100644 (file)
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -1540,7 +1540,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);
 
@@ -5208,7 +5208,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);
@@ -5284,8 +5284,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
@@ -5418,7 +5417,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);
@@ -5539,8 +5538,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 {
@@ -5603,7 +5601,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);
@@ -5649,8 +5647,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 544b5cc4a7ed3688c7f721aecf826de811dbf0ff..97de04cfb732b4c1b172ca6d75f1d2a149e40af7 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -619,7 +619,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);
@@ -3945,9 +3945,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 {
@@ -4012,7 +4010,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 {

diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index 4342a329821f4b4911a824b5b8febd6b52aaede9..9a44f0515819206f70597fd7b8c9299dd8781560 100644 (file)
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -332,7 +332,7 @@ DECLARE_EVENT_CLASS(
                __entry->extent_type    = btrfs_file_extent_type(l, fi);
                __entry->compression    = btrfs_file_extent_compression(l, fi);
                __entry->extent_start   = start;
-               __entry->extent_end     = (start + btrfs_file_extent_inline_len(l, slot, fi));
+               __entry->extent_end     = (start + btrfs_file_extent_ram_bytes(l, fi));
        ),
 
        TP_printk_btrfs(