1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2021 ARM Limited.
4  */
5 #include <errno.h>
6 #include <stdbool.h>
7 #include <stddef.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include <unistd.h>
12 #include <sys/auxv.h>
13 #include <sys/prctl.h>
14 #include <sys/ptrace.h>
15 #include <sys/types.h>
16 #include <sys/uio.h>
17 #include <sys/wait.h>
18 #include <asm/sigcontext.h>
19 #include <asm/ptrace.h>
20 
21 #include "../../kselftest.h"
22 
23 /* <linux/elf.h> and <sys/auxv.h> don't like each other, so: */
24 #ifndef NT_ARM_ZA
25 #define NT_ARM_ZA 0x40c
26 #endif
27 
28 #define EXPECTED_TESTS (((SVE_VQ_MAX - SVE_VQ_MIN) + 1) * 3)
29 
30 static void fill_buf(char *buf, size_t size)
31 {
32 	int i;
33 
34 	for (i = 0; i < size; i++)
35 		buf[i] = random();
36 }
37 
38 static int do_child(void)
39 {
40 	if (ptrace(PTRACE_TRACEME, -1, NULL, NULL))
41 		ksft_exit_fail_msg("PTRACE_TRACEME", strerror(errno));
42 
43 	if (raise(SIGSTOP))
44 		ksft_exit_fail_msg("raise(SIGSTOP)", strerror(errno));
45 
46 	return EXIT_SUCCESS;
47 }
48 
49 static struct user_za_header *get_za(pid_t pid, void **buf, size_t *size)
50 {
51 	struct user_za_header *za;
52 	void *p;
53 	size_t sz = sizeof(*za);
54 	struct iovec iov;
55 
56 	while (1) {
57 		if (*size < sz) {
58 			p = realloc(*buf, sz);
59 			if (!p) {
60 				errno = ENOMEM;
61 				goto error;
62 			}
63 
64 			*buf = p;
65 			*size = sz;
66 		}
67 
68 		iov.iov_base = *buf;
69 		iov.iov_len = sz;
70 		if (ptrace(PTRACE_GETREGSET, pid, NT_ARM_ZA, &iov))
71 			goto error;
72 
73 		za = *buf;
74 		if (za->size <= sz)
75 			break;
76 
77 		sz = za->size;
78 	}
79 
80 	return za;
81 
82 error:
83 	return NULL;
84 }
85 
86 static int set_za(pid_t pid, const struct user_za_header *za)
87 {
88 	struct iovec iov;
89 
90 	iov.iov_base = (void *)za;
91 	iov.iov_len = za->size;
92 	return ptrace(PTRACE_SETREGSET, pid, NT_ARM_ZA, &iov);
93 }
94 
95 /* Validate attempting to set the specfied VL via ptrace */
96 static void ptrace_set_get_vl(pid_t child, unsigned int vl, bool *supported)
97 {
98 	struct user_za_header za;
99 	struct user_za_header *new_za = NULL;
100 	size_t new_za_size = 0;
101 	int ret, prctl_vl;
102 
103 	*supported = false;
104 
105 	/* Check if the VL is supported in this process */
106 	prctl_vl = prctl(PR_SME_SET_VL, vl);
107 	if (prctl_vl == -1)
108 		ksft_exit_fail_msg("prctl(PR_SME_SET_VL) failed: %s (%d)\n",
109 				   strerror(errno), errno);
110 
111 	/* If the VL is not supported then a supported VL will be returned */
112 	*supported = (prctl_vl == vl);
113 
114 	/* Set the VL by doing a set with no register payload */
115 	memset(&za, 0, sizeof(za));
116 	za.size = sizeof(za);
117 	za.vl = vl;
118 	ret = set_za(child, &za);
119 	if (ret != 0) {
120 		ksft_test_result_fail("Failed to set VL %u\n", vl);
121 		return;
122 	}
123 
124 	/*
125 	 * Read back the new register state and verify that we have the
126 	 * same VL that we got from prctl() on ourselves.
127 	 */
128 	if (!get_za(child, (void **)&new_za, &new_za_size)) {
129 		ksft_test_result_fail("Failed to read VL %u\n", vl);
130 		return;
131 	}
132 
133 	ksft_test_result(new_za->vl = prctl_vl, "Set VL %u\n", vl);
134 
135 	free(new_za);
136 }
137 
138 /* Validate attempting to set no ZA data and read it back */
139 static void ptrace_set_no_data(pid_t child, unsigned int vl)
140 {
141 	void *read_buf = NULL;
142 	struct user_za_header write_za;
143 	struct user_za_header *read_za;
144 	size_t read_za_size = 0;
145 	int ret;
146 
147 	/* Set up some data and write it out */
148 	memset(&write_za, 0, sizeof(write_za));
149 	write_za.size = ZA_PT_ZA_OFFSET;
150 	write_za.vl = vl;
151 
152 	ret = set_za(child, &write_za);
153 	if (ret != 0) {
154 		ksft_test_result_fail("Failed to set VL %u no data\n", vl);
155 		return;
156 	}
157 
158 	/* Read the data back */
159 	if (!get_za(child, (void **)&read_buf, &read_za_size)) {
160 		ksft_test_result_fail("Failed to read VL %u no data\n", vl);
161 		return;
162 	}
163 	read_za = read_buf;
164 
165 	/* We might read more data if there's extensions we don't know */
166 	if (read_za->size < write_za.size) {
167 		ksft_test_result_fail("VL %u wrote %d bytes, only read %d\n",
168 				      vl, write_za.size, read_za->size);
169 		goto out_read;
170 	}
171 
172 	ksft_test_result(read_za->size == write_za.size,
173 			 "Disabled ZA for VL %u\n", vl);
174 
175 out_read:
176 	free(read_buf);
177 }
178 
179 /* Validate attempting to set data and read it back */
180 static void ptrace_set_get_data(pid_t child, unsigned int vl)
181 {
182 	void *write_buf;
183 	void *read_buf = NULL;
184 	struct user_za_header *write_za;
185 	struct user_za_header *read_za;
186 	size_t read_za_size = 0;
187 	unsigned int vq = sve_vq_from_vl(vl);
188 	int ret;
189 	size_t data_size;
190 
191 	data_size = ZA_PT_SIZE(vq);
192 	write_buf = malloc(data_size);
193 	if (!write_buf) {
194 		ksft_test_result_fail("Error allocating %d byte buffer for VL %u\n",
195 				      data_size, vl);
196 		return;
197 	}
198 	write_za = write_buf;
199 
200 	/* Set up some data and write it out */
201 	memset(write_za, 0, data_size);
202 	write_za->size = data_size;
203 	write_za->vl = vl;
204 
205 	fill_buf(write_buf + ZA_PT_ZA_OFFSET, ZA_PT_ZA_SIZE(vq));
206 
207 	ret = set_za(child, write_za);
208 	if (ret != 0) {
209 		ksft_test_result_fail("Failed to set VL %u data\n", vl);
210 		goto out;
211 	}
212 
213 	/* Read the data back */
214 	if (!get_za(child, (void **)&read_buf, &read_za_size)) {
215 		ksft_test_result_fail("Failed to read VL %u data\n", vl);
216 		goto out;
217 	}
218 	read_za = read_buf;
219 
220 	/* We might read more data if there's extensions we don't know */
221 	if (read_za->size < write_za->size) {
222 		ksft_test_result_fail("VL %u wrote %d bytes, only read %d\n",
223 				      vl, write_za->size, read_za->size);
224 		goto out_read;
225 	}
226 
227 	ksft_test_result(memcmp(write_buf + ZA_PT_ZA_OFFSET,
228 				read_buf + ZA_PT_ZA_OFFSET,
229 				ZA_PT_ZA_SIZE(vq)) == 0,
230 			 "Data match for VL %u\n", vl);
231 
232 out_read:
233 	free(read_buf);
234 out:
235 	free(write_buf);
236 }
237 
238 static int do_parent(pid_t child)
239 {
240 	int ret = EXIT_FAILURE;
241 	pid_t pid;
242 	int status;
243 	siginfo_t si;
244 	unsigned int vq, vl;
245 	bool vl_supported;
246 
247 	/* Attach to the child */
248 	while (1) {
249 		int sig;
250 
251 		pid = wait(&status);
252 		if (pid == -1) {
253 			perror("wait");
254 			goto error;
255 		}
256 
257 		/*
258 		 * This should never happen but it's hard to flag in
259 		 * the framework.
260 		 */
261 		if (pid != child)
262 			continue;
263 
264 		if (WIFEXITED(status) || WIFSIGNALED(status))
265 			ksft_exit_fail_msg("Child died unexpectedly\n");
266 
267 		if (!WIFSTOPPED(status))
268 			goto error;
269 
270 		sig = WSTOPSIG(status);
271 
272 		if (ptrace(PTRACE_GETSIGINFO, pid, NULL, &si)) {
273 			if (errno == ESRCH)
274 				goto disappeared;
275 
276 			if (errno == EINVAL) {
277 				sig = 0; /* bust group-stop */
278 				goto cont;
279 			}
280 
281 			ksft_test_result_fail("PTRACE_GETSIGINFO: %s\n",
282 					      strerror(errno));
283 			goto error;
284 		}
285 
286 		if (sig == SIGSTOP && si.si_code == SI_TKILL &&
287 		    si.si_pid == pid)
288 			break;
289 
290 	cont:
291 		if (ptrace(PTRACE_CONT, pid, NULL, sig)) {
292 			if (errno == ESRCH)
293 				goto disappeared;
294 
295 			ksft_test_result_fail("PTRACE_CONT: %s\n",
296 					      strerror(errno));
297 			goto error;
298 		}
299 	}
300 
301 	ksft_print_msg("Parent is %d, child is %d\n", getpid(), child);
302 
303 	/* Step through every possible VQ */
304 	for (vq = SVE_VQ_MIN; vq <= SVE_VQ_MAX; vq++) {
305 		vl = sve_vl_from_vq(vq);
306 
307 		/* First, try to set this vector length */
308 		ptrace_set_get_vl(child, vl, &vl_supported);
309 
310 		/* If the VL is supported validate data set/get */
311 		if (vl_supported) {
312 			ptrace_set_no_data(child, vl);
313 			ptrace_set_get_data(child, vl);
314 		} else {
315 			ksft_test_result_skip("Disabled ZA for VL %u\n", vl);
316 			ksft_test_result_skip("Get and set data for VL %u\n",
317 					      vl);
318 		}
319 	}
320 
321 	ret = EXIT_SUCCESS;
322 
323 error:
324 	kill(child, SIGKILL);
325 
326 disappeared:
327 	return ret;
328 }
329 
330 int main(void)
331 {
332 	int ret = EXIT_SUCCESS;
333 	pid_t child;
334 
335 	srandom(getpid());
336 
337 	ksft_print_header();
338 
339 	if (!(getauxval(AT_HWCAP2) & HWCAP2_SME)) {
340 		ksft_set_plan(1);
341 		ksft_exit_skip("SME not available\n");
342 	}
343 
344 	ksft_set_plan(EXPECTED_TESTS);
345 
346 	child = fork();
347 	if (!child)
348 		return do_child();
349 
350 	if (do_parent(child))
351 		ret = EXIT_FAILURE;
352 
353 	ksft_print_cnts();
354 
355 	return ret;
356 }
357