Re: [PATCH] rust: add `CacheAligned` for easy cache line alignment of values

["Gary Guo" <gary@garyguo.net>]

On Tue May 19, 2026 at 9:18 AM BST, Andreas Hindborg wrote:
> "Gary Guo" <gary@garyguo.net> writes:
>
>> On Mon May 18, 2026 at 2:41 PM BST, Andreas Hindborg wrote:
>>> "Gary Guo" <gary@garyguo.net> writes:
>>>
>>>> On Wed Jan 28, 2026 at 2:25 PM GMT, Alexandre Courbot wrote:
>>>>> On Wed Jan 28, 2026 at 11:05 PM JST, Andreas Hindborg wrote:
>>>>>> `CacheAligned` allows to easily align values to a 64 byte boundary.
>>>>>>
>>>>>> An example use case is the kernel `struct spinlock`. This struct is 4 bytes
>>>>>> on x86 when lockdep is not enabled. The structure is not padded to fit a
>>>>>> cache line. The effect of this for `SpinLock` is that the lock variable and
>>>>>> the value protected by the lock might share a cache line, depending on the
>>>>>> alignment requirements of the protected value. Wrapping the value in
>>>>>> `CacheAligned` to get a `SpinLock<CacheAligned<T>>` solves this problem.
>>>>>>
>>>>>> Signed-off-by: Andreas Hindborg <a.hindborg@samsung.com>
>>>>>> ---
>>>>>> Signed-off-by: Andreas Hindborg <a.hindborg@kernel.org>
>>>>>> ---
>>>>>>  rust/kernel/cache_aligned.rs | 59 ++++++++++++++++++++++++++++++++++++++++++++
>>>>>>  rust/kernel/lib.rs           |  2 ++
>>>>>>  2 files changed, 61 insertions(+)
>>>>>>
>>>>>> diff --git a/rust/kernel/cache_aligned.rs b/rust/kernel/cache_aligned.rs
>>>>>> new file mode 100644
>>>>>> index 0000000000000..9c33b8613c077
>>>>>> --- /dev/null
>>>>>> +++ b/rust/kernel/cache_aligned.rs
>>>>>> @@ -0,0 +1,59 @@
>>>>>> +// SPDX-License-Identifier: GPL-2.0
>>>>>> +
>>>>>> +use kernel::try_pin_init;
>>>>>> +use pin_init::{
>>>>>> +    pin_data,
>>>>>> +    pin_init,
>>>>>> +    PinInit, //
>>>>>> +};
>>>>>> +
>>>>>> +/// Wrapper type that alings content to a 64 byte cache line.
>>>>>
>>>>> nit: s/alings/aligns
>>>>>
>>>>>> +#[repr(align(64))]
>>>>>
>>>>> While 64 bytes is the most common cache line size, AFAIK this is not
>>>>> a universal value? Can we expose and use `L1_CACHE_BYTES` here?
>>>>
>>>> Unfortunately `repr(align())` does not accept expression or macro invocations.
>>>> It's still possible with code-generation, but it'll be more tricky.
>>>>
>>>> On all archs that we do support today, I think the value is always 64. However
>>>> it'd worth putting a FIXME or TODO (or assertion, maybe?) in case new archs gets
>>>> addded where this isn't true.
>>>
>>> I was looking into how to implement this properly. Apparently, we don't
>>> have a config item that specifies the L1 cache line size for all
>>> architectures. Each architectures defines the cache line size as C
>>> define in a header. For x86 we have
>>>
>>>   #define L1_CACHE_SHIFT	(CONFIG_X86_L1_CACHE_SHIFT)
>>>
>>> and for arm64
>>>
>>>   #define L1_CACHE_SHIFT		(6)
>>>
>>> and so on.
>>>
>>> One thing we could do is run the C preprocessor on a small snippet to
>>> expand the `L1_CACHE_SHIFT` symbol at some point before invoking
>>> `rustc`. Then we can pass the value to `rustc` via environment variable
>>> when building the `macros` crate. This is similar to how we pass
>>> `RUST_MODFILE` to `rustc`, sans the cpp invocation.
>>>
>>> Otherwise we have to convince all architectures that support Rust to
>>> emit a config that we can rely on, like `CONFIG_L1_CACHE_SHIFT`.
>>>
>>> The latter options is probably the better one, what do you all think?
>>>
>>> Best regards,
>>> Andreas Hindborg
>>
>> You can implement this with generics alone using associative types.
>>
>> mod sealed {
>>     pub trait Sealed {
>>         type Repr;
>>     }
>> }
>>
>> trait Alignment: sealed::Sealed {}
>>
>> #[repr(transparent)]
>> struct Align<const N: usize>([<Self as sealed::Sealed>::Repr; 0])
>> where
>>     Self: Alignment;
>>
>> impl<const N: usize> Align<N>
>> where
>>     Self: Alignment,
>> {
>>     #[inline]
>>     pub fn new() -> Self {
>>         Align([])
>>     }
>> }
>>
>> macro_rules! impl_align {
>>     () => {};
>>     ($a:literal $($rest:literal)*) => {
>>         const _: () = {
>>             #[repr(align($a))]
>>             struct Repr;
>>
>>             impl sealed::Sealed for Align<$a> {
>>                 type Repr = Repr;
>>             }
>>             
>>             impl Alignment for Align<$a> {}
>>         };
>>         
>>         impl_align!($($rest)*);
>>     }
>> }
>>
>> impl_align!(32 64 128 256);
>
> Right, that is great for avoiding code duplication in case we want to
> have `Align<16>`, `Align<32>`, etc.
>
> My discussion was about having just `CacheAligned` and having the
> alignment of that type automatically be the `1 << L1_CACHE_SHIFT`.

#[repr(transparent)]
struct CacheAligned(Align<{ 1 << L1_CACHE_SHIFT }>);

Best,
Gary