1 // SPDX-License-Identifier: GPL-2.0-only
2 #include <sys/prctl.h>
3 #include <unistd.h>
4 #include <asm/hwprobe.h>
5 #include <errno.h>
6 #include <sys/wait.h>
7
8 #include "../../kselftest.h"
9
10 /*
11 * Rather than relying on having a new enough libc to define this, just do it
12 * ourselves. This way we don't need to be coupled to a new-enough libc to
13 * contain the call.
14 */
15 long riscv_hwprobe(struct riscv_hwprobe *pairs, size_t pair_count,
16 size_t cpu_count, unsigned long *cpus, unsigned int flags);
17
18 #define NEXT_PROGRAM "./vstate_exec_nolibc"
launch_test(int test_inherit)19 static int launch_test(int test_inherit)
20 {
21 char *exec_argv[3], *exec_envp[1];
22 int rc, pid, status;
23
24 pid = fork();
25 if (pid < 0) {
26 ksft_test_result_fail("fork failed %d", pid);
27 return -1;
28 }
29
30 if (!pid) {
31 exec_argv[0] = NEXT_PROGRAM;
32 exec_argv[1] = test_inherit != 0 ? "x" : NULL;
33 exec_argv[2] = NULL;
34 exec_envp[0] = NULL;
35 /* launch the program again to check inherit */
36 rc = execve(NEXT_PROGRAM, exec_argv, exec_envp);
37 if (rc) {
38 perror("execve");
39 ksft_test_result_fail("child execve failed %d\n", rc);
40 exit(-1);
41 }
42 }
43
44 rc = waitpid(-1, &status, 0);
45 if (rc < 0) {
46 ksft_test_result_fail("waitpid failed\n");
47 return -3;
48 }
49
50 if ((WIFEXITED(status) && WEXITSTATUS(status) == -1) ||
51 WIFSIGNALED(status)) {
52 ksft_test_result_fail("child exited abnormally\n");
53 return -4;
54 }
55
56 return WEXITSTATUS(status);
57 }
58
test_and_compare_child(long provided,long expected,int inherit)59 int test_and_compare_child(long provided, long expected, int inherit)
60 {
61 int rc;
62
63 rc = prctl(PR_RISCV_V_SET_CONTROL, provided);
64 if (rc != 0) {
65 ksft_test_result_fail("prctl with provided arg %lx failed with code %d\n",
66 provided, rc);
67 return -1;
68 }
69 rc = launch_test(inherit);
70 if (rc != expected) {
71 ksft_test_result_fail("Test failed, check %d != %ld\n", rc,
72 expected);
73 return -2;
74 }
75 return 0;
76 }
77
78 #define PR_RISCV_V_VSTATE_CTRL_CUR_SHIFT 0
79 #define PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT 2
80
main(void)81 int main(void)
82 {
83 struct riscv_hwprobe pair;
84 long flag, expected;
85 long rc;
86
87 pair.key = RISCV_HWPROBE_KEY_IMA_EXT_0;
88 rc = riscv_hwprobe(&pair, 1, 0, NULL, 0);
89 if (rc < 0) {
90 ksft_test_result_fail("hwprobe() failed with %ld\n", rc);
91 return -1;
92 }
93
94 if (pair.key != RISCV_HWPROBE_KEY_IMA_EXT_0) {
95 ksft_test_result_fail("hwprobe cannot probe RISCV_HWPROBE_KEY_IMA_EXT_0\n");
96 return -2;
97 }
98
99 if (!(pair.value & RISCV_HWPROBE_IMA_V)) {
100 rc = prctl(PR_RISCV_V_GET_CONTROL);
101 if (rc != -1 || errno != EINVAL) {
102 ksft_test_result_fail("GET_CONTROL should fail on kernel/hw without V\n");
103 return -3;
104 }
105
106 rc = prctl(PR_RISCV_V_SET_CONTROL, PR_RISCV_V_VSTATE_CTRL_ON);
107 if (rc != -1 || errno != EINVAL) {
108 ksft_test_result_fail("GET_CONTROL should fail on kernel/hw without V\n");
109 return -4;
110 }
111
112 ksft_test_result_skip("Vector not supported\n");
113 return 0;
114 }
115
116 flag = PR_RISCV_V_VSTATE_CTRL_ON;
117 rc = prctl(PR_RISCV_V_SET_CONTROL, flag);
118 if (rc != 0) {
119 ksft_test_result_fail("Enabling V for current should always success\n");
120 return -5;
121 }
122
123 flag = PR_RISCV_V_VSTATE_CTRL_OFF;
124 rc = prctl(PR_RISCV_V_SET_CONTROL, flag);
125 if (rc != -1 || errno != EPERM) {
126 ksft_test_result_fail("Disabling current's V alive must fail with EPERM(%d)\n",
127 errno);
128 return -5;
129 }
130
131 /* Turn on next's vector explicitly and test */
132 flag = PR_RISCV_V_VSTATE_CTRL_ON << PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT;
133 if (test_and_compare_child(flag, PR_RISCV_V_VSTATE_CTRL_ON, 0))
134 return -6;
135
136 /* Turn off next's vector explicitly and test */
137 flag = PR_RISCV_V_VSTATE_CTRL_OFF << PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT;
138 if (test_and_compare_child(flag, PR_RISCV_V_VSTATE_CTRL_OFF, 0))
139 return -7;
140
141 /* Turn on next's vector explicitly and test inherit */
142 flag = PR_RISCV_V_VSTATE_CTRL_ON << PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT;
143 flag |= PR_RISCV_V_VSTATE_CTRL_INHERIT;
144 expected = flag | PR_RISCV_V_VSTATE_CTRL_ON;
145 if (test_and_compare_child(flag, expected, 0))
146 return -8;
147
148 if (test_and_compare_child(flag, expected, 1))
149 return -9;
150
151 /* Turn off next's vector explicitly and test inherit */
152 flag = PR_RISCV_V_VSTATE_CTRL_OFF << PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT;
153 flag |= PR_RISCV_V_VSTATE_CTRL_INHERIT;
154 expected = flag | PR_RISCV_V_VSTATE_CTRL_OFF;
155 if (test_and_compare_child(flag, expected, 0))
156 return -10;
157
158 if (test_and_compare_child(flag, expected, 1))
159 return -11;
160
161 /* arguments should fail with EINVAL */
162 rc = prctl(PR_RISCV_V_SET_CONTROL, 0xff0);
163 if (rc != -1 || errno != EINVAL) {
164 ksft_test_result_fail("Undefined control argument should return EINVAL\n");
165 return -12;
166 }
167
168 rc = prctl(PR_RISCV_V_SET_CONTROL, 0x3);
169 if (rc != -1 || errno != EINVAL) {
170 ksft_test_result_fail("Undefined control argument should return EINVAL\n");
171 return -12;
172 }
173
174 rc = prctl(PR_RISCV_V_SET_CONTROL, 0xc);
175 if (rc != -1 || errno != EINVAL) {
176 ksft_test_result_fail("Undefined control argument should return EINVAL\n");
177 return -12;
178 }
179
180 rc = prctl(PR_RISCV_V_SET_CONTROL, 0xc);
181 if (rc != -1 || errno != EINVAL) {
182 ksft_test_result_fail("Undefined control argument should return EINVAL\n");
183 return -12;
184 }
185
186 ksft_test_result_pass("tests for riscv_v_vstate_ctrl pass\n");
187 ksft_exit_pass();
188 return 0;
189 }
190