tests/xsave/spawn_fpu.c

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2026 Oxide Computer Company
 */

/*
 * Verify that a process born via posix_spawn(3C) comes to life with a correctly
 * initialised FPU.
 *
 * Unlike a fork(2) child, a spawned process is created as a bare kernel thread
 * that never passes through forklwp()/fp_new_lwp(), so it inherits neither FPU
 * register state nor the FPU thread context operations from its parent. Both
 * are instead established from scratch by fp_exec() when the child execs its
 * target, which is the same path the kernel uses to bring up init. This test
 * confirms, from inside a spawned child, that:
 *
 *   o the initial x87 control word and MXCSR are the architectural defaults,
 *     proving fp_exec()/fpinit() ran for the spawned LWP;
 *   o the full vector register file survives context switches while sibling
 *     threads hammer the FPU, making it very likely that the context
 *     operations were installed and actually save and restore our state.
 *
 * A fork(2)+exec(2) child is run through the identical checks first as a
 * control. The test needs xsave + AVX (it reuses the xsave test support
 * library) and is gated on that hardware by xsu_hwtype in the runfile.
 */

#include <err.h>
#include <errno.h>
#include <ieeefp.h>
#include <spawn.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <thread.h>
#include <ucontext.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/fp.h>
#include <sys/processor.h>
#include <sys/procset.h>
#include <sys/time.h>
#include <sys/wait.h>

#include "xsave_util.h"

extern char **environ;

/*
 * How long to spend repeatedly reloading and verifying the vector register
 * file while the sibling threads create FPU contention.
 */
#define	SPAWN_FPU_RUNTIME_MS	500

/*
 * Number of FPU-hammering sibling threads to share the bound CPU with the
 * thread under test. Pinning a handful to a single CPU gives reasonably
 * reliable contention.
 */
#define	SPAWN_FPU_NRUNNERS	4

static uint_t failures;

typedef struct {
	uint32_t	fra_hwsup;
	processorid_t	fra_cpu;
} fpu_runner_arg_t;

/*
 * Continually load the vector registers with a distinct pattern. Run by the
 * sibling threads purely to dirty the physical registers so that, on a kernel
 * that failed to install the spawned thread's FPU context operations, a context
 * switch would leak this state into the thread under test.
 */
static void *
fpu_runner(void *arg)
{
	const fpu_runner_arg_t *ra = arg;
	uint32_t seed = 0x80000000;
	xsu_fpu_t buf;

	if (ra->fra_cpu != -1)
		(void) processor_bind(P_LWPID, P_MYID, ra->fra_cpu, NULL);

	for (;;) {
		xsu_fill(&buf, ra->fra_hwsup, seed);
		xsu_setfpu(&buf, ra->fra_hwsup);
		seed += 0x1000;
	}

	/* NOTREACHED */
	return (NULL);
}

static processorid_t
bind_to_cpu(void)
{
	long maxcpu = sysconf(_SC_CPUID_MAX);

	for (processorid_t cpu = 0; cpu <= maxcpu; cpu++) {
		if (processor_bind(P_LWPID, P_MYID, cpu, NULL) == 0)
			return (cpu);
	}

	return (-1);
}

/*
 * Snapshot the calling thread's initial FPU control word and MXCSR.
 * getcontext() forces an FPU save, after which we read them from the saved
 * state. Keeping this in its own function means getcontext(), which the
 * compiler treats like setjmp(), does not force the caller's locals volatile.
 */
static void
read_initial_fpu(uint32_t *cwp, uint32_t *mxcsrp)
{
	ucontext_t uc;

	if (getcontext(&uc) != 0)
		err(EXIT_FAILURE, "getcontext failed");

	/*
	 * The x87 control word is a named field on amd64. On i386 the
	 * fpchip_state is the opaque legacy save area, so we overlay the ILP32
	 * struct _fpstate to read it, as xsave_util.c does.
	 */
#ifdef __amd64
	*cwp = uc.uc_mcontext.fpregs.fp_reg_set.fpchip_state.cw & 0xffff;
#else
	struct _fpstate fps;

	(void) memcpy(&fps, &uc.uc_mcontext.fpregs.fp_reg_set.fpchip_state,
	    sizeof (fps));
	*cwp = fps.cw & 0xffff;
#endif
	*mxcsrp = uc.uc_mcontext.fpregs.fp_reg_set.fpchip_state.mxcsr;
}

