// SPDX-License-Identifier: GPL-2.0-only
#define _GNU_SOURCE
#include <stdio.h>
#include <signal.h>
#include <string.h>
#include <sys/ucontext.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <cpuid.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <stddef.h>
#include <setjmp.h>
#include "helpers.h"
#include "xstate.h"
#ifndef FP_XSTATE_MAGIC2_SIZE
#define FP_XSTATE_MAGIC2_SIZE sizeof(FP_XSTATE_MAGIC2)
#endif
/*
* This test verifies the FPU portability and consistency of the signal frame.
*
* - test_valid_shrunk_xstate_size:
* Verifies that the kernel restores state from a frame with xstate_size
* shrunk to only include active features.
*
* - test_invalid_shrunk_xstate_size:
* Verifies that the kernel rejects a frame if xstate_size is too small for
* the features enabled in xfeatures.
*/
#define SIGFRAME_XSTATE_HDR_OFFSET 512
#define XSTATE_SSE_ONLY_SIZE (SIGFRAME_XSTATE_HDR_OFFSET + XSAVE_HDR_SIZE)
#define XFEATURE_MASK_FPSSE ((1 << XFEATURE_FP) | (1 << XFEATURE_SSE))
static uint32_t ymm_offset;
static uint32_t xstate_size_ymm;
static pid_t self_pid;
/*
* Load %ymm0 from @v, invoke SYS_kill to deliver @sig, and store the
* restored %ymm0 state back into @v within a single inline assembly
* block so the compiler cannot clobber %xmm0/%ymm0 between steps.
*/
__attribute__((target("avx")))
static void raise_with_ymm0(int sig, uint64_t *v)
{
register long rax asm("rax") = SYS_kill;
register long rdi asm("rdi") = self_pid;
register long rsi asm("rsi") = sig;
asm volatile ("vmovdqu %0, %%ymm0\n\t"
"syscall\n\t"
"vmovdqu %%ymm0, %0"
: "+m" (*(char (*)[32])v), "+r" (rax)
: "r" (rdi), "r" (rsi)
: "rcx", "r11", "ymm0", "memory");
}
/*
* Avoid using printf() in signal handlers as it is not
* async-signal-safe.
*/
#define SIGNAL_BUF_LEN 1024
static char sig_err_buf[SIGNAL_BUF_LEN];
static void sig_print(const char *msg)
{
int left = SIGNAL_BUF_LEN - strlen(sig_err_buf) - 1;
strncat(sig_err_buf, msg, left);
}
static void check_avx_support(void)
{
uint32_t eax, ebx, ecx, edx;
struct xstate_info xstate;
/* Check CPUID.01H:ECX.OSXSAVE[bit 27] before calling xgetbv to avoid #UD */
__cpuid(1, eax, ebx, ecx, edx);
if (!(ecx & (1 << 27)))
ksft_exit_skip("OSXSAVE not enabled by OS\n");
/* Check XCR0[2] (YMM) is enabled by OS */
if (!(xgetbv(0) & (1 << XFEATURE_YMM)))
ksft_exit_skip("AVX (YMM) not enabled in XCR0\n");
xstate = get_xstate_info(XFEATURE_YMM);
if (!xstate.size)
ksft_exit_skip("AVX not supported by hardware\n");
ymm_offset = xstate.xbuf_offset;
xstate_size_ymm = xstate.xbuf_offset + xstate.size;
}
#define TEST_YMMH_VAL (0x5656565656565656UL)
static void __handle_shrunk_xstate_size(int sig, siginfo_t *si, void *ucp, bool valid_size)
{
uint64_t xfeatures, *ymmh_p;
struct xsave_buffer *xbuf;
struct _fpx_sw_bytes *sw;
ucontext_t *uc = ucp;
void *fp;
fp = uc->uc_mcontext.fpregs;
if (!fp) {
sig_print("fpregs is NULL\n");
return;
}
sw = get_fpx_sw_bytes(fp);
if (sw->magic1 != FP_XSTATE_MAGIC1) {
sig_print("magic1 is not valid\n");
return;
}
xbuf = (struct xsave_buffer *)fp;
/*
* Both test cases shrink the frame to contain only AVX (FP + SSE + YMM).
* If valid_size is true, set xstate_size to match the enabled features.
* If valid_size is false, set xstate_size too small (SSE only), which
* the kernel must reject.
*/
if (valid_size)
sw->xstate_size = xstate_size_ymm;
else
sw->xstate_size = XSTATE_SSE_ONLY_SIZE;
xfeatures = get_xstatebv(xbuf);
xfeatures &= XFEATURE_MASK_FPSSE | (1 << XFEATURE_YMM);
set_xstatebv(xbuf, xfeatures);
set_fpx_sw_bytes_features(fp, xfeatures);
*(uint32_t *)(fp + sw->xstate_size) = FP_XSTATE_MAGIC2;
if (valid_size) {
ymmh_p = (uint64_t *)(fp + ymm_offset);
ymmh_p[0] = TEST_YMMH_VAL;
ymmh_p[1] = TEST_YMMH_VAL + 1;
}
/* clear everything after MAGIC2. */
if (sw->xstate_size + FP_XSTATE_MAGIC2_SIZE < sw->extended_size)
memset(fp + sw->xstate_size + FP_XSTATE_MAGIC2_SIZE, 0,
sw->extended_size - sw->xstate_size - FP_XSTATE_MAGIC2_SIZE);
}
static void handle_valid_shrunk_xstate_size(int sig, siginfo_t *si, void *ucp)
{
__handle_shrunk_xstate_size(sig, si, ucp, true);
}
static void handle_invalid_shrunk_xstate_size(int sig, siginfo_t *si, void *ucp)
{
__handle_shrunk_xstate_size(sig, si, ucp, false);
}
static void test_valid_shrunk_xstate_size(void)
{
uint64_t v[4];
sig_err_buf[0] = 0;
sethandler(SIGUSR1, handle_valid_shrunk_xstate_size, 0);
v[0] = 0x1111111111111111ULL;
v[1] = 0x2222222222222222ULL;
v[2] = 0x3333333333333333ULL;
v[3] = 0x4444444444444444ULL;
raise_with_ymm0(SIGUSR1, v);
if (sig_err_buf[0])
ksft_test_result_fail("%s\n", sig_err_buf);
else if (v[2] == TEST_YMMH_VAL && v[3] == (TEST_YMMH_VAL + 1))
ksft_test_result_pass("YMM state restored correctly from shrunk frame\n");
else
ksft_test_result_fail(
"Got upper bits: 0x%lx 0x%lx (expected %lx %lx)\n",
v[2], v[3], TEST_YMMH_VAL, TEST_YMMH_VAL + 1);
clearhandler(SIGUSR1);
}
static sigjmp_buf segv_jmpbuf;
static void handle_segv(int sig, siginfo_t *si, void *ucp)
{
siglongjmp(segv_jmpbuf, 1);
}
static void test_invalid_shrunk_xstate_size(void)
{
uint64_t v[4];
sig_err_buf[0] = 0;
sethandler(SIGUSR1, handle_invalid_shrunk_xstate_size, 0);
sethandler(SIGSEGV, handle_segv, 0);
if (sigsetjmp(segv_jmpbuf, 1) == 0) {
v[0] = 0x1111111111111111ULL;
v[1] = 0x2222222222222222ULL;
v[2] = 0x3333333333333333ULL;
v[3] = 0x4444444444444444ULL;
raise_with_ymm0(SIGUSR1, v);
sig_print("Inconsistent size was NOT rejected\n");
}
clearhandler(SIGUSR1);
clearhandler(SIGSEGV);
if (sig_err_buf[0])
ksft_test_result_fail("%s\n", sig_err_buf);
else
ksft_test_result_pass("Inconsistent size correctly rejected\n");
}
int main(void)
{
ksft_print_header();
ksft_set_plan(2);
self_pid = getpid();
check_avx_support();
test_valid_shrunk_xstate_size();
test_invalid_shrunk_xstate_size();
ksft_finished();
return 0;
}