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