btrfs: define separate btrfs_set/get_XX helpers

There are helpers for all type widths defined via macro and optionally
can use a token which is a cached pointer to avoid repeated mapping of
the extent buffer.

The token value is known at compile time, when it's valid it's always
address of a local variable, otherwise it's NULL passed by the
token-less helpers.

This can be utilized to remove some branching as the helpers are used
frequenlty.

Signed-off-by: David Sterba <dsterba@suse.com>

2 files changed, 55 insertions, 11 deletions

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 292e21b23217..8e18fb062215 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -1335,17 +1335,10 @@ u##bits btrfs_get_token_##bits(const struct extent_buffer *eb,		\
 void btrfs_set_token_##bits(struct extent_buffer *eb, const void *ptr,  \
                             unsigned long off, u##bits val,             \
                             struct btrfs_map_token *token);             \
-static inline u##bits btrfs_get_##bits(const struct extent_buffer *eb,  \
-                                       const void *ptr,                 \
-                                       unsigned long off)               \
-{                                                                       \
-        return btrfs_get_token_##bits(eb, ptr, off, NULL);              \
-}                                                                       \
-static inline void btrfs_set_##bits(struct extent_buffer *eb, void *ptr,\
-                                    unsigned long off, u##bits val)     \
-{                                                                       \
-       btrfs_set_token_##bits(eb, ptr, off, val, NULL);                 \
-}
+u##bits btrfs_get_##bits(const struct extent_buffer *eb,                \
+                         const void *ptr, unsigned long off);           \
+void btrfs_set_##bits(struct extent_buffer *eb, void *ptr,              \
+                      unsigned long off, u##bits val);
 
 DECLARE_BTRFS_SETGET_BITS(8)
 DECLARE_BTRFS_SETGET_BITS(16)
diff --git a/fs/btrfs/struct-funcs.c b/fs/btrfs/struct-funcs.c
index 4c13b737f568..e63936e4c1e0 100644
--- a/fs/btrfs/struct-funcs.c
+++ b/fs/btrfs/struct-funcs.c
@@ -33,6 +33,8 @@ static inline void put_unaligned_le8(u8 val, void *p)
  *
  * The extent buffer api is used to do the page spanning work required to
  * have a metadata blocksize different from the page size.
+ *
+ * There are 2 variants defined, one with a token pointer and one without.
  */
 
 #define DEFINE_BTRFS_SETGET_BITS(bits)                                  \
@@ -75,6 +77,31 @@ u##bits btrfs_get_token_##bits(const struct extent_buffer *eb,		\
         }                                                               \
         return res;                                                     \
 }                                                                       \
+u##bits btrfs_get_##bits(const struct extent_buffer *eb,                \
+                         const void *ptr, unsigned long off)            \
+{                                                                       \
+        unsigned long part_offset = (unsigned long)ptr;                 \
+        unsigned long offset = part_offset + off;                       \
+        void *p;                                                        \
+        int err;                                                        \
+        char *kaddr;                                                    \
+        unsigned long map_start;                                        \
+        unsigned long map_len;                                          \
+        int size = sizeof(u##bits);                                     \
+        u##bits res;                                                    \
+                                                                        \
+        err = map_private_extent_buffer(eb, offset, size,               \
+                                        &kaddr, &map_start, &map_len);  \
+        if (err) {                                                      \
+                __le##bits leres;                                       \
+                                                                        \
+                read_extent_buffer(eb, &leres, offset, size);           \
+                return le##bits##_to_cpu(leres);                        \
+        }                                                               \
+        p = kaddr + part_offset - map_start;                            \
+        res = get_unaligned_le##bits(p + off);                          \
+        return res;                                                     \
+}                                                                       \
 void btrfs_set_token_##bits(struct extent_buffer *eb,                   \
                             const void *ptr, unsigned long off,         \
                             u##bits val,                                \
@@ -113,6 +140,30 @@ void btrfs_set_token_##bits(struct extent_buffer *eb,			\
                 token->offset = map_start;                              \
                 token->eb = eb;                                         \
         }                                                               \
+}                                                                       \
+void btrfs_set_##bits(struct extent_buffer *eb, void *ptr,              \
+                      unsigned long off, u##bits val)                   \
+{                                                                       \
+        unsigned long part_offset = (unsigned long)ptr;                 \
+        unsigned long offset = part_offset + off;                       \
+        void *p;                                                        \
+        int err;                                                        \
+        char *kaddr;                                                    \
+        unsigned long map_start;                                        \
+        unsigned long map_len;                                          \
+        int size = sizeof(u##bits);                                     \
+                                                                        \
+        err = map_private_extent_buffer(eb, offset, size,               \
+                        &kaddr, &map_start, &map_len);                  \
+        if (err) {                                                      \
+                __le##bits val2;                                        \
+                                                                        \
+                val2 = cpu_to_le##bits(val);                            \
+                write_extent_buffer(eb, &val2, offset, size);           \
+                return;                                                 \
+        }                                                               \
+        p = kaddr + part_offset - map_start;                            \
+        put_unaligned_le##bits(val, p + off);                           \
 }
 
 DEFINE_BTRFS_SETGET_BITS(8)