Use unaligned put/get
David Sterba
maintainercover Use unaligned put/get
We use buffers that get mapped to structures and then accessed via member pointers. For all the on-disk items we have the setget helpers, but there are still some other cases like send and free space cache (v1). Due to natural alignment this worked and we haven't received reports where from strict alignment arches. Use the put/get_unaligned_le* helpers to make it explicit.
David Sterba (3):
btrfs: send: use helpers for unaligned access to header members
btrfs: free-space-cache: use unaligned helpers to access data
btrfs: use unaligned helpers for stack and header set/get helpers
fs/btrfs/ctree.h | 20 ++++++++++++++------ fs/btrfs/free-space-cache.c | 21 +++++++++------------ fs/btrfs/send.c | 14 +++++++------- fs/btrfs/struct-funcs.c | 10 ---------- 4 files changed, 30 insertions(+), 35 deletions(-)
Signature · 1 line
2.25.0
David Sterba
maintainerPATCH 1/3 btrfs: send: use helpers for unaligned access to header members
The header is mapped onto the send buffer and thus its members may be potentially unaligned so use the helpers instead of directly assigning the pointers. This has worked so far but let's use the helpers to make that clear.
--- fs/btrfs/send.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
fs/btrfs/send.c +7 -7
@@ -577,8 +577,8 @@ static int tlv_put(struct send_ctx *sctx, u16 attr, const void *data, int len)return -EOVERFLOW ; hdr = (struct btrfs_tlv_header *) (sctx->send_buf + sctx->send_size); - hdr->tlv_type =cpu_to_le16 (attr); - hdr->tlv_len =cpu_to_le16 (len); +put_unaligned_le16 (attr, &hdr->tlv_type); +put_unaligned_le16 (len, &hdr->tlv_len);memcpy (hdr +1 , data, len); sctx->send_size += total_len;
@@ -688,7 +688,7 @@ static int begin_cmd(struct send_ctx *sctx, int cmd) sctx->send_size +=sizeof (*hdr); hdr = (struct btrfs_cmd_header *)sctx->send_buf; - hdr->cmd =cpu_to_le16 (cmd); +put_unaligned_le16 (cmd, &hdr->cmd);return 0 ; }
@@ -700,17 +700,17 @@ static int send_cmd(struct send_ctx *sctx)u32 crc; hdr = (struct btrfs_cmd_header *)sctx->send_buf; - hdr->len =cpu_to_le32 (sctx->send_size -sizeof (*hdr)); - hdr->crc =0 ; +put_unaligned_le32 (sctx->send_size -sizeof (*hdr), &hdr->len); +put_unaligned_le32 (0 , &hdr->crc); crc =btrfs_crc32c (0 , (unsigned char *)sctx->send_buf, sctx->send_size); - hdr->crc =cpu_to_le32 (crc); +put_unaligned_le32 (crc, &hdr->crc); ret =write_buf (sctx->send_filp, sctx->send_buf, sctx->send_size, &sctx->send_off); sctx->total_send_size += sctx->send_size; - sctx->cmd_send_size[le16_to_cpu (hdr->cmd)] += sctx->send_size; + sctx->cmd_send_size[get_unaligned_le16 (&hdr->cmd)] += sctx->send_size; sctx->send_size =0 ;return ret;
Signature · 1 line
2.25.0
David Sterba
maintainerPATCH 2/3 btrfs: free-space-cache: use unaligned helpers to access data
In reply to David SterbaThe free space inode stores the tracking data, checksums etc, using the io_ctl structure and moving the pointers. The data are generally aligned to at least 4 bytes (u32 for CRC) so it's not completely unaligned but for clarity we should use the proper helpers whenever a struct is initialized from io_ctl->cur pointer.
--- fs/btrfs/free-space-cache.c | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-)
fs/btrfs/free-space-cache.c +9 -12
@@ -413,8 +413,6 @@ static int io_ctl_prepare_pages(struct btrfs_io_ctl *io_ctl, bool uptodate)static void io_ctl_set_generation (struct btrfs_io_ctl *io_ctl,u64 generation) { -__le64 *val; -io_ctl_map_page (io_ctl,1 );/*
@@ -429,14 +427,13 @@ static void io_ctl_set_generation(struct btrfs_io_ctl *io_ctl, u64 generation) io_ctl->size -=sizeof (u64) *2 ; } - val = io_ctl->cur; - *val =cpu_to_le64 (generation); +put_unaligned_le64 (generation, io_ctl->cur); io_ctl->cur +=sizeof (u64); }static int io_ctl_check_generation (struct btrfs_io_ctl *io_ctl,u64 generation) { -__le64 *gen; +u64 cache_gen;/* * Skip the crc area. If we don't check crcs then we just have a 64bit
@@ -451,11 +448,11 @@ static int io_ctl_check_generation(struct btrfs_io_ctl *io_ctl, u64 generation) io_ctl->size -=sizeof (u64) *2 ; } - gen = io_ctl->cur; -if (le64_to_cpu (*gen) != generation) { + cache_gen =get_unaligned_le64 (io_ctl->cur); +if (cache_gen != generation) {btrfs_err_rl (io_ctl->fs_info,"space cache generation (%llu) does not match inode (%llu)" , - *gen, generation); + cache_gen, generation);io_ctl_unmap_page (io_ctl);return -EIO ; }
@@ -525,8 +522,8 @@ static int io_ctl_add_entry(struct btrfs_io_ctl *io_ctl, u64 offset, u64 bytes,return -ENOSPC ; entry = io_ctl->cur; - entry->offset =cpu_to_le64 (offset); - entry->bytes =cpu_to_le64 (bytes); +put_unaligned_le64 (offset, &entry->offset); +put_unaligned_le64 (bytes, &entry->bytes); entry->type = (bitmap) ?BTRFS_FREE_SPACE_BITMAP :BTRFS_FREE_SPACE_EXTENT ; io_ctl->cur +=sizeof (struct btrfs_free_space_entry );
@@ -599,8 +596,8 @@ static int io_ctl_read_entry(struct btrfs_io_ctl *io_ctl, } e = io_ctl->cur; - entry->offset =le64_to_cpu (e->offset); - entry->bytes =le64_to_cpu (e->bytes); + entry->offset =get_unaligned_le64 (&e->offset); + entry->bytes =get_unaligned_le64 (&e->bytes); *type = e->type; io_ctl->cur +=sizeof (struct btrfs_free_space_entry ); io_ctl->size -=sizeof (struct btrfs_free_space_entry );
Signature · 1 line
2.25.0
David Sterba
maintainerPATCH 3/3 btrfs: use unaligned helpers for stack and header set/get helpers
In reply to David SterbaIn the definitions generated by BTRFS_SETGET_HEADER_FUNCS there's direct pointer assignment but we should use the helpers for unaligned access for clarity. It hasn't been a problem so far because of the natural alignment.
Similarly for BTRFS_SETGET_STACK_FUNCS, that usually get a structure from stack that has an aligned start but some members may not be aligned due to packing. This as well hasn't caused problems so far.
Move the put/get_unaligned_le8 stubs to ctree.h so we can use them.
--- fs/btrfs/ctree.h | 20 ++++++++++++++------ fs/btrfs/struct-funcs.c | 10 ---------- 2 files changed, 14 insertions(+), 16 deletions(-)
fs/btrfs/ctree.h +14 -6
@@ -1420,6 +1420,16 @@ static inline void btrfs_init_map_token(struct btrfs_map_token *token,#define cpu_to_le8 (v) (v)#define __le8 u8 +static inline u8 get_unaligned_le8 (const void *p) +{ +return *(u8 *)p; +} + +static inline void put_unaligned_le8 (u8 val,void *p) +{ + *(u8 *)p = val; +} +#define read_eb_member (eb, ptr, type, member, result) (\ read_extent_buffer(eb, (char *)(result), \ ((unsigned long)(ptr)) + \
@@ -1478,27 +1488,25 @@ static inline void btrfs_set_token_##name(struct btrfs_map_token *token,\ static inline u##bits btrfs_##name(const struct extent_buffer *eb) \ { \ const type *p = page_address(eb->pages[0]); \ - u##bits res = le##bits##_to_cpu(p->member); \ - return res; \ + return get_unaligned_le##bits(&p->member); \ } \ static inline void btrfs_set_##name(const struct extent_buffer *eb, \ u##bits val) \ { \ type *p = page_address(eb->pages[0]); \ - p->member = cpu_to_le##bits(val); \ + put_unaligned_le##bits(val, &p->member); \ }#define BTRFS_SETGET_STACK_FUNCS (name, type, member, bits) \ static inline u##bits btrfs_##name(const type *s) \ { \ - return le##bits##_to_cpu(s->member); \ + return get_unaligned_le##bits(&s->member); \ } \ static inline void btrfs_set_##name(type *s, u##bits val) \ { \ - s->member = cpu_to_le##bits(val); \ + put_unaligned_le##bits(val, &s->member); \ } -static inline u64 btrfs_device_total_bytes (const struct extent_buffer *eb,struct btrfs_dev_item *s) {
fs/btrfs/struct-funcs.c +0 -10
@@ -7,16 +7,6 @@#include "ctree.h" -static inline u8 get_unaligned_le8 (const void *p) -{ -return *(u8 *)p; -} - -static inline void put_unaligned_le8 (u8 val,void *p) -{ - *(u8 *)p = val; -} -static bool check_setget_bounds (const struct extent_buffer *eb,const void *ptr,unsigned off,int size) {
Signature · 1 line
2.25.0