[PATCH v2] smp: align struct __call_single_node to 8 bytes

[PATCH v2] smp: align struct __call_single_node to 8 bytes

[Brian Cain]

Consumers walking call_single_queue cast each node to call_single_data_t
and, given that type's declared over-alignment, the compiler may load
llist.next and u_flags as one naturally aligned double word.  Fields using
this type, such as task_struct::wake_entry only guarantee pointer alignment,
which faults on strict-alignment 32-bit architectures like hexagon.

Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Paul E. McKenney <paulmck@kernel.org>
Cc: Frederic Weisbecker <frederic@kernel.org>
Cc: linux-hexagon@vger.kernel.org
Reviewed-by: Philippe Mathieu-Daudé <philmd@oss.qualcomm.com>
Signed-off-by: Brian Cain <brian.cain@oss.qualcomm.com>
---
 include/linux/smp_types.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/linux/smp_types.h b/include/linux/smp_types.h
index 2e8461af8df6..5773e1fb2660 100644
--- a/include/linux/smp_types.h
+++ b/include/linux/smp_types.h
@@ -64,6 +64,6 @@ struct __call_single_node {
 #ifdef CONFIG_64BIT
 	u16 src, dst;
 #endif
-};
+} __aligned(8);
 
 #endif /* __LINUX_SMP_TYPES_H */
-- 
2.34.1

Re: [PATCH v2] smp: align struct __call_single_node to 8 bytes

[David Laight]

On Wed, 23 Sep 2026 08:43:07 -0700
Brian Cain <brian.cain@oss.qualcomm.com> wrote:

> Consumers walking call_single_queue cast each node to call_single_data_t
> and, given that type's declared over-alignment, the compiler may load
> llist.next and u_flags as one naturally aligned double word.  Fields using
> this type, such as task_struct::wake_entry only guarantee pointer alignment,
> which faults on strict-alignment 32-bit architectures like hexagon.

I think the same could happen on arm64.
The compiler is being told the alignment is 4*sizeof(long)), but I doubt it
can ever matter that it is more than 2*sizeof(long).

The other option is to only ever use call_single_data_t to get an aligned
version of the structure and use the struct everywhere else.
The compiler won't be able to use the 'load two register' instruction, but
I doubt that will be measurable.

David

> 
> Cc: Peter Zijlstra <peterz@infradead.org>
> Cc: Ingo Molnar <mingo@kernel.org>
> Cc: Paul E. McKenney <paulmck@kernel.org>
> Cc: Frederic Weisbecker <frederic@kernel.org>
> Cc: linux-hexagon@vger.kernel.org
> Reviewed-by: Philippe Mathieu-Daudé <philmd@oss.qualcomm.com>
> Signed-off-by: Brian Cain <brian.cain@oss.qualcomm.com>
> ---
>  include/linux/smp_types.h | 2 +-
>  1 file changed, 1 insertion(+), 1 deletion(-)
> 
> diff --git a/include/linux/smp_types.h b/include/linux/smp_types.h
> index 2e8461af8df6..5773e1fb2660 100644
> --- a/include/linux/smp_types.h
> +++ b/include/linux/smp_types.h
> @@ -64,6 +64,6 @@ struct __call_single_node {
>  #ifdef CONFIG_64BIT
>  	u16 src, dst;
>  #endif
> -};
> +} __aligned(8);
>  
>  #endif /* __LINUX_SMP_TYPES_H */

Re: [PATCH v2] smp: align struct __call_single_node to 8 bytes

[Peter Zijlstra]

On Wed, Sep 23, 2026 at 08:43:07AM -0700, Brian Cain wrote:
> Consumers walking call_single_queue cast each node to call_single_data_t
> and, given that type's declared over-alignment, the compiler may load
> llist.next and u_flags as one naturally aligned double word.  Fields using
> this type, such as task_struct::wake_entry only guarantee pointer alignment,
> which faults on strict-alignment 32-bit architectures like hexagon.

Where exactly does this happen? I'm failing with grep.

Re: [PATCH v2] smp: align struct __call_single_node to 8 bytes

[David Laight]

On Thu, 24 Sep 2026 11:34:50 +0200
Peter Zijlstra <peterz@infradead.org> wrote:

> On Wed, Sep 23, 2026 at 08:43:07AM -0700, Brian Cain wrote:
> > Consumers walking call_single_queue cast each node to call_single_data_t
> > and, given that type's declared over-alignment, the compiler may load
> > llist.next and u_flags as one naturally aligned double word.  Fields using
> > this type, such as task_struct::wake_entry only guarantee pointer alignment,
> > which faults on strict-alignment 32-bit architectures like hexagon.  
> 
> Where exactly does this happen? I'm failing with grep.
> 

Here for one:

void __smp_call_single_queue(int cpu, struct llist_node *node)
{
	/*
	 * We have to check the type of the CSD before queueing it, because
	 * once queued it can have its flags cleared by
	 *   flush_smp_call_function_queue()
	 * even if we haven't sent the smp_call IPI yet (e.g. the stopper
	 * executes migration_cpu_stop() on the remote CPU).
	 */
	if (trace_csd_queue_cpu_enabled()) {
		call_single_data_t *csd;
		smp_call_func_t func;

		csd = container_of(node, call_single_data_t, node.llist);
		func = CSD_TYPE(csd) == CSD_TYPE_TTWU ?
			sched_ttwu_pending : csd->func;

		trace_call__csd_queue_cpu(cpu, _RET_IP_, func, csd);
	}

since the data item itself was probably created with:

#define CSD_INIT(_func, _info) \
	(struct __call_single_data){ .func = (_func), .info = (_info), }

I've not looked hard enough to see what the extra alignment was trying
to achieve.
But the above function needs to use the 'less aligned' struct __call_single_data
even if some places use call_single_data_t to get a 'more aligned' structure.

David