In the Linux kernel, the following vulnerability has been resolved:

net: ipv4: fix ARM64 alignment fault in multipath hash seed

`struct sysctl_fib_multipath_hash_seed` contains two u32 fields
(user_seed and mp_seed), making it an 8-byte structure with a 4-byte
alignment requirement.

In `fib_multipath_hash_from_keys()`, the code evaluates the entire
struct atomically via `READ_ONCE()`:

mp_seed = READ_ONCE(net->ipv4.sysctl_fib_multipath_hash_seed).mp_seed;

While this silently works on GCC by falling back to unaligned regular
loads which the ARM64 kernel tolerates, it causes a fatal kernel panic
when compiled with Clang and LTO enabled.

Commit e35123d83ee3 ("arm64: lto: Strengthen READ_ONCE() to acquire
when CONFIG_LTO=y") strengthens `READ_ONCE()` to use Load-Acquire
instructions (`ldar` / `ldapr`) to prevent compiler reordering bugs
under Clang LTO. Since the macro evaluates the full 8-byte struct,
Clang emits a 64-bit `ldar` instruction. ARM64 architecture strictly
requires `ldar` to be naturally aligned, thus executing it on a 4-byte
aligned address triggers a strict Alignment Fault (FSC = 0x21).

Fix the read side by moving the `READ_ONCE()` directly to the `u32`
member, which emits a safe 32-bit `ldar Wn`.

Furthermore, Eric Dumazet pointed out that `WRITE_ONCE()` on the entire
struct in `proc_fib_multipath_hash_set_seed()` is also flawed. Analysis
shows that Clang splits this 8-byte write into two separate 32-bit
`str` instructions. While this avoids an alignment fault, it destroys
atomicity and exposes a tear-write vulnerability. Fix this by
explicitly splitting the write into two 32-bit `WRITE_ONCE()`
operations.

Finally, add the missing `READ_ONCE()` when reading `user_seed` in
`proc_fib_multipath_hash_seed()` to ensure proper pairing and
concurrency safety.

En el kernel de Linux, la siguiente vulnerabilidad ha sido resuelta:

net: ipv4: solucionar fallo de alineación ARM64 en la semilla de hash multipath

'struct sysctl_fib_multipath_hash_seed' contiene dos campos u32 (user_seed y mp_seed), convirtiéndola en una estructura de 8 bytes con un requisito de alineación de 4 bytes.

En 'fib_multipath_hash_from_keys()', el código evalúa la estructura completa atómicamente a través de 'READ_ONCE()':

mp_seed = 'READ_ONCE'(net->ipv4.sysctl_fib_multipath_hash_seed).mp_seed;

Aunque esto funciona silenciosamente en GCC al recurrir a cargas regulares no alineadas que el kernel ARM64 tolera, causa un pánico fatal del kernel cuando se compila con Clang y LTO habilitado.

El commit e35123d83ee3 ('arm64: lto: Strengthen 'READ_ONCE()' to acquire when CONFIG_LTO=y') refuerza 'READ_ONCE()' para usar instrucciones Load-Acquire ('ldar' / 'ldapr') para prevenir errores de reordenamiento del compilador bajo Clang LTO. Dado que la macro evalúa la estructura completa de 8 bytes, Clang emite una instrucción 'ldar' de 64 bits. La arquitectura ARM64 requiere estrictamente que 'ldar' esté naturalmente alineado, por lo tanto, ejecutarlo en una dirección alineada a 4 bytes desencadena un fallo de alineación estricto (FSC = 0x21).

Solucionar el lado de lectura moviendo 'READ_ONCE()' directamente al miembro 'u32', lo que emite un 'ldar Wn' seguro de 32 bits.

Además, Eric Dumazet señaló que 'WRITE_ONCE()' en la estructura completa en 'proc_fib_multipath_hash_set_seed()' también es defectuoso. El análisis muestra que Clang divide esta escritura de 8 bytes en dos instrucciones 'str' separadas de 32 bits. Aunque esto evita un fallo de alineación, destruye la atomicidad y expone una vulnerabilidad de escritura fragmentada. Solucionar esto dividiendo explícitamente la escritura en dos operaciones 'WRITE_ONCE()' de 32 bits.

Finalmente, añadir el 'READ_ONCE()' faltante al leer 'user_seed' en 'proc_fib_multipath_hash_seed()' para asegurar un emparejamiento adecuado y seguridad de concurrencia.