Unverified Commit 7cf6198c authored by Andy Chiu's avatar Andy Chiu Committed by Palmer Dabbelt
Browse files

selftests: Test RISC-V Vector prctl interface 



This add a test for prctl interface that controls the use of userspace
Vector.

Signed-off-by: default avatarAndy Chiu <andy.chiu@sifive.com>
Link: https://lore.kernel.org/r/20230605110724.21391-27-andy.chiu@sifive.com


Signed-off-by: default avatarPalmer Dabbelt <palmer@rivosinc.com>
parent 04a4722e

tools/testing/selftests/riscv/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -5,7 +5,7 @@ 
ARCH ?= $(shell uname -m 2>/dev/null || echo not)



ifneq (,$(filter $(ARCH),riscv))

RISCV_SUBTARGETS ?= hwprobe

RISCV_SUBTARGETS ?= hwprobe vector

else

RISCV_SUBTARGETS :=

endif

tools/testing/selftests/riscv/vector/.gitignore

0 → 100644
+2 −0
Original line number Diff line number Diff line 
vstate_exec_nolibc

vstate_prctl

tools/testing/selftests/riscv/vector/Makefile

0 → 100644
+15 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0

# Copyright (C) 2021 ARM Limited

# Originally tools/testing/arm64/abi/Makefile



TEST_GEN_PROGS := vstate_prctl

TEST_GEN_PROGS_EXTENDED := vstate_exec_nolibc



include ../../lib.mk



$(OUTPUT)/vstate_prctl: vstate_prctl.c ../hwprobe/sys_hwprobe.S

	$(CC) -static -o$@ $(CFLAGS) $(LDFLAGS) $^



$(OUTPUT)/vstate_exec_nolibc: vstate_exec_nolibc.c

	$(CC) -nostdlib -static -include ../../../../include/nolibc/nolibc.h \

		-Wall $(CFLAGS) $(LDFLAGS) $^ -o $@ -lgcc

tools/testing/selftests/riscv/vector/vstate_exec_nolibc.c

0 → 100644
+111 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

#include <sys/prctl.h>



#define THIS_PROGRAM "./vstate_exec_nolibc"



int main(int argc, char **argv)

{

	int rc, pid, status, test_inherit = 0;

	long ctrl, ctrl_c;

	char *exec_argv[2], *exec_envp[2];



	if (argc > 1)

		test_inherit = 1;



	ctrl = my_syscall1(__NR_prctl, PR_RISCV_V_GET_CONTROL);

	if (ctrl < 0) {

		puts("PR_RISCV_V_GET_CONTROL is not supported\n");

		return ctrl;

	}



	if (test_inherit) {

		pid = fork();

		if (pid == -1) {

			puts("fork failed\n");

			exit(-1);

		}



		/* child  */

		if (!pid) {

			exec_argv[0] = THIS_PROGRAM;

			exec_argv[1] = NULL;

			exec_envp[0] = NULL;

			exec_envp[1] = NULL;

			/* launch the program again to check inherit */

			rc = execve(THIS_PROGRAM, exec_argv, exec_envp);

			if (rc) {

				puts("child execve failed\n");

				exit(-1);

			}

		}



	} else {

		pid = fork();

		if (pid == -1) {

			puts("fork failed\n");

			exit(-1);

		}



		if (!pid) {

			rc = my_syscall1(__NR_prctl, PR_RISCV_V_GET_CONTROL);

			if (rc != ctrl) {

				puts("child's vstate_ctrl not equal to parent's\n");

				exit(-1);

			}

			asm volatile (".option push\n\t"

				      ".option arch, +v\n\t"

				      "vsetvli x0, x0, e32, m8, ta, ma\n\t"

				      ".option pop\n\t"

				      );

			exit(ctrl);

		}

	}



	rc = waitpid(-1, &status, 0);



	if (WIFEXITED(status) && WEXITSTATUS(status) == -1) {

		puts("child exited abnormally\n");

		exit(-1);

	}



	if (WIFSIGNALED(status)) {

		if (WTERMSIG(status) != SIGILL) {

			puts("child was terminated by unexpected signal\n");

			exit(-1);

		}



		if ((ctrl & PR_RISCV_V_VSTATE_CTRL_CUR_MASK) != PR_RISCV_V_VSTATE_CTRL_OFF) {

			puts("child signaled by illegal V access but vstate_ctrl is not off\n");

			exit(-1);

		}



		/* child terminated, and its vstate_ctrl is off */

		exit(ctrl);

	}



	ctrl_c = WEXITSTATUS(status);

	if (test_inherit) {

		if (ctrl & PR_RISCV_V_VSTATE_CTRL_INHERIT) {

			if (!(ctrl_c & PR_RISCV_V_VSTATE_CTRL_INHERIT)) {

				puts("parent has inherit bit, but child has not\n");

				exit(-1);

			}

		}

		rc = (ctrl & PR_RISCV_V_VSTATE_CTRL_NEXT_MASK) >> 2;

		if (rc != PR_RISCV_V_VSTATE_CTRL_DEFAULT) {

			if (rc != (ctrl_c & PR_RISCV_V_VSTATE_CTRL_CUR_MASK)) {

				puts("parent's next setting does not equal to child's\n");

				exit(-1);

			}



			if (!(ctrl & PR_RISCV_V_VSTATE_CTRL_INHERIT)) {

				if ((ctrl_c & PR_RISCV_V_VSTATE_CTRL_NEXT_MASK) !=

				    PR_RISCV_V_VSTATE_CTRL_DEFAULT) {

					puts("must clear child's next vstate_ctrl if !inherit\n");

					exit(-1);

				}

			}

		}

	}

	return ctrl;

}

