Switch get/put unaligned to use memcpy
v4 cover Switch get/put unaligned to use memcpy
The existing type punning approach with packed structs requires
-fno-strict-aliasing to be passed to the compiler for
correctness. This is true in the kernel tree but not in the tools directory resulting in this suggested patch from Eric Biggers
<[email protected]>:
https://lore.kernel.org/lkml/[email protected]/
Requiring -fno-strict-aliasing seems unfortunate and so this patch makes the unaligned code work via memcpy for type punning rather than the packed attribute.
v4: switch the type/expression variable __get_unaligned_ctrl_type that
is used by _Generic to be a pointer to avoid 0 vs NULL usage warnings - always use NULL and dereference the type. This should also hopefully address analysis bots complaints.
v3: switch to __unqual_scalar_typeof, reducing the code, and use an
uninitialized variable rather than a cast of 0 to try to avoid a sparse warning about not using NULL. The code is trying to navigate a minefield of uninitialized and casting warnings, hopefully the best balance has been struck, but the code will fail for cases like:
const void *val = get_unaligned((const void * const *)ptr); due to __unqual_scalar_typeof leaving the 2nd const of the cast in place. Thankfully no code does this - tested with an allyesconfig. Support would be achievable by using void* as a default case in __unqual_scalar_typeof, it just doesn't seem worth it for a fairly unusual const case.
v2: switch memcpy to __builtin_memcpy to avoid potential/disallowed
memcpy calls in vdso caused by -fno-builtin. Reported by Christophe Leroy <[email protected]>:
https://lore.kernel.org/lkml/[email protected]/
Ian Rogers (3):
vdso: Switch get/put unaligned from packed struct to memcpy tools headers: Update the linux/unaligned.h copy with the kernel
sources
tools headers: Remove unneeded ignoring of warnings in unaligned.h
include/vdso/unaligned.h | 41 ++++++++++++++++++++++++---- tools/include/linux/compiler_types.h | 22 +++++++++++++++ tools/include/linux/unaligned.h | 4 --- tools/include/vdso/unaligned.h | 41 ++++++++++++++++++++++++---- 4 files changed, 92 insertions(+), 16 deletions(-)
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
PATCH v4 1/3 vdso: Switch get/put unaligned from packed struct to memcpy
Type punning is necessary for get/put unaligned but the use of a packed struct violates strict aliasing rules, requiring -fno-strict-aliasing to be passed to the C compiler. Switch to using memcpy so that -fno-strict-aliasing isn't necessary.
--- include/vdso/unaligned.h | 41 ++++++++++++++++++++++++++++++++++------ 1 file changed, 35 insertions(+), 6 deletions(-)
include/vdso/unaligned.h +35 -6
@@ -2,14 +2,43 @@#ifndef __VDSO_UNALIGNED_H#define __VDSO_UNALIGNED_H -#define __get_unaligned_t (type, ptr) ({ \ - const struct { type x; } __packed * __get_pptr = (typeof(__get_pptr))(ptr); \ - __get_pptr->x; \ +#include <linux/compiler_types.h> + +/** +* __get_unaligned_t - read an unaligned value from memory. +* @type: the type to load from the pointer. +* @ptr: the pointer to load from. +* +* Use memcpy to affect an unaligned type sized load avoiding undefined behavior +* from approaches like type punning that require -fno-strict-aliasing in order +* to be correct. As type may be const, use __unqual_scalar_typeof to map to a +* non-const type - you can't memcpy into a const type. The +* __get_unaligned_ctrl_type gives __unqual_scalar_typeof its required +* expression rather than type, a pointer is used to avoid warnings about mixing +* the use of 0 and NULL. The void* cast silences ubsan warnings. +*/ +#define __get_unaligned_t (type, ptr) ({ \ + type *__get_unaligned_ctrl_type __always_unused = NULL; \ + __unqual_scalar_typeof(*__get_unaligned_ctrl_type) __get_unaligned_val; \ + __builtin_memcpy(&__get_unaligned_val, (void *)(ptr), \ + sizeof(__get_unaligned_val)); \ + __get_unaligned_val; \ }) -#define __put_unaligned_t (type, val, ptr) do { \ - struct { type x; } __packed * __put_pptr = (typeof(__put_pptr))(ptr); \ - __put_pptr->x = (val); \ +/** +* __put_unaligned_t - write an unaligned value to memory. +* @type: the type of the value to store. +* @val: the value to store. +* @ptr: the pointer to store to. +* +* Use memcpy to affect an unaligned type sized store avoiding undefined +* behavior from approaches like type punning that require -fno-strict-aliasing +* in order to be correct. The void* cast silences ubsan warnings. +*/ +#define __put_unaligned_t (type, val, ptr) do { \ + type __put_unaligned_val = (val); \ + __builtin_memcpy((void *)(ptr), &__put_unaligned_val, \ + sizeof(__put_unaligned_val)); \ } while (0)#endif /* __VDSO_UNALIGNED_H */
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
[tip: timers/vdso] vdso: Switch get/put_unaligned() from packed struct to memcpy()
The following commit has been merged into the timers/vdso branch of tip:
The following commit has been merged into the timers/vdso branch of tip:
Commit-ID: 34a1cbf21227f1327ead30dcf2a52aac79bf4f15 Gitweb: https://git.kernel.org/tip/34a1cbf21227f1327ead30dcf2a52aac79bf4f15 Author: Ian Rogers <[email protected]> AuthorDate: Tue, 22 Jul 2025 14:57:52 -07:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 04 Sep 2025 11:43:03 +02:00
vdso: Switch get/put_unaligned() from packed struct to memcpy()
Type punning is necessary for get/put_unaligned() but the use of a packed struct violates strict aliasing rules, requiring -fno-strict-aliasing to be passed to the C compiler.
Switch to using memcpy() so that -fno-strict-aliasing isn't necessary.
--- include/vdso/unaligned.h | 41 +++++++++++++++++++++++++++++++++------ 1 file changed, 35 insertions(+), 6 deletions(-)
include/vdso/unaligned.h +35 -6
@@ -2,14 +2,43 @@#ifndef __VDSO_UNALIGNED_H#define __VDSO_UNALIGNED_H -#define __get_unaligned_t (type, ptr) ({ \ - const struct { type x; } __packed * __get_pptr = (typeof(__get_pptr))(ptr); \ - __get_pptr->x; \ +#include <linux/compiler_types.h> + +/** +* __get_unaligned_t - read an unaligned value from memory. +* @type: the type to load from the pointer. +* @ptr: the pointer to load from. +* +* Use memcpy to affect an unaligned type sized load avoiding undefined behavior +* from approaches like type punning that require -fno-strict-aliasing in order +* to be correct. As type may be const, use __unqual_scalar_typeof to map to a +* non-const type - you can't memcpy into a const type. The +* __get_unaligned_ctrl_type gives __unqual_scalar_typeof its required +* expression rather than type, a pointer is used to avoid warnings about mixing +* the use of 0 and NULL. The void* cast silences ubsan warnings. +*/ +#define __get_unaligned_t (type, ptr) ({ \ + type *__get_unaligned_ctrl_type __always_unused = NULL; \ + __unqual_scalar_typeof(*__get_unaligned_ctrl_type) __get_unaligned_val; \ + __builtin_memcpy(&__get_unaligned_val, (void *)(ptr), \ + sizeof(__get_unaligned_val)); \ + __get_unaligned_val; \ }) -#define __put_unaligned_t (type, val, ptr) do { \ - struct { type x; } __packed * __put_pptr = (typeof(__put_pptr))(ptr); \ - __put_pptr->x = (val); \ +/** +* __put_unaligned_t - write an unaligned value to memory. +* @type: the type of the value to store. +* @val: the value to store. +* @ptr: the pointer to store to. +* +* Use memcpy to affect an unaligned type sized store avoiding undefined +* behavior from approaches like type punning that require -fno-strict-aliasing +* in order to be correct. The void* cast silences ubsan warnings. +*/ +#define __put_unaligned_t (type, val, ptr) do { \ + type __put_unaligned_val = (val); \ + __builtin_memcpy((void *)(ptr), &__put_unaligned_val, \ + sizeof(__put_unaligned_val)); \ } while (0)#endif /* __VDSO_UNALIGNED_H */
PATCH v4 2/3 tools headers: Update the linux/unaligned.h copy with the kernel sources
In reply to Ian RogersTo pick up the changes in:
e5f39a57c4c5 vdso: Switch get/put unaligned from packed struct to memcpy
As the code is dependent on __unqual_scalar_typeof, update the tools version of compiler_types.h to include this.
--- tools/include/linux/compiler_types.h | 22 +++++++++++++++ tools/include/vdso/unaligned.h | 41 ++++++++++++++++++++++++---- 2 files changed, 57 insertions(+), 6 deletions(-)
tools/include/linux/compiler_types.h +22 -0
@@ -40,4 +40,26 @@ #define asm_goto_output(x...) asm goto(x)#endif +/* +* __unqual_scalar_typeof(x) - Declare an unqualified scalar type, leaving +* non-scalar types unchanged. +*/ +/* +* Prefer C11 _Generic for better compile-times and simpler code. Note: 'char' +* is not type-compatible with 'signed char', and we define a separate case. +*/ +#define __scalar_type_to_expr_cases (type) \ + unsigned type: (unsigned type)0, \ + signed type: (signed type)0 + +#define __unqual_scalar_typeof (x) typeof( \ + _Generic((x), \ + char: (char)0, \ + __scalar_type_to_expr_cases(char), \ + __scalar_type_to_expr_cases(short), \ + __scalar_type_to_expr_cases(int), \ + __scalar_type_to_expr_cases(long), \ + __scalar_type_to_expr_cases(long long), \ + default: (x))) +#endif /* __LINUX_COMPILER_TYPES_H */
tools/include/vdso/unaligned.h +35 -6
49 lines not on this page · raw message
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
[tip: timers/vdso] tools headers: Update the linux/unaligned.h copy with the kernel sources
The following commit has been merged into the timers/vdso branch of tip:
The following commit has been merged into the timers/vdso branch of tip:
Commit-ID: 15f25184464199470bc355ea85f3813fa6156cac Gitweb: https://git.kernel.org/tip/15f25184464199470bc355ea85f3813fa6156cac Author: Ian Rogers <[email protected]> AuthorDate: Tue, 22 Jul 2025 14:57:53 -07:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 04 Sep 2025 11:43:03 +02:00
tools headers: Update the linux/unaligned.h copy with the kernel sources
To pick up the changes in:
vdso: Switch get/put_unaligned() from packed struct to memcpy()
As the code is dependent on __unqual_scalar_typeof(), update also the tools version of compiler_types.h to include this.
--- tools/include/linux/compiler_types.h | 22 ++++++++++++++- tools/include/vdso/unaligned.h | 41 +++++++++++++++++++++++---- 2 files changed, 57 insertions(+), 6 deletions(-)
tools/include/linux/compiler_types.h +22 -0
@@ -40,4 +40,26 @@ #define asm_goto_output(x...) asm goto(x)#endif +/* +* __unqual_scalar_typeof(x) - Declare an unqualified scalar type, leaving +* non-scalar types unchanged. +*/ +/* +* Prefer C11 _Generic for better compile-times and simpler code. Note: 'char' +* is not type-compatible with 'signed char', and we define a separate case. +*/ +#define __scalar_type_to_expr_cases (type) \ + unsigned type: (unsigned type)0, \ + signed type: (signed type)0 + +#define __unqual_scalar_typeof (x) typeof( \ + _Generic((x), \ + char: (char)0, \ + __scalar_type_to_expr_cases(char), \ + __scalar_type_to_expr_cases(short), \ + __scalar_type_to_expr_cases(int), \ + __scalar_type_to_expr_cases(long), \ + __scalar_type_to_expr_cases(long long), \ + default: (x))) +#endif /* __LINUX_COMPILER_TYPES_H */
tools/include/vdso/unaligned.h +35 -6
49 lines not on this page · raw message
PATCH v4 3/3 tools headers: Remove unneeded ignoring of warnings in unaligned.h
In reply to Ian RogersNow the get/put unaligned use memcpy the -Wpacked and -Wattributes warnings don't need disabling.
--- tools/include/linux/unaligned.h | 4 ---- 1 file changed, 4 deletions(-)
tools/include/linux/unaligned.h +0 -4
@@ -6,9 +6,6 @@* This is the most generic implementation of unaligned accesses * and should work almost anywhere. */ -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wpacked" -#pragma GCC diagnostic ignored "-Wattributes"#include <vdso/unaligned.h> #define get_unaligned (ptr) __get_unaligned_t(typeof(*(ptr)), (ptr))
@@ -143,6 +140,5 @@ static inline u64 get_unaligned_be48(const void *p) {return __get_unaligned_be48 (p); } -#pragma GCC diagnostic pop#endif /* __LINUX_UNALIGNED_H */
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
[tip: timers/vdso] tools headers: Remove unneeded ignoring of warnings in unaligned.h
The following commit has been merged into the timers/vdso branch of tip:
The following commit has been merged into the timers/vdso branch of tip:
Commit-ID: 00b04d1a95f3d33d7269eb2a0d07b2850c473fb5 Gitweb: https://git.kernel.org/tip/00b04d1a95f3d33d7269eb2a0d07b2850c473fb5 Author: Ian Rogers <[email protected]> AuthorDate: Tue, 22 Jul 2025 14:57:54 -07:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Thu, 04 Sep 2025 11:43:03 +02:00
tools headers: Remove unneeded ignoring of warnings in unaligned.h
Now that get/put_unaligned() use memcpy() the -Wpacked and -Wattributes warnings don't need disabling anymore.
--- tools/include/linux/unaligned.h | 4 ---- 1 file changed, 4 deletions(-)
tools/include/linux/unaligned.h +0 -4
@@ -6,9 +6,6 @@* This is the most generic implementation of unaligned accesses * and should work almost anywhere. */ -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wpacked" -#pragma GCC diagnostic ignored "-Wattributes"#include <vdso/unaligned.h> #define get_unaligned (ptr) __get_unaligned_t(typeof(*(ptr)), (ptr))
@@ -143,6 +140,5 @@ static inline u64 get_unaligned_be48(const void *p) {return __get_unaligned_be48 (p); } -#pragma GCC diagnostic pop#endif /* __LINUX_UNALIGNED_H */