btrfs: accessors: simplify folio bounds checks

As we can a have non-contiguous range in the eb->folios, any item can be
straddling two folios and we need to check if it can be read in one go
or in two parts. For that there's a check which is not implemented in
the simplest way:

  offset in folio + size <= folio size

With a simple expression transformation:

  oil + size <= unit_size
        size <= unit_size - oil
    sizeof() <= part

this can be simplified and reusing existing run-time or compile-time
constants.

Add likely() annotation for this expression as this is the fast path and
compiler sometimes reorders that after the followup block with the
memcpy (observed in practice with other simplifications).

Overall effect on stack consumption:

  btrfs_get_8                                        -8 (80 -> 72)
  btrfs_set_8                                        -8 (88 -> 80)

And .ko size (due to optimizations making use of the direct constants):

     text    data     bss     dec     hex filename
  1456601  115665   16088 1588354  183c82 pre/btrfs.ko
  1456093  115665   16088 1587846  183a86 post/btrfs.ko

  DELTA: -508

Reviewed-by: Boris Burkov <boris@bur.io>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/accessors.c b/fs/btrfs/accessors.c
index 5cfb0801700e6c87e60bdbbdadde773deef7642c..b54c8abe467a0697175ab092c6d65db2b1c8bf1a 100644 (file)
--- a/fs/btrfs/accessors.c
+++ b/fs/btrfs/accessors.c
@@ -59,7 +59,7 @@ u##bits btrfs_get_##bits(const struct extent_buffer *eb,              \
        u8 lebytes[sizeof(u##bits)];                                    \
                                                                        \
        ASSERT(check_setget_bounds(eb, ptr, off, size));                \
-       if (INLINE_EXTENT_BUFFER_PAGES == 1 || oil + size <= unit_size) \
+       if (INLINE_EXTENT_BUFFER_PAGES == 1 || likely(sizeof(u##bits) <= part)) \
                return get_unaligned_le##bits(kaddr + oil);             \
                                                                        \
        memcpy(lebytes, kaddr + oil, part);                             \
@@ -82,7 +82,7 @@ void btrfs_set_##bits(const struct extent_buffer *eb, void *ptr,      \
                                                                        \
        ASSERT(check_setget_bounds(eb, ptr, off, size));                \
        if (INLINE_EXTENT_BUFFER_PAGES == 1 ||                          \
-           oil + size <= unit_size) {                                  \
+           likely(sizeof(u##bits) <= part)) {                          \
                put_unaligned_le##bits(val, kaddr + oil);               \
                return;                                                 \
        }                                                               \