tools/testing/selftests/riscv/vector/vstate_prctl.c

0 → 100644
+189 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

#include <sys/prctl.h>

#include <unistd.h>

#include <asm/hwprobe.h>

#include <errno.h>

#include <sys/wait.h>



#include "../../kselftest.h"



/*

 * Rather than relying on having a new enough libc to define this, just do it

 * ourselves.  This way we don't need to be coupled to a new-enough libc to

 * contain the call.

 */

long riscv_hwprobe(struct riscv_hwprobe *pairs, size_t pair_count,

		   size_t cpu_count, unsigned long *cpus, unsigned int flags);



#define NEXT_PROGRAM "./vstate_exec_nolibc"

static int launch_test(int test_inherit)

{

	char *exec_argv[3], *exec_envp[1];

	int rc, pid, status;



	pid = fork();

	if (pid < 0) {

		ksft_test_result_fail("fork failed %d", pid);

		return -1;

	}



	if (!pid) {

		exec_argv[0] = NEXT_PROGRAM;

		exec_argv[1] = test_inherit != 0 ? "x" : NULL;

		exec_argv[2] = NULL;

		exec_envp[0] = NULL;

		/* launch the program again to check inherit */

		rc = execve(NEXT_PROGRAM, exec_argv, exec_envp);

		if (rc) {

			perror("execve");

			ksft_test_result_fail("child execve failed %d\n", rc);

			exit(-1);

		}

	}



	rc = waitpid(-1, &status, 0);

	if (rc < 0) {

		ksft_test_result_fail("waitpid failed\n");

		return -3;

	}



	if ((WIFEXITED(status) && WEXITSTATUS(status) == -1) ||

	    WIFSIGNALED(status)) {

		ksft_test_result_fail("child exited abnormally\n");

		return -4;

	}



	return WEXITSTATUS(status);

}



int test_and_compare_child(long provided, long expected, int inherit)

{

	int rc;



	rc = prctl(PR_RISCV_V_SET_CONTROL, provided);

	if (rc != 0) {

		ksft_test_result_fail("prctl with provided arg %lx failed with code %d\n",

				      provided, rc);

		return -1;

	}

	rc = launch_test(inherit);

	if (rc != expected) {

		ksft_test_result_fail("Test failed, check %d != %d\n", rc,

				      expected);

		return -2;

	}

	return 0;

}



#define PR_RISCV_V_VSTATE_CTRL_CUR_SHIFT	0

#define PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT	2



int main(void)

