1 // SPDX-License-Identifier: GPL-2.0
2
3 #define _GNU_SOURCE
4 #include <err.h>
5 #include <errno.h>
6 #include <pthread.h>
7 #include <setjmp.h>
8 #include <stdio.h>
9 #include <string.h>
10 #include <stdbool.h>
11 #include <unistd.h>
12 #include <x86intrin.h>
13
14 #include <sys/auxv.h>
15 #include <sys/mman.h>
16 #include <sys/shm.h>
17 #include <sys/ptrace.h>
18 #include <sys/syscall.h>
19 #include <sys/wait.h>
20 #include <sys/uio.h>
21
22 #include "../kselftest.h" /* For __cpuid_count() */
23
24 #ifndef __x86_64__
25 # error This test is 64-bit only
26 #endif
27
28 #define XSAVE_HDR_OFFSET 512
29 #define XSAVE_HDR_SIZE 64
30
31 struct xsave_buffer {
32 union {
33 struct {
34 char legacy[XSAVE_HDR_OFFSET];
35 char header[XSAVE_HDR_SIZE];
36 char extended[0];
37 };
38 char bytes[0];
39 };
40 };
41
42 static inline void xsave(struct xsave_buffer *xbuf, uint64_t rfbm)
43 {
44 uint32_t rfbm_lo = rfbm;
45 uint32_t rfbm_hi = rfbm >> 32;
46
47 asm volatile("xsave (%%rdi)"
48 : : "D" (xbuf), "a" (rfbm_lo), "d" (rfbm_hi)
49 : "memory");
50 }
51
52 static inline void xrstor(struct xsave_buffer *xbuf, uint64_t rfbm)
53 {
54 uint32_t rfbm_lo = rfbm;
55 uint32_t rfbm_hi = rfbm >> 32;
56
57 asm volatile("xrstor (%%rdi)"
58 : : "D" (xbuf), "a" (rfbm_lo), "d" (rfbm_hi));
59 }
60
61 /* err() exits and will not return */
62 #define fatal_error(msg, ...) err(1, "[FAIL]\t" msg, ##__VA_ARGS__)
63
64 static void sethandler(int sig, void (*handler)(int, siginfo_t *, void *),
65 int flags)
66 {
67 struct sigaction sa;
68
69 memset(&sa, 0, sizeof(sa));
70 sa.sa_sigaction = handler;
71 sa.sa_flags = SA_SIGINFO | flags;
72 sigemptyset(&sa.sa_mask);
73 if (sigaction(sig, &sa, 0))
74 fatal_error("sigaction");
75 }
76
77 static void clearhandler(int sig)
78 {
79 struct sigaction sa;
80
81 memset(&sa, 0, sizeof(sa));
82 sa.sa_handler = SIG_DFL;
83 sigemptyset(&sa.sa_mask);
84 if (sigaction(sig, &sa, 0))
85 fatal_error("sigaction");
86 }
87
88 #define XFEATURE_XTILECFG 17
89 #define XFEATURE_XTILEDATA 18
90 #define XFEATURE_MASK_XTILECFG (1 << XFEATURE_XTILECFG)
91 #define XFEATURE_MASK_XTILEDATA (1 << XFEATURE_XTILEDATA)
92 #define XFEATURE_MASK_XTILE (XFEATURE_MASK_XTILECFG | XFEATURE_MASK_XTILEDATA)
93
94 #define CPUID_LEAF1_ECX_XSAVE_MASK (1 << 26)
95 #define CPUID_LEAF1_ECX_OSXSAVE_MASK (1 << 27)
96
97 static uint32_t xbuf_size;
98
99 static struct {
100 uint32_t xbuf_offset;
101 uint32_t size;
102 } xtiledata;
103
104 #define CPUID_LEAF_XSTATE 0xd
105 #define CPUID_SUBLEAF_XSTATE_USER 0x0
106 #define TILE_CPUID 0x1d
107 #define TILE_PALETTE_ID 0x1
108
109 static void check_cpuid_xtiledata(void)
110 {
111 uint32_t eax, ebx, ecx, edx;
112
113 __cpuid_count(CPUID_LEAF_XSTATE, CPUID_SUBLEAF_XSTATE_USER,
114 eax, ebx, ecx, edx);
115
116 /*
117 * EBX enumerates the size (in bytes) required by the XSAVE
118 * instruction for an XSAVE area containing all the user state
119 * components corresponding to bits currently set in XCR0.
120 *
121 * Stash that off so it can be used to allocate buffers later.
122 */
123 xbuf_size = ebx;
124
125 __cpuid_count(CPUID_LEAF_XSTATE, XFEATURE_XTILEDATA,
126 eax, ebx, ecx, edx);
127 /*
128 * eax: XTILEDATA state component size
129 * ebx: XTILEDATA state component offset in user buffer
130 */
131 if (!eax || !ebx)
132 fatal_error("xstate cpuid: invalid tile data size/offset: %d/%d",
133 eax, ebx);
134
135 xtiledata.size = eax;
136 xtiledata.xbuf_offset = ebx;
137 }
138
139 /* The helpers for managing XSAVE buffer and tile states: */
140
141 struct xsave_buffer *alloc_xbuf(void)
142 {
143 struct xsave_buffer *xbuf;
144
145 /* XSAVE buffer should be 64B-aligned. */
146 xbuf = aligned_alloc(64, xbuf_size);
147 if (!xbuf)
148 fatal_error("aligned_alloc()");
149 return xbuf;
150 }
151
152 static inline void clear_xstate_header(struct xsave_buffer *buffer)
153 {
154 memset(&buffer->header, 0, sizeof(buffer->header));
155 }
156
157 static inline void set_xstatebv(struct xsave_buffer *buffer, uint64_t bv)
158 {
159 /* XSTATE_BV is at the beginning of the header: */
160 *(uint64_t *)(&buffer->header) = bv;
161 }
162
163 static void set_rand_tiledata(struct xsave_buffer *xbuf)
164 {
165 int *ptr = (int *)&xbuf->bytes[xtiledata.xbuf_offset];
166 int data;
167 int i;
168
169 /*
170 * Ensure that 'data' is never 0. This ensures that
171 * the registers are never in their initial configuration
172 * and thus never tracked as being in the init state.
173 */
174 data = rand() | 1;
175
176 for (i = 0; i < xtiledata.size / sizeof(int); i++, ptr++)
177 *ptr = data;
178 }
179
180 struct xsave_buffer *stashed_xsave;
181
182 static void init_stashed_xsave(void)
183 {
184 stashed_xsave = alloc_xbuf();
185 if (!stashed_xsave)
186 fatal_error("failed to allocate stashed_xsave\n");
187 clear_xstate_header(stashed_xsave);
188 }
189
190 static void free_stashed_xsave(void)
191 {
192 free(stashed_xsave);
193 }
194
195 /* See 'struct _fpx_sw_bytes' at sigcontext.h */
196 #define SW_BYTES_OFFSET 464
197 /* N.B. The struct's field name varies so read from the offset. */
198 #define SW_BYTES_BV_OFFSET (SW_BYTES_OFFSET + 8)
199
200 static inline struct _fpx_sw_bytes *get_fpx_sw_bytes(void *buffer)
201 {
202 return (struct _fpx_sw_bytes *)(buffer + SW_BYTES_OFFSET);
203 }
204
205 static inline uint64_t get_fpx_sw_bytes_features(void *buffer)
206 {
207 return *(uint64_t *)(buffer + SW_BYTES_BV_OFFSET);
208 }
209
210 /* Work around printf() being unsafe in signals: */
211 #define SIGNAL_BUF_LEN 1000
212 char signal_message_buffer[SIGNAL_BUF_LEN];
213 void sig_print(char *msg)
214 {
215 int left = SIGNAL_BUF_LEN - strlen(signal_message_buffer) - 1;
216
217 strncat(signal_message_buffer, msg, left);
218 }
219
220 static volatile bool noperm_signaled;
221 static int noperm_errs;
222 /*
223 * Signal handler for when AMX is used but
224 * permission has not been obtained.
225 */
226 static void handle_noperm(int sig, siginfo_t *si, void *ctx_void)
227 {
228 ucontext_t *ctx = (ucontext_t *)ctx_void;
229 void *xbuf = ctx->uc_mcontext.fpregs;
230 struct _fpx_sw_bytes *sw_bytes;
231 uint64_t features;
232
233 /* Reset the signal message buffer: */
234 signal_message_buffer[0] = '\0';
235 sig_print("\tAt SIGILL handler,\n");
236
237 if (si->si_code != ILL_ILLOPC) {
238 noperm_errs++;
239 sig_print("[FAIL]\tInvalid signal code.\n");
240 } else {
241 sig_print("[OK]\tValid signal code (ILL_ILLOPC).\n");
242 }
243
244 sw_bytes = get_fpx_sw_bytes(xbuf);
245 /*
246 * Without permission, the signal XSAVE buffer should not
247 * have room for AMX register state (aka. xtiledata).
248 * Check that the size does not overlap with where xtiledata
249 * will reside.
250 *
251 * This also implies that no state components *PAST*
252 * XTILEDATA (features >=19) can be present in the buffer.
253 */
254 if (sw_bytes->xstate_size <= xtiledata.xbuf_offset) {
255 sig_print("[OK]\tValid xstate size\n");
256 } else {
257 noperm_errs++;
258 sig_print("[FAIL]\tInvalid xstate size\n");
259 }
260
261 features = get_fpx_sw_bytes_features(xbuf);
262 /*
263 * Without permission, the XTILEDATA feature
264 * bit should not be set.
265 */
266 if ((features & XFEATURE_MASK_XTILEDATA) == 0) {
267 sig_print("[OK]\tValid xstate mask\n");
268 } else {
269 noperm_errs++;
270 sig_print("[FAIL]\tInvalid xstate mask\n");
271 }
272
273 noperm_signaled = true;
274 ctx->uc_mcontext.gregs[REG_RIP] += 3; /* Skip the faulting XRSTOR */
275 }
276
277 /* Return true if XRSTOR is successful; otherwise, false. */
278 static inline bool xrstor_safe(struct xsave_buffer *xbuf, uint64_t mask)
279 {
280 noperm_signaled = false;
281 xrstor(xbuf, mask);
282
283 /* Print any messages produced by the signal code: */
284 printf("%s", signal_message_buffer);
285 /*
286 * Reset the buffer to make sure any future printing
287 * only outputs new messages:
288 */
289 signal_message_buffer[0] = '\0';
290
291 if (noperm_errs)
292 fatal_error("saw %d errors in noperm signal handler\n", noperm_errs);
293
294 return !noperm_signaled;
295 }
296
297 /*
298 * Use XRSTOR to populate the XTILEDATA registers with
299 * random data.
300 *
301 * Return true if successful; otherwise, false.
302 */
303 static inline bool load_rand_tiledata(struct xsave_buffer *xbuf)
304 {
305 clear_xstate_header(xbuf);
306 set_xstatebv(xbuf, XFEATURE_MASK_XTILEDATA);
307 set_rand_tiledata(xbuf);
308 return xrstor_safe(xbuf, XFEATURE_MASK_XTILEDATA);
309 }
310
311 /* Return XTILEDATA to its initial configuration. */
312 static inline void init_xtiledata(void)
313 {
314 clear_xstate_header(stashed_xsave);
315 xrstor_safe(stashed_xsave, XFEATURE_MASK_XTILEDATA);
316 }
317
318 enum expected_result { FAIL_EXPECTED, SUCCESS_EXPECTED };
319
320 /* arch_prctl() and sigaltstack() test */
321
322 #define ARCH_GET_XCOMP_SUPP 0x1021
323 #define ARCH_GET_XCOMP_PERM 0x1022
324 #define ARCH_REQ_XCOMP_PERM 0x1023
325
326 static void req_xtiledata_perm(void)
327 {
328 syscall(SYS_arch_prctl, ARCH_REQ_XCOMP_PERM, XFEATURE_XTILEDATA);
329 }
330
331 static void validate_req_xcomp_perm(enum expected_result exp)
332 {
333 unsigned long bitmask, expected_bitmask;
334 long rc;
335
336 rc = syscall(SYS_arch_prctl, ARCH_GET_XCOMP_PERM, &bitmask);
337 if (rc) {
338 fatal_error("prctl(ARCH_GET_XCOMP_PERM) error: %ld", rc);
339 } else if (!(bitmask & XFEATURE_MASK_XTILECFG)) {
340 fatal_error("ARCH_GET_XCOMP_PERM returns XFEATURE_XTILECFG off.");
341 }
342
343 rc = syscall(SYS_arch_prctl, ARCH_REQ_XCOMP_PERM, XFEATURE_XTILEDATA);
344 if (exp == FAIL_EXPECTED) {
345 if (rc) {
346 printf("[OK]\tARCH_REQ_XCOMP_PERM saw expected failure..\n");
347 return;
348 }
349
350 fatal_error("ARCH_REQ_XCOMP_PERM saw unexpected success.\n");
351 } else if (rc) {
352 fatal_error("ARCH_REQ_XCOMP_PERM saw unexpected failure.\n");
353 }
354
355 expected_bitmask = bitmask | XFEATURE_MASK_XTILEDATA;
356
357 rc = syscall(SYS_arch_prctl, ARCH_GET_XCOMP_PERM, &bitmask);
358 if (rc) {
359 fatal_error("prctl(ARCH_GET_XCOMP_PERM) error: %ld", rc);
360 } else if (bitmask != expected_bitmask) {
361 fatal_error("ARCH_REQ_XCOMP_PERM set a wrong bitmask: %lx, expected: %lx.\n",
362 bitmask, expected_bitmask);
363 } else {
364 printf("\tARCH_REQ_XCOMP_PERM is successful.\n");
365 }
366 }
367
368 static void validate_xcomp_perm(enum expected_result exp)
369 {
370 bool load_success = load_rand_tiledata(stashed_xsave);
371
372 if (exp == FAIL_EXPECTED) {
373 if (load_success) {
374 noperm_errs++;
375 printf("[FAIL]\tLoad tiledata succeeded.\n");
376 } else {
377 printf("[OK]\tLoad tiledata failed.\n");
378 }
379 } else if (exp == SUCCESS_EXPECTED) {
380 if (load_success) {
381 printf("[OK]\tLoad tiledata succeeded.\n");
382 } else {
383 noperm_errs++;
384 printf("[FAIL]\tLoad tiledata failed.\n");
385 }
386 }
387 }
388
389 #ifndef AT_MINSIGSTKSZ
390 # define AT_MINSIGSTKSZ 51
391 #endif
392
393 static void *alloc_altstack(unsigned int size)
394 {
395 void *altstack;
396
397 altstack = mmap(NULL, size, PROT_READ | PROT_WRITE,
398 MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
399
400 if (altstack == MAP_FAILED)
401 fatal_error("mmap() for altstack");
402
403 return altstack;
404 }
405
406 static void setup_altstack(void *addr, unsigned long size, enum expected_result exp)
407 {
408 stack_t ss;
409 int rc;
410
411 memset(&ss, 0, sizeof(ss));
412 ss.ss_size = size;
413 ss.ss_sp = addr;
414
415 rc = sigaltstack(&ss, NULL);
416
417 if (exp == FAIL_EXPECTED) {
418 if (rc) {
419 printf("[OK]\tsigaltstack() failed.\n");
420 } else {
421 fatal_error("sigaltstack() succeeded unexpectedly.\n");
422 }
423 } else if (rc) {
424 fatal_error("sigaltstack()");
425 }
426 }
427
428 static void test_dynamic_sigaltstack(void)
429 {
430 unsigned int small_size, enough_size;
431 unsigned long minsigstksz;
432 void *altstack;
433
434 minsigstksz = getauxval(AT_MINSIGSTKSZ);
435 printf("\tAT_MINSIGSTKSZ = %lu\n", minsigstksz);
436 /*
437 * getauxval() itself can return 0 for failure or
438 * success. But, in this case, AT_MINSIGSTKSZ
439 * will always return a >=0 value if implemented.
440 * Just check for 0.
441 */
442 if (minsigstksz == 0) {
443 printf("no support for AT_MINSIGSTKSZ, skipping sigaltstack tests\n");
444 return;
445 }
446
447 enough_size = minsigstksz * 2;
448
449 altstack = alloc_altstack(enough_size);
450 printf("\tAllocate memory for altstack (%u bytes).\n", enough_size);
451
452 /*
453 * Try setup_altstack() with a size which can not fit
454 * XTILEDATA. ARCH_REQ_XCOMP_PERM should fail.
455 */
456 small_size = minsigstksz - xtiledata.size;
457 printf("\tAfter sigaltstack() with small size (%u bytes).\n", small_size);
458 setup_altstack(altstack, small_size, SUCCESS_EXPECTED);
459 validate_req_xcomp_perm(FAIL_EXPECTED);
460
461 /*
462 * Try setup_altstack() with a size derived from
463 * AT_MINSIGSTKSZ. It should be more than large enough
464 * and thus ARCH_REQ_XCOMP_PERM should succeed.
465 */
466 printf("\tAfter sigaltstack() with enough size (%u bytes).\n", enough_size);
467 setup_altstack(altstack, enough_size, SUCCESS_EXPECTED);
468 validate_req_xcomp_perm(SUCCESS_EXPECTED);
469
470 /*
471 * Try to coerce setup_altstack() to again accept a
472 * too-small altstack. This ensures that big-enough
473 * sigaltstacks can not shrink to a too-small value
474 * once XTILEDATA permission is established.
475 */
476 printf("\tThen, sigaltstack() with small size (%u bytes).\n", small_size);
477 setup_altstack(altstack, small_size, FAIL_EXPECTED);
478 }
479
480 static void test_dynamic_state(void)
481 {
482 pid_t parent, child, grandchild;
483
484 parent = fork();
485 if (parent < 0) {
486 /* fork() failed */
487 fatal_error("fork");
488 } else if (parent > 0) {
489 int status;
490 /* fork() succeeded. Now in the parent. */
491
492 wait(&status);
493 if (!WIFEXITED(status) || WEXITSTATUS(status))
494 fatal_error("arch_prctl test parent exit");
495 return;
496 }
497 /* fork() succeeded. Now in the child . */
498
499 printf("[RUN]\tCheck ARCH_REQ_XCOMP_PERM around process fork() and sigaltack() test.\n");
500
501 printf("\tFork a child.\n");
502 child = fork();
503 if (child < 0) {
504 fatal_error("fork");
505 } else if (child > 0) {
506 int status;
507
508 wait(&status);
509 if (!WIFEXITED(status) || WEXITSTATUS(status))
510 fatal_error("arch_prctl test child exit");
511 _exit(0);
512 }
513
514 /*
515 * The permission request should fail without an
516 * XTILEDATA-compatible signal stack
517 */
518 printf("\tTest XCOMP_PERM at child.\n");
519 validate_xcomp_perm(FAIL_EXPECTED);
520
521 /*
522 * Set up an XTILEDATA-compatible signal stack and
523 * also obtain permission to populate XTILEDATA.
524 */
525 printf("\tTest dynamic sigaltstack at child:\n");
526 test_dynamic_sigaltstack();
527
528 /* Ensure that XTILEDATA can be populated. */
529 printf("\tTest XCOMP_PERM again at child.\n");
530 validate_xcomp_perm(SUCCESS_EXPECTED);
531
532 printf("\tFork a grandchild.\n");
533 grandchild = fork();
534 if (grandchild < 0) {
535 /* fork() failed */
536 fatal_error("fork");
537 } else if (!grandchild) {
538 /* fork() succeeded. Now in the (grand)child. */
539 printf("\tTest XCOMP_PERM at grandchild.\n");
540
541 /*
542 * Ensure that the grandchild inherited
543 * permission and a compatible sigaltstack:
544 */
545 validate_xcomp_perm(SUCCESS_EXPECTED);
546 } else {
547 int status;
548 /* fork() succeeded. Now in the parent. */
549
550 wait(&status);
551 if (!WIFEXITED(status) || WEXITSTATUS(status))
552 fatal_error("fork test grandchild");
553 }
554
555 _exit(0);
556 }
557
558 static inline int __compare_tiledata_state(struct xsave_buffer *xbuf1, struct xsave_buffer *xbuf2)
559 {
560 return memcmp(&xbuf1->bytes[xtiledata.xbuf_offset],
561 &xbuf2->bytes[xtiledata.xbuf_offset],
562 xtiledata.size);
563 }
564
565 /*
566 * Save current register state and compare it to @xbuf1.'
567 *
568 * Returns false if @xbuf1 matches the registers.
569 * Returns true if @xbuf1 differs from the registers.
570 */
571 static inline bool __validate_tiledata_regs(struct xsave_buffer *xbuf1)
572 {
573 struct xsave_buffer *xbuf2;
574 int ret;
575
576 xbuf2 = alloc_xbuf();
577 if (!xbuf2)
578 fatal_error("failed to allocate XSAVE buffer\n");
579
580 xsave(xbuf2, XFEATURE_MASK_XTILEDATA);
581 ret = __compare_tiledata_state(xbuf1, xbuf2);
582
583 free(xbuf2);
584
585 if (ret == 0)
586 return false;
587 return true;
588 }
589
590 static inline void validate_tiledata_regs_same(struct xsave_buffer *xbuf)
591 {
592 int ret = __validate_tiledata_regs(xbuf);
593
594 if (ret != 0)
595 fatal_error("TILEDATA registers changed");
596 }
597
598 static inline void validate_tiledata_regs_changed(struct xsave_buffer *xbuf)
599 {
600 int ret = __validate_tiledata_regs(xbuf);
601
602 if (ret == 0)
603 fatal_error("TILEDATA registers did not change");
604 }
605
606 /* tiledata inheritance test */
607
608 static void test_fork(void)
609 {
610 pid_t child, grandchild;
611
612 child = fork();
613 if (child < 0) {
614 /* fork() failed */
615 fatal_error("fork");
616 } else if (child > 0) {
617 /* fork() succeeded. Now in the parent. */
618 int status;
619
620 wait(&status);
621 if (!WIFEXITED(status) || WEXITSTATUS(status))
622 fatal_error("fork test child");
623 return;
624 }
625 /* fork() succeeded. Now in the child. */
626 printf("[RUN]\tCheck tile data inheritance.\n\tBefore fork(), load tiledata\n");
627
628 load_rand_tiledata(stashed_xsave);
629
630 grandchild = fork();
631 if (grandchild < 0) {
632 /* fork() failed */
633 fatal_error("fork");
634 } else if (grandchild > 0) {
635 /* fork() succeeded. Still in the first child. */
636 int status;
637
638 wait(&status);
639 if (!WIFEXITED(status) || WEXITSTATUS(status))
640 fatal_error("fork test grand child");
641 _exit(0);
642 }
643 /* fork() succeeded. Now in the (grand)child. */
644
645 /*
646 * TILEDATA registers are not preserved across fork().
647 * Ensure that their value has changed:
648 */
649 validate_tiledata_regs_changed(stashed_xsave);
650
651 _exit(0);
652 }
653
654 /* Context switching test */
655
656 static struct _ctxtswtest_cfg {
657 unsigned int iterations;
658 unsigned int num_threads;
659 } ctxtswtest_config;
660
661 struct futex_info {
662 pthread_t thread;
663 int nr;
664 pthread_mutex_t mutex;
665 struct futex_info *next;
666 };
667
668 static void *check_tiledata(void *info)
669 {
670 struct futex_info *finfo = (struct futex_info *)info;
671 struct xsave_buffer *xbuf;
672 int i;
673
674 xbuf = alloc_xbuf();
675 if (!xbuf)
676 fatal_error("unable to allocate XSAVE buffer");
677
678 /*
679 * Load random data into 'xbuf' and then restore
680 * it to the tile registers themselves.
681 */
682 load_rand_tiledata(xbuf);
683 for (i = 0; i < ctxtswtest_config.iterations; i++) {
684 pthread_mutex_lock(&finfo->mutex);
685
686 /*
687 * Ensure the register values have not
688 * diverged from those recorded in 'xbuf'.
689 */
690 validate_tiledata_regs_same(xbuf);
691
692 /* Load new, random values into xbuf and registers */
693 load_rand_tiledata(xbuf);
694
695 /*
696 * The last thread's last unlock will be for
697 * thread 0's mutex. However, thread 0 will
698 * have already exited the loop and the mutex
699 * will already be unlocked.
700 *
701 * Because this is not an ERRORCHECK mutex,
702 * that inconsistency will be silently ignored.
703 */
704 pthread_mutex_unlock(&finfo->next->mutex);
705 }
706
707 free(xbuf);
708 /*
709 * Return this thread's finfo, which is
710 * a unique value for this thread.
711 */
712 return finfo;
713 }
714
715 static int create_threads(int num, struct futex_info *finfo)
716 {
717 int i;
718
719 for (i = 0; i < num; i++) {
720 int next_nr;
721
722 finfo[i].nr = i;
723 /*
724 * Thread 'i' will wait on this mutex to
725 * be unlocked. Lock it immediately after
726 * initialization:
727 */
728 pthread_mutex_init(&finfo[i].mutex, NULL);
729 pthread_mutex_lock(&finfo[i].mutex);
730
731 next_nr = (i + 1) % num;
732 finfo[i].next = &finfo[next_nr];
733
734 if (pthread_create(&finfo[i].thread, NULL, check_tiledata, &finfo[i]))
735 fatal_error("pthread_create()");
736 }
737 return 0;
738 }
739
740 static void affinitize_cpu0(void)
741 {
742 cpu_set_t cpuset;
743
744 CPU_ZERO(&cpuset);
745 CPU_SET(0, &cpuset);
746
747 if (sched_setaffinity(0, sizeof(cpuset), &cpuset) != 0)
748 fatal_error("sched_setaffinity to CPU 0");
749 }
750
751 static void test_context_switch(void)
752 {
753 struct futex_info *finfo;
754 int i;
755
756 /* Affinitize to one CPU to force context switches */
757 affinitize_cpu0();
758
759 req_xtiledata_perm();
760
761 printf("[RUN]\tCheck tiledata context switches, %d iterations, %d threads.\n",
762 ctxtswtest_config.iterations,
763 ctxtswtest_config.num_threads);
764
765
766 finfo = malloc(sizeof(*finfo) * ctxtswtest_config.num_threads);
767 if (!finfo)
768 fatal_error("malloc()");
769
770 create_threads(ctxtswtest_config.num_threads, finfo);
771
772 /*
773 * This thread wakes up thread 0
774 * Thread 0 will wake up 1
775 * Thread 1 will wake up 2
776 * ...
777 * the last thread will wake up 0
778 *
779 * ... this will repeat for the configured
780 * number of iterations.
781 */
782 pthread_mutex_unlock(&finfo[0].mutex);
783
784 /* Wait for all the threads to finish: */
785 for (i = 0; i < ctxtswtest_config.num_threads; i++) {
786 void *thread_retval;
787 int rc;
788
789 rc = pthread_join(finfo[i].thread, &thread_retval);
790
791 if (rc)
792 fatal_error("pthread_join() failed for thread %d err: %d\n",
793 i, rc);
794
795 if (thread_retval != &finfo[i])
796 fatal_error("unexpected thread retval for thread %d: %p\n",
797 i, thread_retval);
798
799 }
800
801 printf("[OK]\tNo incorrect case was found.\n");
802
803 free(finfo);
804 }
805
806 /* Ptrace test */
807
808 /*
809 * Make sure the ptracee has the expanded kernel buffer on the first
810 * use. Then, initialize the state before performing the state
811 * injection from the ptracer.
812 */
813 static inline void ptracee_firstuse_tiledata(void)
814 {
815 load_rand_tiledata(stashed_xsave);
816 init_xtiledata();
817 }
818
819 /*
820 * Ptracer injects the randomized tile data state. It also reads
821 * before and after that, which will execute the kernel's state copy
822 * functions. So, the tester is advised to double-check any emitted
823 * kernel messages.
824 */
825 static void ptracer_inject_tiledata(pid_t target)
826 {
827 struct xsave_buffer *xbuf;
828 struct iovec iov;
829
830 xbuf = alloc_xbuf();
831 if (!xbuf)
832 fatal_error("unable to allocate XSAVE buffer");
833
834 printf("\tRead the init'ed tiledata via ptrace().\n");
835
836 iov.iov_base = xbuf;
837 iov.iov_len = xbuf_size;
838
839 memset(stashed_xsave, 0, xbuf_size);
840
841 if (ptrace(PTRACE_GETREGSET, target, (uint32_t)NT_X86_XSTATE, &iov))
842 fatal_error("PTRACE_GETREGSET");
843
844 if (!__compare_tiledata_state(stashed_xsave, xbuf))
845 printf("[OK]\tThe init'ed tiledata was read from ptracee.\n");
846 else
847 printf("[FAIL]\tThe init'ed tiledata was not read from ptracee.\n");
848
849 printf("\tInject tiledata via ptrace().\n");
850
851 load_rand_tiledata(xbuf);
852
853 memcpy(&stashed_xsave->bytes[xtiledata.xbuf_offset],
854 &xbuf->bytes[xtiledata.xbuf_offset],
855 xtiledata.size);
856
857 if (ptrace(PTRACE_SETREGSET, target, (uint32_t)NT_X86_XSTATE, &iov))
858 fatal_error("PTRACE_SETREGSET");
859
860 if (ptrace(PTRACE_GETREGSET, target, (uint32_t)NT_X86_XSTATE, &iov))
861 fatal_error("PTRACE_GETREGSET");
862
863 if (!__compare_tiledata_state(stashed_xsave, xbuf))
864 printf("[OK]\tTiledata was correctly written to ptracee.\n");
865 else
866 printf("[FAIL]\tTiledata was not correctly written to ptracee.\n");
867 }
868
869 static void test_ptrace(void)
870 {
871 pid_t child;
872 int status;
873
874 child = fork();
875 if (child < 0) {
876 err(1, "fork");
877 } else if (!child) {
878 if (ptrace(PTRACE_TRACEME, 0, NULL, NULL))
879 err(1, "PTRACE_TRACEME");
880
881 ptracee_firstuse_tiledata();
882
883 raise(SIGTRAP);
884 _exit(0);
885 }
886
887 do {
888 wait(&status);
889 } while (WSTOPSIG(status) != SIGTRAP);
890
891 ptracer_inject_tiledata(child);
892
893 ptrace(PTRACE_DETACH, child, NULL, NULL);
894 wait(&status);
895 if (!WIFEXITED(status) || WEXITSTATUS(status))
896 err(1, "ptrace test");
897 }
898
899 int main(void)
900 {
901 unsigned long features;
902 long rc;
903
904 rc = syscall(SYS_arch_prctl, ARCH_GET_XCOMP_SUPP, &features);
905 if (rc || (features & XFEATURE_MASK_XTILE) != XFEATURE_MASK_XTILE) {
906 ksft_print_msg("no AMX support\n");
907 return KSFT_SKIP;
908 }
909
910 check_cpuid_xtiledata();
911
912 init_stashed_xsave();
913 sethandler(SIGILL, handle_noperm, 0);
914
915 test_dynamic_state();
916
917 /* Request permission for the following tests */
918 req_xtiledata_perm();
919
920 test_fork();
921
922 ctxtswtest_config.iterations = 10;
923 ctxtswtest_config.num_threads = 5;
924 test_context_switch();
925
926 test_ptrace();
927
928 clearhandler(SIGILL);
929 free_stashed_xsave();
930
931 return 0;
932 }
933
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.