1 // SPDX-License-Identifier: GPL-2.0 2 #define _GNU_SOURCE 3 #include <stdio.h> 4 #include <stdlib.h> 5 #include <string.h> 6 #include <sys/syscall.h> 7 #include <time.h> 8 #include <signal.h> 9 #include <setjmp.h> 10 #include <sys/mman.h> 11 #include <sys/utsname.h> 12 #include <sys/wait.h> 13 #include <sys/stat.h> 14 #include <fcntl.h> 15 #include <inttypes.h> 16 #include <sched.h> 17 18 #include <sys/uio.h> 19 #include <linux/io_uring.h> 20 #include "../kselftest.h" 21 22 #ifndef __x86_64__ 23 # error This test is 64-bit only 24 #endif 25 26 /* LAM modes, these definitions were copied from kernel code */ 27 #define LAM_NONE 0 28 #define LAM_U57_BITS 6 29 30 #define LAM_U57_MASK (0x3fULL << 57) 31 /* arch prctl for LAM */ 32 #define ARCH_GET_UNTAG_MASK 0x4001 33 #define ARCH_ENABLE_TAGGED_ADDR 0x4002 34 #define ARCH_GET_MAX_TAG_BITS 0x4003 35 #define ARCH_FORCE_TAGGED_SVA 0x4004 36 37 /* Specified test function bits */ 38 #define FUNC_MALLOC 0x1 39 #define FUNC_BITS 0x2 40 #define FUNC_MMAP 0x4 41 #define FUNC_SYSCALL 0x8 42 #define FUNC_URING 0x10 43 #define FUNC_INHERITE 0x20 44 #define FUNC_PASID 0x40 45 46 #define TEST_MASK 0x7f 47 48 #define LOW_ADDR (0x1UL << 30) 49 #define HIGH_ADDR (0x3UL << 48) 50 51 #define MALLOC_LEN 32 52 53 #define PAGE_SIZE (4 << 10) 54 55 #define STACK_SIZE 65536 56 57 #define barrier() ({ \ 58 __asm__ __volatile__("" : : : "memory"); \ 59 }) 60 61 #define URING_QUEUE_SZ 1 62 #define URING_BLOCK_SZ 2048 63 64 /* Pasid test define */ 65 #define LAM_CMD_BIT 0x1 66 #define PAS_CMD_BIT 0x2 67 #define SVA_CMD_BIT 0x4 68 69 #define PAS_CMD(cmd1, cmd2, cmd3) (((cmd3) << 8) | ((cmd2) << 4) | ((cmd1) << 0)) 70 71 struct testcases { 72 unsigned int later; 73 int expected; /* 2: SIGSEGV Error; 1: other errors */ 74 unsigned long lam; 75 uint64_t addr; 76 uint64_t cmd; 77 int (*test_func)(struct testcases *test); 78 const char *msg; 79 }; 80 81 /* Used by CQ of uring, source file handler and file's size */ 82 struct file_io { 83 int file_fd; 84 off_t file_sz; 85 struct iovec iovecs[]; 86 }; 87 88 struct io_uring_queue { 89 unsigned int *head; 90 unsigned int *tail; 91 unsigned int *ring_mask; 92 unsigned int *ring_entries; 93 unsigned int *flags; 94 unsigned int *array; 95 union { 96 struct io_uring_cqe *cqes; 97 struct io_uring_sqe *sqes; 98 } queue; 99 size_t ring_sz; 100 }; 101 102 struct io_ring { 103 int ring_fd; 104 struct io_uring_queue sq_ring; 105 struct io_uring_queue cq_ring; 106 }; 107 108 int tests_cnt; 109 jmp_buf segv_env; 110 111 static void segv_handler(int sig) 112 { 113 ksft_print_msg("Get segmentation fault(%d).", sig); 114 115 siglongjmp(segv_env, 1); 116 } 117 118 static inline int cpu_has_lam(void) 119 { 120 unsigned int cpuinfo[4]; 121 122 __cpuid_count(0x7, 1, cpuinfo[0], cpuinfo[1], cpuinfo[2], cpuinfo[3]); 123 124 return (cpuinfo[0] & (1 << 26)); 125 } 126 127 /* Check 5-level page table feature in CPUID.(EAX=07H, ECX=00H):ECX.[bit 16] */ 128 static inline int cpu_has_la57(void) 129 { 130 unsigned int cpuinfo[4]; 131 132 __cpuid_count(0x7, 0, cpuinfo[0], cpuinfo[1], cpuinfo[2], cpuinfo[3]); 133 134 return (cpuinfo[2] & (1 << 16)); 135 } 136 137 /* 138 * Set tagged address and read back untag mask. 139 * check if the untagged mask is expected. 140 * 141 * @return: 142 * 0: Set LAM mode successfully 143 * others: failed to set LAM 144 */ 145 static int set_lam(unsigned long lam) 146 { 147 int ret = 0; 148 uint64_t ptr = 0; 149 150 if (lam != LAM_U57_BITS && lam != LAM_NONE) 151 return -1; 152 153 /* Skip check return */ 154 syscall(SYS_arch_prctl, ARCH_ENABLE_TAGGED_ADDR, lam); 155 156 /* Get untagged mask */ 157 syscall(SYS_arch_prctl, ARCH_GET_UNTAG_MASK, &ptr); 158 159 /* Check mask returned is expected */ 160 if (lam == LAM_U57_BITS) 161 ret = (ptr != ~(LAM_U57_MASK)); 162 else if (lam == LAM_NONE) 163 ret = (ptr != -1ULL); 164 165 return ret; 166 } 167 168 static unsigned long get_default_tag_bits(void) 169 { 170 pid_t pid; 171 int lam = LAM_NONE; 172 int ret = 0; 173 174 pid = fork(); 175 if (pid < 0) { 176 perror("Fork failed."); 177 } else if (pid == 0) { 178 /* Set LAM mode in child process */ 179 if (set_lam(LAM_U57_BITS) == 0) 180 lam = LAM_U57_BITS; 181 else 182 lam = LAM_NONE; 183 exit(lam); 184 } else { 185 wait(&ret); 186 lam = WEXITSTATUS(ret); 187 } 188 189 return lam; 190 } 191 192 /* 193 * Set tagged address and read back untag mask. 194 * check if the untag mask is expected. 195 */ 196 static int get_lam(void) 197 { 198 uint64_t ptr = 0; 199 int ret = -1; 200 /* Get untagged mask */ 201 if (syscall(SYS_arch_prctl, ARCH_GET_UNTAG_MASK, &ptr) == -1) 202 return -1; 203 204 /* Check mask returned is expected */ 205 if (ptr == ~(LAM_U57_MASK)) 206 ret = LAM_U57_BITS; 207 else if (ptr == -1ULL) 208 ret = LAM_NONE; 209 210 211 return ret; 212 } 213 214 /* According to LAM mode, set metadata in high bits */ 215 static uint64_t set_metadata(uint64_t src, unsigned long lam) 216 { 217 uint64_t metadata; 218 219 srand(time(NULL)); 220 221 switch (lam) { 222 case LAM_U57_BITS: /* Set metadata in bits 62:57 */ 223 /* Get a random non-zero value as metadata */ 224 metadata = (rand() % ((1UL << LAM_U57_BITS) - 1) + 1) << 57; 225 metadata |= (src & ~(LAM_U57_MASK)); 226 break; 227 default: 228 metadata = src; 229 break; 230 } 231 232 return metadata; 233 } 234 235 /* 236 * Set metadata in user pointer, compare new pointer with original pointer. 237 * both pointers should point to the same address. 238 * 239 * @return: 240 * 0: value on the pointer with metadate and value on original are same 241 * 1: not same. 242 */ 243 static int handle_lam_test(void *src, unsigned int lam) 244 { 245 char *ptr; 246 247 strcpy((char *)src, "USER POINTER"); 248 249 ptr = (char *)set_metadata((uint64_t)src, lam); 250 if (src == ptr) 251 return 0; 252 253 /* Copy a string into the pointer with metadata */ 254 strcpy((char *)ptr, "METADATA POINTER"); 255 256 return (!!strcmp((char *)src, (char *)ptr)); 257 } 258 259 260 int handle_max_bits(struct testcases *test) 261 { 262 unsigned long exp_bits = get_default_tag_bits(); 263 unsigned long bits = 0; 264 265 if (exp_bits != LAM_NONE) 266 exp_bits = LAM_U57_BITS; 267 268 /* Get LAM max tag bits */ 269 if (syscall(SYS_arch_prctl, ARCH_GET_MAX_TAG_BITS, &bits) == -1) 270 return 1; 271 272 return (exp_bits != bits); 273 } 274 275 /* 276 * Test lam feature through dereference pointer get from malloc. 277 * @return 0: Pass test. 1: Get failure during test 2: Get SIGSEGV 278 */ 279 static int handle_malloc(struct testcases *test) 280 { 281 char *ptr = NULL; 282 int ret = 0; 283 284 if (test->later == 0 && test->lam != 0) 285 if (set_lam(test->lam) == -1) 286 return 1; 287 288 ptr = (char *)malloc(MALLOC_LEN); 289 if (ptr == NULL) { 290 perror("malloc() failure\n"); 291 return 1; 292 } 293 294 /* Set signal handler */ 295 if (sigsetjmp(segv_env, 1) == 0) { 296 signal(SIGSEGV, segv_handler); 297 ret = handle_lam_test(ptr, test->lam); 298 } else { 299 ret = 2; 300 } 301 302 if (test->later != 0 && test->lam != 0) 303 if (set_lam(test->lam) == -1 && ret == 0) 304 ret = 1; 305 306 free(ptr); 307 308 return ret; 309 } 310 311 static int handle_mmap(struct testcases *test) 312 { 313 void *ptr; 314 unsigned int flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED; 315 int ret = 0; 316 317 if (test->later == 0 && test->lam != 0) 318 if (set_lam(test->lam) != 0) 319 return 1; 320 321 ptr = mmap((void *)test->addr, PAGE_SIZE, PROT_READ | PROT_WRITE, 322 flags, -1, 0); 323 if (ptr == MAP_FAILED) { 324 if (test->addr == HIGH_ADDR) 325 if (!cpu_has_la57()) 326 return 3; /* unsupport LA57 */ 327 return 1; 328 } 329 330 if (test->later != 0 && test->lam != 0) 331 if (set_lam(test->lam) != 0) 332 ret = 1; 333 334 if (ret == 0) { 335 if (sigsetjmp(segv_env, 1) == 0) { 336 signal(SIGSEGV, segv_handler); 337 ret = handle_lam_test(ptr, test->lam); 338 } else { 339 ret = 2; 340 } 341 } 342 343 munmap(ptr, PAGE_SIZE); 344 return ret; 345 } 346 347 static int handle_syscall(struct testcases *test) 348 { 349 struct utsname unme, *pu; 350 int ret = 0; 351 352 if (test->later == 0 && test->lam != 0) 353 if (set_lam(test->lam) != 0) 354 return 1; 355 356 if (sigsetjmp(segv_env, 1) == 0) { 357 signal(SIGSEGV, segv_handler); 358 pu = (struct utsname *)set_metadata((uint64_t)&unme, test->lam); 359 ret = uname(pu); 360 if (ret < 0) 361 ret = 1; 362 } else { 363 ret = 2; 364 } 365 366 if (test->later != 0 && test->lam != 0) 367 if (set_lam(test->lam) != -1 && ret == 0) 368 ret = 1; 369 370 return ret; 371 } 372 373 int sys_uring_setup(unsigned int entries, struct io_uring_params *p) 374 { 375 return (int)syscall(__NR_io_uring_setup, entries, p); 376 } 377 378 int sys_uring_enter(int fd, unsigned int to, unsigned int min, unsigned int flags) 379 { 380 return (int)syscall(__NR_io_uring_enter, fd, to, min, flags, NULL, 0); 381 } 382 383 /* Init submission queue and completion queue */ 384 int mmap_io_uring(struct io_uring_params p, struct io_ring *s) 385 { 386 struct io_uring_queue *sring = &s->sq_ring; 387 struct io_uring_queue *cring = &s->cq_ring; 388 389 sring->ring_sz = p.sq_off.array + p.sq_entries * sizeof(unsigned int); 390 cring->ring_sz = p.cq_off.cqes + p.cq_entries * sizeof(struct io_uring_cqe); 391 392 if (p.features & IORING_FEAT_SINGLE_MMAP) { 393 if (cring->ring_sz > sring->ring_sz) 394 sring->ring_sz = cring->ring_sz; 395 396 cring->ring_sz = sring->ring_sz; 397 } 398 399 void *sq_ptr = mmap(0, sring->ring_sz, PROT_READ | PROT_WRITE, 400 MAP_SHARED | MAP_POPULATE, s->ring_fd, 401 IORING_OFF_SQ_RING); 402 403 if (sq_ptr == MAP_FAILED) { 404 perror("sub-queue!"); 405 return 1; 406 } 407 408 void *cq_ptr = sq_ptr; 409 410 if (!(p.features & IORING_FEAT_SINGLE_MMAP)) { 411 cq_ptr = mmap(0, cring->ring_sz, PROT_READ | PROT_WRITE, 412 MAP_SHARED | MAP_POPULATE, s->ring_fd, 413 IORING_OFF_CQ_RING); 414 if (cq_ptr == MAP_FAILED) { 415 perror("cpl-queue!"); 416 munmap(sq_ptr, sring->ring_sz); 417 return 1; 418 } 419 } 420 421 sring->head = sq_ptr + p.sq_off.head; 422 sring->tail = sq_ptr + p.sq_off.tail; 423 sring->ring_mask = sq_ptr + p.sq_off.ring_mask; 424 sring->ring_entries = sq_ptr + p.sq_off.ring_entries; 425 sring->flags = sq_ptr + p.sq_off.flags; 426 sring->array = sq_ptr + p.sq_off.array; 427 428 /* Map a queue as mem map */ 429 s->sq_ring.queue.sqes = mmap(0, p.sq_entries * sizeof(struct io_uring_sqe), 430 PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, 431 s->ring_fd, IORING_OFF_SQES); 432 if (s->sq_ring.queue.sqes == MAP_FAILED) { 433 munmap(sq_ptr, sring->ring_sz); 434 if (sq_ptr != cq_ptr) { 435 ksft_print_msg("failed to mmap uring queue!"); 436 munmap(cq_ptr, cring->ring_sz); 437 return 1; 438 } 439 } 440 441 cring->head = cq_ptr + p.cq_off.head; 442 cring->tail = cq_ptr + p.cq_off.tail; 443 cring->ring_mask = cq_ptr + p.cq_off.ring_mask; 444 cring->ring_entries = cq_ptr + p.cq_off.ring_entries; 445 cring->queue.cqes = cq_ptr + p.cq_off.cqes; 446 447 return 0; 448 } 449 450 /* Init io_uring queues */ 451 int setup_io_uring(struct io_ring *s) 452 { 453 struct io_uring_params para; 454 455 memset(¶, 0, sizeof(para)); 456 s->ring_fd = sys_uring_setup(URING_QUEUE_SZ, ¶); 457 if (s->ring_fd < 0) 458 return 1; 459 460 return mmap_io_uring(para, s); 461 } 462 463 /* 464 * Get data from completion queue. the data buffer saved the file data 465 * return 0: success; others: error; 466 */ 467 int handle_uring_cq(struct io_ring *s) 468 { 469 struct file_io *fi = NULL; 470 struct io_uring_queue *cring = &s->cq_ring; 471 struct io_uring_cqe *cqe; 472 unsigned int head; 473 off_t len = 0; 474 475 head = *cring->head; 476 477 do { 478 barrier(); 479 if (head == *cring->tail) 480 break; 481 /* Get the entry */ 482 cqe = &cring->queue.cqes[head & *s->cq_ring.ring_mask]; 483 fi = (struct file_io *)cqe->user_data; 484 if (cqe->res < 0) 485 break; 486 487 int blocks = (int)(fi->file_sz + URING_BLOCK_SZ - 1) / URING_BLOCK_SZ; 488 489 for (int i = 0; i < blocks; i++) 490 len += fi->iovecs[i].iov_len; 491 492 head++; 493 } while (1); 494 495 *cring->head = head; 496 barrier(); 497 498 return (len != fi->file_sz); 499 } 500 501 /* 502 * Submit squeue. specify via IORING_OP_READV. 503 * the buffer need to be set metadata according to LAM mode 504 */ 505 int handle_uring_sq(struct io_ring *ring, struct file_io *fi, unsigned long lam) 506 { 507 int file_fd = fi->file_fd; 508 struct io_uring_queue *sring = &ring->sq_ring; 509 unsigned int index = 0, cur_block = 0, tail = 0, next_tail = 0; 510 struct io_uring_sqe *sqe; 511 512 off_t remain = fi->file_sz; 513 int blocks = (int)(remain + URING_BLOCK_SZ - 1) / URING_BLOCK_SZ; 514 515 while (remain) { 516 off_t bytes = remain; 517 void *buf; 518 519 if (bytes > URING_BLOCK_SZ) 520 bytes = URING_BLOCK_SZ; 521 522 fi->iovecs[cur_block].iov_len = bytes; 523 524 if (posix_memalign(&buf, URING_BLOCK_SZ, URING_BLOCK_SZ)) 525 return 1; 526 527 fi->iovecs[cur_block].iov_base = (void *)set_metadata((uint64_t)buf, lam); 528 remain -= bytes; 529 cur_block++; 530 } 531 532 next_tail = *sring->tail; 533 tail = next_tail; 534 next_tail++; 535 536 barrier(); 537 538 index = tail & *ring->sq_ring.ring_mask; 539 540 sqe = &ring->sq_ring.queue.sqes[index]; 541 sqe->fd = file_fd; 542 sqe->flags = 0; 543 sqe->opcode = IORING_OP_READV; 544 sqe->addr = (unsigned long)fi->iovecs; 545 sqe->len = blocks; 546 sqe->off = 0; 547 sqe->user_data = (uint64_t)fi; 548 549 sring->array[index] = index; 550 tail = next_tail; 551 552 if (*sring->tail != tail) { 553 *sring->tail = tail; 554 barrier(); 555 } 556 557 if (sys_uring_enter(ring->ring_fd, 1, 1, IORING_ENTER_GETEVENTS) < 0) 558 return 1; 559 560 return 0; 561 } 562 563 /* 564 * Test LAM in async I/O and io_uring, read current binery through io_uring 565 * Set metadata in pointers to iovecs buffer. 566 */ 567 int do_uring(unsigned long lam) 568 { 569 struct io_ring *ring; 570 struct file_io *fi; 571 struct stat st; 572 int ret = 1; 573 char path[PATH_MAX] = {0}; 574 575 /* get current process path */ 576 if (readlink("/proc/self/exe", path, PATH_MAX - 1) <= 0) 577 return 1; 578 579 int file_fd = open(path, O_RDONLY); 580 581 if (file_fd < 0) 582 return 1; 583 584 if (fstat(file_fd, &st) < 0) 585 return 1; 586 587 off_t file_sz = st.st_size; 588 589 int blocks = (int)(file_sz + URING_BLOCK_SZ - 1) / URING_BLOCK_SZ; 590 591 fi = malloc(sizeof(*fi) + sizeof(struct iovec) * blocks); 592 if (!fi) 593 return 1; 594 595 fi->file_sz = file_sz; 596 fi->file_fd = file_fd; 597 598 ring = malloc(sizeof(*ring)); 599 if (!ring) 600 return 1; 601 602 memset(ring, 0, sizeof(struct io_ring)); 603 604 if (setup_io_uring(ring)) 605 goto out; 606 607 if (handle_uring_sq(ring, fi, lam)) 608 goto out; 609 610 ret = handle_uring_cq(ring); 611 612 out: 613 free(ring); 614 615 for (int i = 0; i < blocks; i++) { 616 if (fi->iovecs[i].iov_base) { 617 uint64_t addr = ((uint64_t)fi->iovecs[i].iov_base); 618 619 switch (lam) { 620 case LAM_U57_BITS: /* Clear bits 62:57 */ 621 addr = (addr & ~(LAM_U57_MASK)); 622 break; 623 } 624 free((void *)addr); 625 fi->iovecs[i].iov_base = NULL; 626 } 627 } 628 629 free(fi); 630 631 return ret; 632 } 633 634 int handle_uring(struct testcases *test) 635 { 636 int ret = 0; 637 638 if (test->later == 0 && test->lam != 0) 639 if (set_lam(test->lam) != 0) 640 return 1; 641 642 if (sigsetjmp(segv_env, 1) == 0) { 643 signal(SIGSEGV, segv_handler); 644 ret = do_uring(test->lam); 645 } else { 646 ret = 2; 647 } 648 649 return ret; 650 } 651 652 static int fork_test(struct testcases *test) 653 { 654 int ret, child_ret; 655 pid_t pid; 656 657 pid = fork(); 658 if (pid < 0) { 659 perror("Fork failed."); 660 ret = 1; 661 } else if (pid == 0) { 662 ret = test->test_func(test); 663 exit(ret); 664 } else { 665 wait(&child_ret); 666 ret = WEXITSTATUS(child_ret); 667 } 668 669 return ret; 670 } 671 672 static int handle_execve(struct testcases *test) 673 { 674 int ret, child_ret; 675 int lam = test->lam; 676 pid_t pid; 677 678 pid = fork(); 679 if (pid < 0) { 680 perror("Fork failed."); 681 ret = 1; 682 } else if (pid == 0) { 683 char path[PATH_MAX] = {0}; 684 685 /* Set LAM mode in parent process */ 686 if (set_lam(lam) != 0) 687 return 1; 688 689 /* Get current binary's path and the binary was run by execve */ 690 if (readlink("/proc/self/exe", path, PATH_MAX - 1) <= 0) 691 exit(-1); 692 693 /* run binary to get LAM mode and return to parent process */ 694 if (execlp(path, path, "-t 0x0", NULL) < 0) { 695 perror("error on exec"); 696 exit(-1); 697 } 698 } else { 699 wait(&child_ret); 700 ret = WEXITSTATUS(child_ret); 701 if (ret != LAM_NONE) 702 return 1; 703 } 704 705 return 0; 706 } 707 708 static int handle_inheritance(struct testcases *test) 709 { 710 int ret, child_ret; 711 int lam = test->lam; 712 pid_t pid; 713 714 /* Set LAM mode in parent process */ 715 if (set_lam(lam) != 0) 716 return 1; 717 718 pid = fork(); 719 if (pid < 0) { 720 perror("Fork failed."); 721 return 1; 722 } else if (pid == 0) { 723 /* Set LAM mode in parent process */ 724 int child_lam = get_lam(); 725 726 exit(child_lam); 727 } else { 728 wait(&child_ret); 729 ret = WEXITSTATUS(child_ret); 730 731 if (lam != ret) 732 return 1; 733 } 734 735 return 0; 736 } 737 738 static int thread_fn_get_lam(void *arg) 739 { 740 return get_lam(); 741 } 742 743 static int thread_fn_set_lam(void *arg) 744 { 745 struct testcases *test = arg; 746 747 return set_lam(test->lam); 748 } 749 750 static int handle_thread(struct testcases *test) 751 { 752 char stack[STACK_SIZE]; 753 int ret, child_ret; 754 int lam = 0; 755 pid_t pid; 756 757 /* Set LAM mode in parent process */ 758 if (!test->later) { 759 lam = test->lam; 760 if (set_lam(lam) != 0) 761 return 1; 762 } 763 764 pid = clone(thread_fn_get_lam, stack + STACK_SIZE, 765 SIGCHLD | CLONE_FILES | CLONE_FS | CLONE_VM, NULL); 766 if (pid < 0) { 767 perror("Clone failed."); 768 return 1; 769 } 770 771 waitpid(pid, &child_ret, 0); 772 ret = WEXITSTATUS(child_ret); 773 774 if (lam != ret) 775 return 1; 776 777 if (test->later) { 778 if (set_lam(test->lam) != 0) 779 return 1; 780 } 781 782 return 0; 783 } 784 785 static int handle_thread_enable(struct testcases *test) 786 { 787 char stack[STACK_SIZE]; 788 int ret, child_ret; 789 int lam = test->lam; 790 pid_t pid; 791 792 pid = clone(thread_fn_set_lam, stack + STACK_SIZE, 793 SIGCHLD | CLONE_FILES | CLONE_FS | CLONE_VM, test); 794 if (pid < 0) { 795 perror("Clone failed."); 796 return 1; 797 } 798 799 waitpid(pid, &child_ret, 0); 800 ret = WEXITSTATUS(child_ret); 801 802 if (lam != ret) 803 return 1; 804 805 return 0; 806 } 807 static void run_test(struct testcases *test, int count) 808 { 809 int i, ret = 0; 810 811 for (i = 0; i < count; i++) { 812 struct testcases *t = test + i; 813 814 /* fork a process to run test case */ 815 tests_cnt++; 816 ret = fork_test(t); 817 818 /* return 3 is not support LA57, the case should be skipped */ 819 if (ret == 3) { 820 ksft_test_result_skip(t->msg); 821 continue; 822 } 823 824 if (ret != 0) 825 ret = (t->expected == ret); 826 else 827 ret = !(t->expected); 828 829 ksft_test_result(ret, t->msg); 830 } 831 } 832 833 static struct testcases uring_cases[] = { 834 { 835 .later = 0, 836 .lam = LAM_U57_BITS, 837 .test_func = handle_uring, 838 .msg = "URING: LAM_U57. Dereferencing pointer with metadata\n", 839 }, 840 { 841 .later = 1, 842 .expected = 1, 843 .lam = LAM_U57_BITS, 844 .test_func = handle_uring, 845 .msg = "URING:[Negative] Disable LAM. Dereferencing pointer with metadata.\n", 846 }, 847 }; 848 849 static struct testcases malloc_cases[] = { 850 { 851 .later = 0, 852 .lam = LAM_U57_BITS, 853 .test_func = handle_malloc, 854 .msg = "MALLOC: LAM_U57. Dereferencing pointer with metadata\n", 855 }, 856 { 857 .later = 1, 858 .expected = 2, 859 .lam = LAM_U57_BITS, 860 .test_func = handle_malloc, 861 .msg = "MALLOC:[Negative] Disable LAM. Dereferencing pointer with metadata.\n", 862 }, 863 }; 864 865 static struct testcases bits_cases[] = { 866 { 867 .test_func = handle_max_bits, 868 .msg = "BITS: Check default tag bits\n", 869 }, 870 }; 871 872 static struct testcases syscall_cases[] = { 873 { 874 .later = 0, 875 .lam = LAM_U57_BITS, 876 .test_func = handle_syscall, 877 .msg = "SYSCALL: LAM_U57. syscall with metadata\n", 878 }, 879 { 880 .later = 1, 881 .expected = 1, 882 .lam = LAM_U57_BITS, 883 .test_func = handle_syscall, 884 .msg = "SYSCALL:[Negative] Disable LAM. Dereferencing pointer with metadata.\n", 885 }, 886 }; 887 888 static struct testcases mmap_cases[] = { 889 { 890 .later = 1, 891 .expected = 0, 892 .lam = LAM_U57_BITS, 893 .addr = HIGH_ADDR, 894 .test_func = handle_mmap, 895 .msg = "MMAP: First mmap high address, then set LAM_U57.\n", 896 }, 897 { 898 .later = 0, 899 .expected = 0, 900 .lam = LAM_U57_BITS, 901 .addr = HIGH_ADDR, 902 .test_func = handle_mmap, 903 .msg = "MMAP: First LAM_U57, then High address.\n", 904 }, 905 { 906 .later = 0, 907 .expected = 0, 908 .lam = LAM_U57_BITS, 909 .addr = LOW_ADDR, 910 .test_func = handle_mmap, 911 .msg = "MMAP: First LAM_U57, then Low address.\n", 912 }, 913 }; 914 915 static struct testcases inheritance_cases[] = { 916 { 917 .expected = 0, 918 .lam = LAM_U57_BITS, 919 .test_func = handle_inheritance, 920 .msg = "FORK: LAM_U57, child process should get LAM mode same as parent\n", 921 }, 922 { 923 .expected = 0, 924 .lam = LAM_U57_BITS, 925 .test_func = handle_thread, 926 .msg = "THREAD: LAM_U57, child thread should get LAM mode same as parent\n", 927 }, 928 { 929 .expected = 1, 930 .lam = LAM_U57_BITS, 931 .test_func = handle_thread_enable, 932 .msg = "THREAD: [NEGATIVE] Enable LAM in child.\n", 933 }, 934 { 935 .expected = 1, 936 .later = 1, 937 .lam = LAM_U57_BITS, 938 .test_func = handle_thread, 939 .msg = "THREAD: [NEGATIVE] Enable LAM in parent after thread created.\n", 940 }, 941 { 942 .expected = 0, 943 .lam = LAM_U57_BITS, 944 .test_func = handle_execve, 945 .msg = "EXECVE: LAM_U57, child process should get disabled LAM mode\n", 946 }, 947 }; 948 949 static void cmd_help(void) 950 { 951 printf("usage: lam [-h] [-t test list]\n"); 952 printf("\t-t test list: run tests specified in the test list, default:0x%x\n", TEST_MASK); 953 printf("\t\t0x1:malloc; 0x2:max_bits; 0x4:mmap; 0x8:syscall; 0x10:io_uring; 0x20:inherit;\n"); 954 printf("\t-h: help\n"); 955 } 956 957 /* Check for file existence */ 958 uint8_t file_Exists(const char *fileName) 959 { 960 struct stat buffer; 961 962 uint8_t ret = (stat(fileName, &buffer) == 0); 963 964 return ret; 965 } 966 967 /* Sysfs idxd files */ 968 const char *dsa_configs[] = { 969 "echo 1 > /sys/bus/dsa/devices/dsa0/wq0.1/group_id", 970 "echo shared > /sys/bus/dsa/devices/dsa0/wq0.1/mode", 971 "echo 10 > /sys/bus/dsa/devices/dsa0/wq0.1/priority", 972 "echo 16 > /sys/bus/dsa/devices/dsa0/wq0.1/size", 973 "echo 15 > /sys/bus/dsa/devices/dsa0/wq0.1/threshold", 974 "echo user > /sys/bus/dsa/devices/dsa0/wq0.1/type", 975 "echo MyApp1 > /sys/bus/dsa/devices/dsa0/wq0.1/name", 976 "echo 1 > /sys/bus/dsa/devices/dsa0/engine0.1/group_id", 977 "echo dsa0 > /sys/bus/dsa/drivers/idxd/bind", 978 /* bind files and devices, generated a device file in /dev */ 979 "echo wq0.1 > /sys/bus/dsa/drivers/user/bind", 980 }; 981 982 /* DSA device file */ 983 const char *dsaDeviceFile = "/dev/dsa/wq0.1"; 984 /* file for io*/ 985 const char *dsaPasidEnable = "/sys/bus/dsa/devices/dsa0/pasid_enabled"; 986 987 /* 988 * DSA depends on kernel cmdline "intel_iommu=on,sm_on" 989 * return pasid_enabled (0: disable 1:enable) 990 */ 991 int Check_DSA_Kernel_Setting(void) 992 { 993 char command[256] = ""; 994 char buf[256] = ""; 995 char *ptr; 996 int rv = -1; 997 998 snprintf(command, sizeof(command) - 1, "cat %s", dsaPasidEnable); 999 1000 FILE *cmd = popen(command, "r"); 1001 1002 if (cmd) { 1003 while (fgets(buf, sizeof(buf) - 1, cmd) != NULL); 1004 1005 pclose(cmd); 1006 rv = strtol(buf, &ptr, 16); 1007 } 1008 1009 return rv; 1010 } 1011 1012 /* 1013 * Config DSA's sysfs files as shared DSA's WQ. 1014 * Generated a device file /dev/dsa/wq0.1 1015 * Return: 0 OK; 1 Failed; 3 Skip(SVA disabled). 1016 */ 1017 int Dsa_Init_Sysfs(void) 1018 { 1019 uint len = ARRAY_SIZE(dsa_configs); 1020 const char **p = dsa_configs; 1021 1022 if (file_Exists(dsaDeviceFile) == 1) 1023 return 0; 1024 1025 /* check the idxd driver */ 1026 if (file_Exists(dsaPasidEnable) != 1) { 1027 printf("Please make sure idxd driver was loaded\n"); 1028 return 3; 1029 } 1030 1031 /* Check SVA feature */ 1032 if (Check_DSA_Kernel_Setting() != 1) { 1033 printf("Please enable SVA.(Add intel_iommu=on,sm_on in kernel cmdline)\n"); 1034 return 3; 1035 } 1036 1037 /* Check the idxd device file on /dev/dsa/ */ 1038 for (int i = 0; i < len; i++) { 1039 if (system(p[i])) 1040 return 1; 1041 } 1042 1043 /* After config, /dev/dsa/wq0.1 should be generated */ 1044 return (file_Exists(dsaDeviceFile) != 1); 1045 } 1046 1047 /* 1048 * Open DSA device file, triger API: iommu_sva_alloc_pasid 1049 */ 1050 void *allocate_dsa_pasid(void) 1051 { 1052 int fd; 1053 void *wq; 1054 1055 fd = open(dsaDeviceFile, O_RDWR); 1056 if (fd < 0) { 1057 perror("open"); 1058 return MAP_FAILED; 1059 } 1060 1061 wq = mmap(NULL, 0x1000, PROT_WRITE, 1062 MAP_SHARED | MAP_POPULATE, fd, 0); 1063 if (wq == MAP_FAILED) 1064 perror("mmap"); 1065 1066 return wq; 1067 } 1068 1069 int set_force_svm(void) 1070 { 1071 int ret = 0; 1072 1073 ret = syscall(SYS_arch_prctl, ARCH_FORCE_TAGGED_SVA); 1074 1075 return ret; 1076 } 1077 1078 int handle_pasid(struct testcases *test) 1079 { 1080 uint tmp = test->cmd; 1081 uint runed = 0x0; 1082 int ret = 0; 1083 void *wq = NULL; 1084 1085 ret = Dsa_Init_Sysfs(); 1086 if (ret != 0) 1087 return ret; 1088 1089 for (int i = 0; i < 3; i++) { 1090 int err = 0; 1091 1092 if (tmp & 0x1) { 1093 /* run set lam mode*/ 1094 if ((runed & 0x1) == 0) { 1095 err = set_lam(LAM_U57_BITS); 1096 runed = runed | 0x1; 1097 } else 1098 err = 1; 1099 } else if (tmp & 0x4) { 1100 /* run force svm */ 1101 if ((runed & 0x4) == 0) { 1102 err = set_force_svm(); 1103 runed = runed | 0x4; 1104 } else 1105 err = 1; 1106 } else if (tmp & 0x2) { 1107 /* run allocate pasid */ 1108 if ((runed & 0x2) == 0) { 1109 runed = runed | 0x2; 1110 wq = allocate_dsa_pasid(); 1111 if (wq == MAP_FAILED) 1112 err = 1; 1113 } else 1114 err = 1; 1115 } 1116 1117 ret = ret + err; 1118 if (ret > 0) 1119 break; 1120 1121 tmp = tmp >> 4; 1122 } 1123 1124 if (wq != MAP_FAILED && wq != NULL) 1125 if (munmap(wq, 0x1000)) 1126 printf("munmap failed %d\n", errno); 1127 1128 if (runed != 0x7) 1129 ret = 1; 1130 1131 return (ret != 0); 1132 } 1133 1134 /* 1135 * Pasid test depends on idxd and SVA, kernel should enable iommu and sm. 1136 * command line(intel_iommu=on,sm_on) 1137 */ 1138 static struct testcases pasid_cases[] = { 1139 { 1140 .expected = 1, 1141 .cmd = PAS_CMD(LAM_CMD_BIT, PAS_CMD_BIT, SVA_CMD_BIT), 1142 .test_func = handle_pasid, 1143 .msg = "PASID: [Negative] Execute LAM, PASID, SVA in sequence\n", 1144 }, 1145 { 1146 .expected = 0, 1147 .cmd = PAS_CMD(LAM_CMD_BIT, SVA_CMD_BIT, PAS_CMD_BIT), 1148 .test_func = handle_pasid, 1149 .msg = "PASID: Execute LAM, SVA, PASID in sequence\n", 1150 }, 1151 { 1152 .expected = 1, 1153 .cmd = PAS_CMD(PAS_CMD_BIT, LAM_CMD_BIT, SVA_CMD_BIT), 1154 .test_func = handle_pasid, 1155 .msg = "PASID: [Negative] Execute PASID, LAM, SVA in sequence\n", 1156 }, 1157 { 1158 .expected = 0, 1159 .cmd = PAS_CMD(PAS_CMD_BIT, SVA_CMD_BIT, LAM_CMD_BIT), 1160 .test_func = handle_pasid, 1161 .msg = "PASID: Execute PASID, SVA, LAM in sequence\n", 1162 }, 1163 { 1164 .expected = 0, 1165 .cmd = PAS_CMD(SVA_CMD_BIT, LAM_CMD_BIT, PAS_CMD_BIT), 1166 .test_func = handle_pasid, 1167 .msg = "PASID: Execute SVA, LAM, PASID in sequence\n", 1168 }, 1169 { 1170 .expected = 0, 1171 .cmd = PAS_CMD(SVA_CMD_BIT, PAS_CMD_BIT, LAM_CMD_BIT), 1172 .test_func = handle_pasid, 1173 .msg = "PASID: Execute SVA, PASID, LAM in sequence\n", 1174 }, 1175 }; 1176 1177 int main(int argc, char **argv) 1178 { 1179 int c = 0; 1180 unsigned int tests = TEST_MASK; 1181 1182 tests_cnt = 0; 1183 1184 if (!cpu_has_lam()) { 1185 ksft_print_msg("Unsupported LAM feature!\n"); 1186 return -1; 1187 } 1188 1189 while ((c = getopt(argc, argv, "ht:")) != -1) { 1190 switch (c) { 1191 case 't': 1192 tests = strtoul(optarg, NULL, 16); 1193 if (tests && !(tests & TEST_MASK)) { 1194 ksft_print_msg("Invalid argument!\n"); 1195 return -1; 1196 } 1197 break; 1198 case 'h': 1199 cmd_help(); 1200 return 0; 1201 default: 1202 ksft_print_msg("Invalid argument\n"); 1203 return -1; 1204 } 1205 } 1206 1207 /* 1208 * When tests is 0, it is not a real test case; 1209 * the option used by test case(execve) to check the lam mode in 1210 * process generated by execve, the process read back lam mode and 1211 * check with lam mode in parent process. 1212 */ 1213 if (!tests) 1214 return (get_lam()); 1215 1216 /* Run test cases */ 1217 if (tests & FUNC_MALLOC) 1218 run_test(malloc_cases, ARRAY_SIZE(malloc_cases)); 1219 1220 if (tests & FUNC_BITS) 1221 run_test(bits_cases, ARRAY_SIZE(bits_cases)); 1222 1223 if (tests & FUNC_MMAP) 1224 run_test(mmap_cases, ARRAY_SIZE(mmap_cases)); 1225 1226 if (tests & FUNC_SYSCALL) 1227 run_test(syscall_cases, ARRAY_SIZE(syscall_cases)); 1228 1229 if (tests & FUNC_URING) 1230 run_test(uring_cases, ARRAY_SIZE(uring_cases)); 1231 1232 if (tests & FUNC_INHERITE) 1233 run_test(inheritance_cases, ARRAY_SIZE(inheritance_cases)); 1234 1235 if (tests & FUNC_PASID) 1236 run_test(pasid_cases, ARRAY_SIZE(pasid_cases)); 1237 1238 ksft_set_plan(tests_cnt); 1239 1240 return ksft_exit_pass(); 1241 } 1242