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

bpf, arm64: Force 8-byte alignment for JIT buffer to prevent atomic tearing

struct bpf_plt contains a u64 target field. Currently, the BPF JIT
allocator requests an alignment of 4 bytes (sizeof(u32)) for the JIT
buffer.

Because the base address of the JIT buffer can be 4-byte aligned (e.g.,
ending in 0x4 or 0xc), the relative padding logic in build_plt() fails
to ensure that target lands on an 8-byte boundary.

This leads to two issues:
1. UBSAN reports misaligned-access warnings when dereferencing the
structure.
2. More critically, target is updated concurrently via WRITE_ONCE() in
bpf_arch_text_poke() while the JIT'd code executes ldr. On arm64,
64-bit loads/stores are only guaranteed to be single-copy atomic if
they are 64-bit aligned. A misaligned target risks a torn read,
causing the JIT to jump to a corrupted address.

Fix this by increasing the allocation alignment requirement to 8 bytes
(sizeof(u64)) in bpf_jit_binary_pack_alloc(). This anchors the base of
the JIT buffer to an 8-byte boundary, allowing the relative padding math
in build_plt() to correctly align the target field.

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

bpf, arm64: Forzar alineación de 8 bytes para el búfer JIT para prevenir el desgarro atómico

struct bpf_plt contiene un campo objetivo u64. Actualmente, el asignador JIT de BPF solicita una alineación de 4 bytes (sizeof(u32)) para el búfer JIT.

Debido a que la dirección base del búfer JIT puede estar alineada a 4 bytes (p. ej., terminando en 0x4 o 0xc), la lógica de relleno relativo en build_plt() no logra asegurar que target caiga en un límite de 8 bytes.

Esto lleva a dos problemas:
1. UBSAN informa advertencias de acceso desalineado al desreferenciar la estructura.
2. Más críticamente, target se actualiza concurrentemente a través de WRITE_ONCE() en bpf_arch_text_poke() mientras el código JIT'd ejecuta ldr. En arm64, las cargas/almacenamientos de 64 bits solo se garantiza que sean atómicos de copia única si están alineados a 64 bits. Un target desalineado arriesga una lectura desgarrada, haciendo que el JIT salte a una dirección corrupta.

Solucione esto aumentando el requisito de alineación de asignación a 8 bytes (sizeof(u64)) en bpf_jit_binary_pack_alloc(). Esto ancla la base del búfer JIT a un límite de 8 bytes, permitiendo que las matemáticas de relleno relativo en build_plt() alineen correctamente el campo target.