1 /* 2 * Test the powerpc alignment handler on POWER8/POWER9 3 * 4 * Copyright (C) 2017 IBM Corporation (Michael Neuling, Andrew Donnellan) 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 */ 11 12 /* 13 * This selftest exercises the powerpc alignment fault handler. 14 * 15 * We create two sets of source and destination buffers, one in regular memory, 16 * the other cache-inhibited (we use /dev/fb0 for this). 17 * 18 * We initialise the source buffers, then use whichever set of load/store 19 * instructions is under test to copy bytes from the source buffers to the 20 * destination buffers. For the regular buffers, these instructions will 21 * execute normally. For the cache-inhibited buffers, these instructions 22 * will trap and cause an alignment fault, and the alignment fault handler 23 * will emulate the particular instruction under test. We then compare the 24 * destination buffers to ensure that the native and emulated cases give the 25 * same result. 26 * 27 * TODO: 28 * - Any FIXMEs below 29 * - Test VSX regs < 32 and > 32 30 * - Test all loads and stores 31 * - Check update forms do update register 32 * - Test alignment faults over page boundary 33 * 34 * Some old binutils may not support all the instructions. 35 */ 36 37 38 #include <sys/mman.h> 39 #include <sys/types.h> 40 #include <sys/stat.h> 41 #include <fcntl.h> 42 #include <unistd.h> 43 #include <stdbool.h> 44 #include <stdio.h> 45 #include <stdlib.h> 46 #include <string.h> 47 #include <assert.h> 48 #include <getopt.h> 49 #include <setjmp.h> 50 #include <signal.h> 51 52 #include "utils.h" 53 54 int bufsize; 55 int debug; 56 int testing; 57 volatile int gotsig; 58 59 void sighandler(int sig, siginfo_t *info, void *ctx) 60 { 61 ucontext_t *ucp = ctx; 62 63 if (!testing) { 64 signal(sig, SIG_DFL); 65 kill(0, sig); 66 } 67 gotsig = sig; 68 #ifdef __powerpc64__ 69 ucp->uc_mcontext.gp_regs[PT_NIP] += 4; 70 #else 71 ucp->uc_mcontext.uc_regs->gregs[PT_NIP] += 4; 72 #endif 73 } 74 75 #define XFORM(reg, n) " " #reg " ,%"#n",%2 ;" 76 #define DFORM(reg, n) " " #reg " ,0(%"#n") ;" 77 78 #define TEST(name, ld_op, st_op, form, ld_reg, st_reg) \ 79 void test_##name(char *s, char *d) \ 80 { \ 81 asm volatile( \ 82 #ld_op form(ld_reg, 0) \ 83 #st_op form(st_reg, 1) \ 84 :: "r"(s), "r"(d), "r"(0) \ 85 : "memory", "vs0", "vs32", "r31"); \ 86 } \ 87 rc |= do_test(#name, test_##name) 88 89 #define LOAD_VSX_XFORM_TEST(op) TEST(op, op, stxvd2x, XFORM, 32, 32) 90 #define STORE_VSX_XFORM_TEST(op) TEST(op, lxvd2x, op, XFORM, 32, 32) 91 #define LOAD_VSX_DFORM_TEST(op) TEST(op, op, stxv, DFORM, 32, 32) 92 #define STORE_VSX_DFORM_TEST(op) TEST(op, lxv, op, DFORM, 32, 32) 93 #define LOAD_VMX_XFORM_TEST(op) TEST(op, op, stxvd2x, XFORM, 0, 32) 94 #define STORE_VMX_XFORM_TEST(op) TEST(op, lxvd2x, op, XFORM, 32, 0) 95 #define LOAD_VMX_DFORM_TEST(op) TEST(op, op, stxv, DFORM, 0, 32) 96 #define STORE_VMX_DFORM_TEST(op) TEST(op, lxv, op, DFORM, 32, 0) 97 98 #define LOAD_XFORM_TEST(op) TEST(op, op, stdx, XFORM, 31, 31) 99 #define STORE_XFORM_TEST(op) TEST(op, ldx, op, XFORM, 31, 31) 100 #define LOAD_DFORM_TEST(op) TEST(op, op, std, DFORM, 31, 31) 101 #define STORE_DFORM_TEST(op) TEST(op, ld, op, DFORM, 31, 31) 102 103 #define LOAD_FLOAT_DFORM_TEST(op) TEST(op, op, stfd, DFORM, 0, 0) 104 #define STORE_FLOAT_DFORM_TEST(op) TEST(op, lfd, op, DFORM, 0, 0) 105 #define LOAD_FLOAT_XFORM_TEST(op) TEST(op, op, stfdx, XFORM, 0, 0) 106 #define STORE_FLOAT_XFORM_TEST(op) TEST(op, lfdx, op, XFORM, 0, 0) 107 108 109 /* FIXME: Unimplemented tests: */ 110 // STORE_DFORM_TEST(stq) /* FIXME: need two registers for quad */ 111 // STORE_DFORM_TEST(stswi) /* FIXME: string instruction */ 112 113 // STORE_XFORM_TEST(stwat) /* AMO can't emulate or run on CI */ 114 // STORE_XFORM_TEST(stdat) /* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */ 115 116 117 /* preload byte by byte */ 118 void preload_data(void *dst, int offset, int width) 119 { 120 char *c = dst; 121 int i; 122 123 c += offset; 124 125 for (i = 0 ; i < width ; i++) 126 c[i] = i; 127 } 128 129 int test_memcpy(void *dst, void *src, int size, int offset, 130 void (*test_func)(char *, char *)) 131 { 132 char *s, *d; 133 134 s = src; 135 s += offset; 136 d = dst; 137 d += offset; 138 139 assert(size == 16); 140 gotsig = 0; 141 testing = 1; 142 143 test_func(s, d); /* run the actual test */ 144 145 testing = 0; 146 if (gotsig) { 147 if (debug) 148 printf(" Got signal %i\n", gotsig); 149 return 1; 150 } 151 return 0; 152 } 153 154 void dumpdata(char *s1, char *s2, int n, char *test_name) 155 { 156 int i; 157 158 printf(" %s: unexpected result:\n", test_name); 159 printf(" mem:"); 160 for (i = 0; i < n; i++) 161 printf(" %02x", s1[i]); 162 printf("\n"); 163 printf(" ci: "); 164 for (i = 0; i < n; i++) 165 printf(" %02x", s2[i]); 166 printf("\n"); 167 } 168 169 int test_memcmp(void *s1, void *s2, int n, int offset, char *test_name) 170 { 171 char *s1c, *s2c; 172 173 s1c = s1; 174 s1c += offset; 175 s2c = s2; 176 s2c += offset; 177 178 if (memcmp(s1c, s2c, n)) { 179 if (debug) { 180 printf("\n Compare failed. Offset:%i length:%i\n", 181 offset, n); 182 dumpdata(s1c, s2c, n, test_name); 183 } 184 return 1; 185 } 186 return 0; 187 } 188 189 /* 190 * Do two memcpy tests using the same instructions. One cachable 191 * memory and the other doesn't. 192 */ 193 int do_test(char *test_name, void (*test_func)(char *, char *)) 194 { 195 int offset, width, fd, rc, r; 196 void *mem0, *mem1, *ci0, *ci1; 197 198 printf("\tDoing %s:\t", test_name); 199 200 fd = open("/dev/fb0", O_RDWR); 201 if (fd < 0) { 202 printf("\n"); 203 perror("Can't open /dev/fb0 now?"); 204 return 1; 205 } 206 207 ci0 = mmap(NULL, bufsize, PROT_WRITE, MAP_SHARED, 208 fd, 0x0); 209 ci1 = mmap(NULL, bufsize, PROT_WRITE, MAP_SHARED, 210 fd, bufsize); 211 if ((ci0 == MAP_FAILED) || (ci1 == MAP_FAILED)) { 212 printf("\n"); 213 perror("mmap failed"); 214 SKIP_IF(1); 215 } 216 217 rc = posix_memalign(&mem0, bufsize, bufsize); 218 if (rc) { 219 printf("\n"); 220 return rc; 221 } 222 223 rc = posix_memalign(&mem1, bufsize, bufsize); 224 if (rc) { 225 printf("\n"); 226 free(mem0); 227 return rc; 228 } 229 230 rc = 0; 231 /* offset = 0 no alignment fault, so skip */ 232 for (offset = 1; offset < 16; offset++) { 233 width = 16; /* vsx == 16 bytes */ 234 r = 0; 235 236 /* load pattern into memory byte by byte */ 237 preload_data(ci0, offset, width); 238 preload_data(mem0, offset, width); // FIXME: remove?? 239 memcpy(ci0, mem0, bufsize); 240 memcpy(ci1, mem1, bufsize); /* initialise output to the same */ 241 242 /* sanity check */ 243 test_memcmp(mem0, ci0, width, offset, test_name); 244 245 r |= test_memcpy(ci1, ci0, width, offset, test_func); 246 r |= test_memcpy(mem1, mem0, width, offset, test_func); 247 if (r && !debug) { 248 printf("FAILED: Got signal"); 249 rc = 1; 250 break; 251 } 252 253 r |= test_memcmp(mem1, ci1, width, offset, test_name); 254 if (r && !debug) { 255 printf("FAILED: Wrong Data"); 256 rc = 1; 257 break; 258 } 259 } 260 261 if (rc == 0) 262 printf("PASSED"); 263 264 printf("\n"); 265 266 munmap(ci0, bufsize); 267 munmap(ci1, bufsize); 268 free(mem0); 269 free(mem1); 270 close(fd); 271 272 return rc; 273 } 274 275 static bool can_open_fb0(void) 276 { 277 int fd; 278 279 fd = open("/dev/fb0", O_RDWR); 280 if (fd < 0) 281 return false; 282 283 close(fd); 284 return true; 285 } 286 287 int test_alignment_handler_vsx_206(void) 288 { 289 int rc = 0; 290 291 SKIP_IF(!can_open_fb0()); 292 293 printf("VSX: 2.06B\n"); 294 LOAD_VSX_XFORM_TEST(lxvd2x); 295 LOAD_VSX_XFORM_TEST(lxvw4x); 296 LOAD_VSX_XFORM_TEST(lxsdx); 297 LOAD_VSX_XFORM_TEST(lxvdsx); 298 STORE_VSX_XFORM_TEST(stxvd2x); 299 STORE_VSX_XFORM_TEST(stxvw4x); 300 STORE_VSX_XFORM_TEST(stxsdx); 301 return rc; 302 } 303 304 int test_alignment_handler_vsx_207(void) 305 { 306 int rc = 0; 307 308 SKIP_IF(!can_open_fb0()); 309 310 printf("VSX: 2.07B\n"); 311 LOAD_VSX_XFORM_TEST(lxsspx); 312 LOAD_VSX_XFORM_TEST(lxsiwax); 313 LOAD_VSX_XFORM_TEST(lxsiwzx); 314 STORE_VSX_XFORM_TEST(stxsspx); 315 STORE_VSX_XFORM_TEST(stxsiwx); 316 return rc; 317 } 318 319 int test_alignment_handler_vsx_300(void) 320 { 321 int rc = 0; 322 323 SKIP_IF(!can_open_fb0()); 324 325 SKIP_IF(!have_hwcap2(PPC_FEATURE2_ARCH_3_00)); 326 printf("VSX: 3.00B\n"); 327 LOAD_VMX_DFORM_TEST(lxsd); 328 LOAD_VSX_XFORM_TEST(lxsibzx); 329 LOAD_VSX_XFORM_TEST(lxsihzx); 330 LOAD_VMX_DFORM_TEST(lxssp); 331 LOAD_VSX_DFORM_TEST(lxv); 332 LOAD_VSX_XFORM_TEST(lxvb16x); 333 LOAD_VSX_XFORM_TEST(lxvh8x); 334 LOAD_VSX_XFORM_TEST(lxvx); 335 LOAD_VSX_XFORM_TEST(lxvwsx); 336 LOAD_VSX_XFORM_TEST(lxvl); 337 LOAD_VSX_XFORM_TEST(lxvll); 338 STORE_VMX_DFORM_TEST(stxsd); 339 STORE_VSX_XFORM_TEST(stxsibx); 340 STORE_VSX_XFORM_TEST(stxsihx); 341 STORE_VMX_DFORM_TEST(stxssp); 342 STORE_VSX_DFORM_TEST(stxv); 343 STORE_VSX_XFORM_TEST(stxvb16x); 344 STORE_VSX_XFORM_TEST(stxvh8x); 345 STORE_VSX_XFORM_TEST(stxvx); 346 STORE_VSX_XFORM_TEST(stxvl); 347 STORE_VSX_XFORM_TEST(stxvll); 348 return rc; 349 } 350 351 int test_alignment_handler_integer(void) 352 { 353 int rc = 0; 354 355 SKIP_IF(!can_open_fb0()); 356 357 printf("Integer\n"); 358 LOAD_DFORM_TEST(lbz); 359 LOAD_DFORM_TEST(lbzu); 360 LOAD_XFORM_TEST(lbzx); 361 LOAD_XFORM_TEST(lbzux); 362 LOAD_DFORM_TEST(lhz); 363 LOAD_DFORM_TEST(lhzu); 364 LOAD_XFORM_TEST(lhzx); 365 LOAD_XFORM_TEST(lhzux); 366 LOAD_DFORM_TEST(lha); 367 LOAD_DFORM_TEST(lhau); 368 LOAD_XFORM_TEST(lhax); 369 LOAD_XFORM_TEST(lhaux); 370 LOAD_XFORM_TEST(lhbrx); 371 LOAD_DFORM_TEST(lwz); 372 LOAD_DFORM_TEST(lwzu); 373 LOAD_XFORM_TEST(lwzx); 374 LOAD_XFORM_TEST(lwzux); 375 LOAD_DFORM_TEST(lwa); 376 LOAD_XFORM_TEST(lwax); 377 LOAD_XFORM_TEST(lwaux); 378 LOAD_XFORM_TEST(lwbrx); 379 LOAD_DFORM_TEST(ld); 380 LOAD_DFORM_TEST(ldu); 381 LOAD_XFORM_TEST(ldx); 382 LOAD_XFORM_TEST(ldux); 383 LOAD_XFORM_TEST(ldbrx); 384 LOAD_DFORM_TEST(lmw); 385 STORE_DFORM_TEST(stb); 386 STORE_XFORM_TEST(stbx); 387 STORE_DFORM_TEST(stbu); 388 STORE_XFORM_TEST(stbux); 389 STORE_DFORM_TEST(sth); 390 STORE_XFORM_TEST(sthx); 391 STORE_DFORM_TEST(sthu); 392 STORE_XFORM_TEST(sthux); 393 STORE_XFORM_TEST(sthbrx); 394 STORE_DFORM_TEST(stw); 395 STORE_XFORM_TEST(stwx); 396 STORE_DFORM_TEST(stwu); 397 STORE_XFORM_TEST(stwux); 398 STORE_XFORM_TEST(stwbrx); 399 STORE_DFORM_TEST(std); 400 STORE_XFORM_TEST(stdx); 401 STORE_DFORM_TEST(stdu); 402 STORE_XFORM_TEST(stdux); 403 STORE_XFORM_TEST(stdbrx); 404 STORE_DFORM_TEST(stmw); 405 return rc; 406 } 407 408 int test_alignment_handler_vmx(void) 409 { 410 int rc = 0; 411 412 SKIP_IF(!can_open_fb0()); 413 414 printf("VMX\n"); 415 LOAD_VMX_XFORM_TEST(lvx); 416 417 /* 418 * FIXME: These loads only load part of the register, so our 419 * testing method doesn't work. Also they don't take alignment 420 * faults, so it's kinda pointless anyway 421 * 422 LOAD_VMX_XFORM_TEST(lvebx) 423 LOAD_VMX_XFORM_TEST(lvehx) 424 LOAD_VMX_XFORM_TEST(lvewx) 425 LOAD_VMX_XFORM_TEST(lvxl) 426 */ 427 STORE_VMX_XFORM_TEST(stvx); 428 STORE_VMX_XFORM_TEST(stvebx); 429 STORE_VMX_XFORM_TEST(stvehx); 430 STORE_VMX_XFORM_TEST(stvewx); 431 STORE_VMX_XFORM_TEST(stvxl); 432 return rc; 433 } 434 435 int test_alignment_handler_fp(void) 436 { 437 int rc = 0; 438 439 SKIP_IF(!can_open_fb0()); 440 441 printf("Floating point\n"); 442 LOAD_FLOAT_DFORM_TEST(lfd); 443 LOAD_FLOAT_XFORM_TEST(lfdx); 444 LOAD_FLOAT_DFORM_TEST(lfdp); 445 LOAD_FLOAT_XFORM_TEST(lfdpx); 446 LOAD_FLOAT_DFORM_TEST(lfdu); 447 LOAD_FLOAT_XFORM_TEST(lfdux); 448 LOAD_FLOAT_DFORM_TEST(lfs); 449 LOAD_FLOAT_XFORM_TEST(lfsx); 450 LOAD_FLOAT_DFORM_TEST(lfsu); 451 LOAD_FLOAT_XFORM_TEST(lfsux); 452 LOAD_FLOAT_XFORM_TEST(lfiwzx); 453 LOAD_FLOAT_XFORM_TEST(lfiwax); 454 STORE_FLOAT_DFORM_TEST(stfd); 455 STORE_FLOAT_XFORM_TEST(stfdx); 456 STORE_FLOAT_DFORM_TEST(stfdp); 457 STORE_FLOAT_XFORM_TEST(stfdpx); 458 STORE_FLOAT_DFORM_TEST(stfdu); 459 STORE_FLOAT_XFORM_TEST(stfdux); 460 STORE_FLOAT_DFORM_TEST(stfs); 461 STORE_FLOAT_XFORM_TEST(stfsx); 462 STORE_FLOAT_DFORM_TEST(stfsu); 463 STORE_FLOAT_XFORM_TEST(stfsux); 464 STORE_FLOAT_XFORM_TEST(stfiwx); 465 466 return rc; 467 } 468 469 void usage(char *prog) 470 { 471 printf("Usage: %s [options]\n", prog); 472 printf(" -d Enable debug error output\n"); 473 printf("\n"); 474 printf("This test requires a POWER8 or POWER9 CPU and a usable "); 475 printf("framebuffer at /dev/fb0.\n"); 476 } 477 478 int main(int argc, char *argv[]) 479 { 480 481 struct sigaction sa; 482 int rc = 0; 483 int option = 0; 484 485 while ((option = getopt(argc, argv, "d")) != -1) { 486 switch (option) { 487 case 'd': 488 debug++; 489 break; 490 default: 491 usage(argv[0]); 492 exit(1); 493 } 494 } 495 496 bufsize = getpagesize(); 497 498 sa.sa_sigaction = sighandler; 499 sigemptyset(&sa.sa_mask); 500 sa.sa_flags = SA_SIGINFO; 501 if (sigaction(SIGSEGV, &sa, NULL) == -1 502 || sigaction(SIGBUS, &sa, NULL) == -1 503 || sigaction(SIGILL, &sa, NULL) == -1) { 504 perror("sigaction"); 505 exit(1); 506 } 507 508 rc |= test_harness(test_alignment_handler_vsx_206, 509 "test_alignment_handler_vsx_206"); 510 rc |= test_harness(test_alignment_handler_vsx_207, 511 "test_alignment_handler_vsx_207"); 512 rc |= test_harness(test_alignment_handler_vsx_300, 513 "test_alignment_handler_vsx_300"); 514 rc |= test_harness(test_alignment_handler_integer, 515 "test_alignment_handler_integer"); 516 rc |= test_harness(test_alignment_handler_vmx, 517 "test_alignment_handler_vmx"); 518 rc |= test_harness(test_alignment_handler_fp, 519 "test_alignment_handler_fp"); 520 return rc; 521 } 522