static int
fpu_child(void)
{
	static fpu_runner_arg_t ra;
	uint32_t hwsup, cw, mxcsr;
	uint32_t seed = 1;
	long ncpu;
	uint_t nrun;
	hrtime_t end;
	int ret = EXIT_SUCCESS;

	read_initial_fpu(&cw, &mxcsr);

	hwsup = xsu_hwsupport();

	if (cw != FPU_CW_INIT) {
		warnx("initial x87 control word is %#x, expected %#x", cw,
		    FPU_CW_INIT);
		ret = EXIT_FAILURE;
	}
	if (mxcsr != SSE_MXCSR_INIT) {
		warnx("initial MXCSR is %#x, expected %#x", mxcsr,
		    SSE_MXCSR_INIT);
		ret = EXIT_FAILURE;
	}

	/*
	 * Force the thread under test to share a CPU with FPU-hammering
	 * siblings.
	 */
	ra.fra_hwsup = hwsup;
	ra.fra_cpu = bind_to_cpu();
	if (ra.fra_cpu != -1) {
		nrun = SPAWN_FPU_NRUNNERS;
	} else {
		ncpu = sysconf(_SC_NPROCESSORS_ONLN);
		if (ncpu < 1)
			ncpu = 1;
		nrun = 2 * (uint_t)ncpu;
	}

	for (uint_t i = 0; i < nrun; i++) {
		thread_t tid;
		int e = thr_create(NULL, 0, fpu_runner, &ra, THR_DETACHED,
		    &tid);
		if (e != 0)
			errc(EXIT_FAILURE, e, "failed to create FPU runner");
	}

	/*
	 * Load a known pattern and read it straight back. There is no
	 * FPU-clobbering call between the two so the pattern should
	 * survive even if we are preempted in the window.
	 */
	end = gethrtime() + (hrtime_t)SPAWN_FPU_RUNTIME_MS *
	    (NANOSEC / MILLISEC);
	do {
		xsu_fpu_t set, got;

		xsu_fill(&set, hwsup, seed);
		xsu_setfpu(&set, hwsup);

		/*
		 * Widen the window in which our vector state has to survive a
		 * context switch. This spin only touches integer registers, so
		 * it cannot disturb the FPU state we just loaded.
		 */
		for (volatile uint_t d = 0; d < 10000; d++)
			continue;

		xsu_getfpu(&got, hwsup);
		if (!xsu_same(&set, &got, hwsup)) {
			warnx("vector register state was not preserved across "
			    "a context switch (seed %#x)", seed);
			ret = EXIT_FAILURE;
			break;
		}
		seed += 0x40;
	} while (gethrtime() < end);

	return (ret);
}

static void
run_child(const char *desc, bool use_spawn, const char *path)
{
	char *argv[] = { (char *)path, "child", NULL };
	pid_t pid;
	int status;

	if (use_spawn) {
		int e = posix_spawn(&pid, path, NULL, NULL, argv, environ);
		if (e != 0)
			errc(EXIT_FAILURE, e, "posix_spawn of %s failed", path);
	} else {
		pid = fork();
		if (pid == -1)
			err(EXIT_FAILURE, "fork failed");
		if (pid == 0) {
			(void) execv(path, argv);
			err(127, "execv of %s failed", path);
		}
	}

	while (waitpid(pid, &status, 0) != pid) {
		if (errno != EINTR)
			err(EXIT_FAILURE, "waitpid failed");
	}

	if (!WIFEXITED(status) || WEXITSTATUS(status) != EXIT_SUCCESS) {
		(void) fprintf(stderr, "TEST FAILED: %s: child status %#x\n",
		    desc, status);
		failures++;
		return;
	}

	(void) printf("TEST PASSED: %s\n", desc);
}

int
main(int argc, char *argv[])
{
	const char *path;

	if (argc > 1 && strcmp(argv[1], "child") == 0)
		return (fpu_child());

	path = getexecname();
	if (path == NULL)
		errx(EXIT_FAILURE, "could not determine own path");

	run_child("fork+exec child FPU initialisation", false, path);
	run_child("posix_spawn child FPU initialisation", true, path);

	if (failures != 0) {
		(void) fprintf(stderr, "%u test(s) failed\n", failures);
		return (EXIT_FAILURE);
	}

	(void) printf("All tests passed\n");
	return (EXIT_SUCCESS);
}