| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <c57de5bf-d55c-48c5-9dfa-e2fb844dafe9@csgroup.eu>
Date: Tue, 17 Jun 2025 07:22:57 +0200
From: Christophe Leroy <christophe.leroy@...roup.eu>
To: Ian Rogers <irogers@...gle.com>, Eric Biggers <ebiggers@...gle.com>,
Yuzhuo Jing <yuzhuo@...gle.com>, Andy Lutomirski <luto@...nel.org>,
Thomas Gleixner <tglx@...utronix.de>,
Vincenzo Frascino <vincenzo.frascino@....com>,
Arnaldo Carvalho de Melo <acme@...hat.com>, Al Viro
<viro@...iv.linux.org.uk>, "Jason A. Donenfeld" <Jason@...c4.com>,
linux-kernel@...r.kernel.org, linux-perf-users@...r.kernel.org
Subject: Re: [PATCH v1 1/3] vdso: Switch get/put unaligned from packed struct
to memcpy
Le 17/06/2025 à 02:57, Ian Rogers a écrit :
> 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.
VDSO build fails with this patch:
VDSO32L arch/powerpc/kernel/vdso/vdso32.so.dbg
arch/powerpc/kernel/vdso/vdso32.so.dbg: dynamic relocations are not
supported
make[2]: *** [arch/powerpc/kernel/vdso/Makefile:79:
arch/powerpc/kernel/vdso/vdso32.so.dbg] Error 1
Behind the relocation issue, calling memcpy() for a single 4-bytes word
kills performance.
170: 7f e4 fb 78 mr r4,r31
174: 38 a0 00 04 li r5,4
178: 38 61 00 10 addi r3,r1,16
17c: 93 81 00 10 stw r28,16(r1)
180: 48 00 00 01 bl 180 <__c_kernel_getrandom+0x180>
180: R_PPC_REL24 memcpy
184: 38 81 00 10 addi r4,r1,16
188: 7f a3 eb 78 mr r3,r29
18c: 38 a0 00 04 li r5,4
190: 48 00 00 01 bl 190 <__c_kernel_getrandom+0x190>
190: R_PPC_REL24 memcpy
194: 38 81 00 10 addi r4,r1,16
198: 7f e3 fb 78 mr r3,r31
19c: 38 a0 00 04 li r5,4
1a0: 93 81 00 10 stw r28,16(r1)
1a4: 48 00 00 01 bl 1a4 <__c_kernel_getrandom+0x1a4>
1a4: R_PPC_REL24 memcpy
1a8: 37 de ff ff addic. r30,r30,-1
1ac: 3b bd 00 04 addi r29,r29,4
1b0: 3b ff 00 04 addi r31,r31,4
1b4: 40 82 ff bc bne 170 <__c_kernel_getrandom+0x170>
1b8: 73 09 00 02 andi. r9,r24,2
1bc: 56 b5 00 3a clrrwi r21,r21,2
1c0: 3b 7b 00 04 addi r27,r27,4
1c4: 3b f7 00 04 addi r31,r23,4
1c8: 7f 7b aa 14 add r27,r27,r21
1cc: 7f ff aa 14 add r31,r31,r21
1d0: 57 1e 07 be clrlwi r30,r24,30
1d4: 41 82 00 48 beq 21c <__c_kernel_getrandom+0x21c>
1d8: 7f 64 db 78 mr r4,r27
1dc: 38 a0 00 02 li r5,2
1e0: 7e c3 b3 78 mr r3,r22
1e4: b1 c1 00 10 sth r14,16(r1)
1e8: 48 00 00 01 bl 1e8 <__c_kernel_getrandom+0x1e8>
1e8: R_PPC_REL24 memcpy
1ec: 7e c4 b3 78 mr r4,r22
1f0: 7f e3 fb 78 mr r3,r31
1f4: 38 a0 00 02 li r5,2
1f8: 48 00 00 01 bl 1f8 <__c_kernel_getrandom+0x1f8>
1f8: R_PPC_REL24 memcpy
1fc: 7f 63 db 78 mr r3,r27
200: 7e c4 b3 78 mr r4,r22
204: 38 a0 00 02 li r5,2
208: b1 c1 00 10 sth r14,16(r1)
20c: 57 de 07 fe clrlwi r30,r30,31
210: 48 00 00 01 bl 210 <__c_kernel_getrandom+0x210>
210: R_PPC_REL24 memcpy
214: 3b 7b 00 02 addi r27,r27,2
218: 3b ff 00 02 addi r31,r31,2
21c: 2c 1e 00 00 cmpwi r30,0
220: 41 82 00 3c beq 25c <__c_kernel_getrandom+0x25c>
Christophe
>
> Signed-off-by: Ian Rogers <irogers@...gle.com>
> ---
> include/vdso/unaligned.h | 48 +++++++++++++++++++++++++++++++++++-----
> 1 file changed, 42 insertions(+), 6 deletions(-)
>
> diff --git a/include/vdso/unaligned.h b/include/vdso/unaligned.h
> index ff0c06b6513e..81f632e3c5eb 100644
> --- a/include/vdso/unaligned.h
> +++ b/include/vdso/unaligned.h
> @@ -2,14 +2,50 @@
> #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/string.h> // For memcpy.
> +
> +#define ____get_unaligned_type(type) type: (type)0
> +/**
> + * __get_unaligned_t - read an unaligned value from memory.
> + * @ptr: the pointer to load from.
> + * @type: the type to load from the pointer.
> + *
> + * 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 _Generic to map to a non-const type
> + * - you can't memcpy into a const type. The void* cast silences ubsan warnings.
> + */
> +#define __get_unaligned_t(type, ptr) ({ \
> + type __get_unaligned_map_ctrl = 0; \
> + typeof(_Generic(__get_unaligned_map_ctrl, \
> + ____get_unaligned_type(short int), \
> + ____get_unaligned_type(unsigned short int), \
> + ____get_unaligned_type(int), \
> + ____get_unaligned_type(unsigned int), \
> + ____get_unaligned_type(long), \
> + ____get_unaligned_type(unsigned long), \
> + ____get_unaligned_type(long long), \
> + ____get_unaligned_type(unsigned long long), \
> + default: (type)0 \
> + )) __get_unaligned_val; \
> + (void)__get_unaligned_map_ctrl; \
> + 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); \
> + memcpy((void *)(ptr), &__put_unaligned_val, sizeof(__put_unaligned_val)); \
> } while (0)
>
> #endif /* __VDSO_UNALIGNED_H */
Powered by blists - more mailing lists