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.

Signed-off-by: Ian Rogers <irogers@google.com>
Signed-off-by: Thomas Gleixner <tglx@kernel.org>
Link: https://patch.msgid.link/20251016205126.2882625-4-irogers@google.com

diff --git a/tools/include/linux/compiler_types.h b/tools/include/linux/compiler_types.h
index d09f9dc172a486875e2e62cf8550a69f24c9beed..890982283a5ee123c3a4e86c22e032282372e60e 100644 (file)
--- a/tools/include/linux/compiler_types.h
+++ b/tools/include/linux/compiler_types.h
@@ -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 */

diff --git a/tools/include/vdso/unaligned.h b/tools/include/vdso/unaligned.h
index ff0c06b6513eff61046f9fcf40111c9a8baf176b..9076483c9fbbd0a9d0735683b82b3bdf91ad5fb5 100644 (file)
--- a/tools/include/vdso/unaligned.h
+++ b/tools/include/vdso/unaligned.h
@@ -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 */