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>

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 292e21b23217b527d1a1d4f92475cfa5ae4cf127..8e18fb062215f886f9ec3035447b7b7b7a52cf87 100644 (file)
--- 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 4c13b737f568db9c2917ba4b610edd188e0528cb..e63936e4c1e078858122d7e82c2476ac6a4f3aa0 100644 (file)
--- 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)