{

	struct riscv_hwprobe pair;

	long flag, expected;

	long rc;



	pair.key = RISCV_HWPROBE_KEY_IMA_EXT_0;

	rc = riscv_hwprobe(&pair, 1, 0, NULL, 0);

	if (rc < 0) {

		ksft_test_result_fail("hwprobe() failed with %d\n", rc);

		return -1;

	}



	if (pair.key != RISCV_HWPROBE_KEY_IMA_EXT_0) {

		ksft_test_result_fail("hwprobe cannot probe RISCV_HWPROBE_KEY_IMA_EXT_0\n");

		return -2;

	}



	if (!(pair.value & RISCV_HWPROBE_IMA_V)) {

		rc = prctl(PR_RISCV_V_GET_CONTROL);

		if (rc != -1 || errno != EINVAL) {

			ksft_test_result_fail("GET_CONTROL should fail on kernel/hw without V\n");

			return -3;

		}



		rc = prctl(PR_RISCV_V_SET_CONTROL, PR_RISCV_V_VSTATE_CTRL_ON);

		if (rc != -1 || errno != EINVAL) {

			ksft_test_result_fail("GET_CONTROL should fail on kernel/hw without V\n");

			return -4;

		}



		ksft_test_result_skip("Vector not supported\n");

		return 0;

	}



	flag = PR_RISCV_V_VSTATE_CTRL_ON;

	rc = prctl(PR_RISCV_V_SET_CONTROL, flag);

	if (rc != 0) {

		ksft_test_result_fail("Enabling V for current should always success\n");

		return -5;

	}



	flag = PR_RISCV_V_VSTATE_CTRL_OFF;

	rc = prctl(PR_RISCV_V_SET_CONTROL, flag);

	if (rc != -1 || errno != EPERM) {

		ksft_test_result_fail("Disabling current's V alive must fail with EPERM(%d)\n",

				      errno);

		return -5;

	}



	/* Turn on next's vector explicitly and test */

	flag = PR_RISCV_V_VSTATE_CTRL_ON << PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT;

	if (test_and_compare_child(flag, PR_RISCV_V_VSTATE_CTRL_ON, 0))

		return -6;



	/* Turn off next's vector explicitly and test */

	flag = PR_RISCV_V_VSTATE_CTRL_OFF << PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT;

	if (test_and_compare_child(flag, PR_RISCV_V_VSTATE_CTRL_OFF, 0))

		return -7;



	/* Turn on next's vector explicitly and test inherit */

	flag = PR_RISCV_V_VSTATE_CTRL_ON << PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT;

	flag |= PR_RISCV_V_VSTATE_CTRL_INHERIT;

	expected = flag | PR_RISCV_V_VSTATE_CTRL_ON;

	if (test_and_compare_child(flag, expected, 0))

		return -8;



	if (test_and_compare_child(flag, expected, 1))

		return -9;



	/* Turn off next's vector explicitly and test inherit */

	flag = PR_RISCV_V_VSTATE_CTRL_OFF << PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT;

	flag |= PR_RISCV_V_VSTATE_CTRL_INHERIT;

	expected = flag | PR_RISCV_V_VSTATE_CTRL_OFF;

	if (test_and_compare_child(flag, expected, 0))

		return -10;



	if (test_and_compare_child(flag, expected, 1))

		return -11;



	/* arguments should fail with EINVAL */

	rc = prctl(PR_RISCV_V_SET_CONTROL, 0xff0);

	if (rc != -1 || errno != EINVAL) {

		ksft_test_result_fail("Undefined control argument should return EINVAL\n");

		return -12;

	}



	rc = prctl(PR_RISCV_V_SET_CONTROL, 0x3);

	if (rc != -1 || errno != EINVAL) {

		ksft_test_result_fail("Undefined control argument should return EINVAL\n");

		return -12;

	}



	rc = prctl(PR_RISCV_V_SET_CONTROL, 0xc);

	if (rc != -1 || errno != EINVAL) {

		ksft_test_result_fail("Undefined control argument should return EINVAL\n");

		return -12;

	}



	rc = prctl(PR_RISCV_V_SET_CONTROL, 0xc);

	if (rc != -1 || errno != EINVAL) {

		ksft_test_result_fail("Undefined control argument should return EINVAL\n");

		return -12;

	}



	ksft_test_result_pass("tests for riscv_v_vstate_ctrl pass\n");

	ksft_exit_pass();

	return 0;

}