1/* 2 * Copyright 2014 Advanced Micro Devices, Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 * 22*/ 23 24#include <string.h> 25#include <stdio.h> 26#include <stdlib.h> 27#include <unistd.h> 28#include <string.h> 29#include <ctype.h> 30#include <fcntl.h> 31#include <errno.h> 32#include <signal.h> 33#include <time.h> 34#include <sys/types.h> 35#include <sys/stat.h> 36#include <sys/ioctl.h> 37#include <sys/time.h> 38#include <stdarg.h> 39#include <stdint.h> 40#ifdef __linux__ 41#include <linux/limits.h> 42#elif __FreeBSD__ 43/* SPECNAMELEN in FreeBSD is defined here: */ 44#include <sys/param.h> 45#endif 46#ifdef MAJOR_IN_MKDEV 47#include <sys/mkdev.h> 48#endif 49#ifdef MAJOR_IN_SYSMACROS 50#include <sys/sysmacros.h> 51#endif 52 53#include "drm.h" 54#include "xf86drmMode.h" 55#include "xf86drm.h" 56 57#include "CUnit/Basic.h" 58 59#include "amdgpu_test.h" 60#include "amdgpu_internal.h" 61 62/* Test suite names */ 63#define BASIC_TESTS_STR "Basic Tests" 64#define BO_TESTS_STR "BO Tests" 65#define CS_TESTS_STR "CS Tests" 66#define VCE_TESTS_STR "VCE Tests" 67#define VCN_TESTS_STR "VCN Tests" 68#define JPEG_TESTS_STR "JPEG Tests" 69#define UVD_ENC_TESTS_STR "UVD ENC Tests" 70#define DEADLOCK_TESTS_STR "Deadlock Tests" 71#define VM_TESTS_STR "VM Tests" 72#define RAS_TESTS_STR "RAS Tests" 73#define SYNCOBJ_TIMELINE_TESTS_STR "SYNCOBJ TIMELINE Tests" 74#define SECURITY_TESTS_STR "Security Tests" 75#define HOTUNPLUG_TESTS_STR "Hotunplug Tests" 76#define CP_DMA_TESTS_STR "CP DMA Tests" 77 78/** 79 * Open handles for amdgpu devices 80 * 81 */ 82int drm_amdgpu[MAX_CARDS_SUPPORTED]; 83 84/** Open render node to test */ 85int open_render_node = 0; /* By default run most tests on primary node */ 86 87/** The table of all known test suites to run */ 88static CU_SuiteInfo suites[] = { 89 { 90 .pName = BASIC_TESTS_STR, 91 .pInitFunc = suite_basic_tests_init, 92 .pCleanupFunc = suite_basic_tests_clean, 93 .pTests = basic_tests, 94 }, 95 { 96 .pName = BO_TESTS_STR, 97 .pInitFunc = suite_bo_tests_init, 98 .pCleanupFunc = suite_bo_tests_clean, 99 .pTests = bo_tests, 100 }, 101 { 102 .pName = CS_TESTS_STR, 103 .pInitFunc = suite_cs_tests_init, 104 .pCleanupFunc = suite_cs_tests_clean, 105 .pTests = cs_tests, 106 }, 107 { 108 .pName = VCE_TESTS_STR, 109 .pInitFunc = suite_vce_tests_init, 110 .pCleanupFunc = suite_vce_tests_clean, 111 .pTests = vce_tests, 112 }, 113 { 114 .pName = VCN_TESTS_STR, 115 .pInitFunc = suite_vcn_tests_init, 116 .pCleanupFunc = suite_vcn_tests_clean, 117 .pTests = vcn_tests, 118 }, 119 { 120 .pName = JPEG_TESTS_STR, 121 .pInitFunc = suite_jpeg_tests_init, 122 .pCleanupFunc = suite_jpeg_tests_clean, 123 .pTests = jpeg_tests, 124 }, 125 { 126 .pName = UVD_ENC_TESTS_STR, 127 .pInitFunc = suite_uvd_enc_tests_init, 128 .pCleanupFunc = suite_uvd_enc_tests_clean, 129 .pTests = uvd_enc_tests, 130 }, 131 { 132 .pName = DEADLOCK_TESTS_STR, 133 .pInitFunc = suite_deadlock_tests_init, 134 .pCleanupFunc = suite_deadlock_tests_clean, 135 .pTests = deadlock_tests, 136 }, 137 { 138 .pName = VM_TESTS_STR, 139 .pInitFunc = suite_vm_tests_init, 140 .pCleanupFunc = suite_vm_tests_clean, 141 .pTests = vm_tests, 142 }, 143 { 144 .pName = RAS_TESTS_STR, 145 .pInitFunc = suite_ras_tests_init, 146 .pCleanupFunc = suite_ras_tests_clean, 147 .pTests = ras_tests, 148 }, 149 { 150 .pName = SYNCOBJ_TIMELINE_TESTS_STR, 151 .pInitFunc = suite_syncobj_timeline_tests_init, 152 .pCleanupFunc = suite_syncobj_timeline_tests_clean, 153 .pTests = syncobj_timeline_tests, 154 }, 155 { 156 .pName = SECURITY_TESTS_STR, 157 .pInitFunc = suite_security_tests_init, 158 .pCleanupFunc = suite_security_tests_clean, 159 .pTests = security_tests, 160 }, 161 { 162 .pName = HOTUNPLUG_TESTS_STR, 163 .pInitFunc = suite_hotunplug_tests_init, 164 .pCleanupFunc = suite_hotunplug_tests_clean, 165 .pTests = hotunplug_tests, 166 }, 167 { 168 .pName = CP_DMA_TESTS_STR, 169 .pInitFunc = suite_cp_dma_tests_init, 170 .pCleanupFunc = suite_cp_dma_tests_clean, 171 .pTests = cp_dma_tests, 172 }, 173 174 CU_SUITE_INFO_NULL, 175}; 176 177typedef CU_BOOL (*active__stat_func)(void); 178 179typedef struct Suites_Active_Status { 180 char* pName; 181 active__stat_func pActive; 182}Suites_Active_Status; 183 184static CU_BOOL always_active() 185{ 186 return CU_TRUE; 187} 188 189static Suites_Active_Status suites_active_stat[] = { 190 { 191 .pName = BASIC_TESTS_STR, 192 .pActive = suite_basic_tests_enable, 193 }, 194 { 195 .pName = BO_TESTS_STR, 196 .pActive = always_active, 197 }, 198 { 199 .pName = CS_TESTS_STR, 200 .pActive = suite_cs_tests_enable, 201 }, 202 { 203 .pName = VCE_TESTS_STR, 204 .pActive = suite_vce_tests_enable, 205 }, 206 { 207 .pName = VCN_TESTS_STR, 208 .pActive = suite_vcn_tests_enable, 209 }, 210 { 211 .pName = JPEG_TESTS_STR, 212 .pActive = suite_jpeg_tests_enable, 213 }, 214 { 215 .pName = UVD_ENC_TESTS_STR, 216 .pActive = suite_uvd_enc_tests_enable, 217 }, 218 { 219 .pName = DEADLOCK_TESTS_STR, 220 .pActive = suite_deadlock_tests_enable, 221 }, 222 { 223 .pName = VM_TESTS_STR, 224 .pActive = suite_vm_tests_enable, 225 }, 226 { 227 .pName = RAS_TESTS_STR, 228 .pActive = suite_ras_tests_enable, 229 }, 230 { 231 .pName = SYNCOBJ_TIMELINE_TESTS_STR, 232 .pActive = suite_syncobj_timeline_tests_enable, 233 }, 234 { 235 .pName = SECURITY_TESTS_STR, 236 .pActive = suite_security_tests_enable, 237 }, 238 { 239 .pName = HOTUNPLUG_TESTS_STR, 240 .pActive = suite_hotunplug_tests_enable, 241 }, 242 { 243 .pName = CP_DMA_TESTS_STR, 244 .pActive = suite_cp_dma_tests_enable, 245 }, 246}; 247 248 249/* 250 * Display information about all suites and their tests 251 * 252 * NOTE: Must be run after registry is initialized and suites registered. 253 */ 254static void display_test_suites(void) 255{ 256 int iSuite; 257 int iTest; 258 CU_pSuite pSuite = NULL; 259 CU_pTest pTest = NULL; 260 261 printf("%5s: %2s: %8s: %s\n", "What", "ID", "Status", "Name"); 262 263 for (iSuite = 0; suites[iSuite].pName != NULL; iSuite++) { 264 265 pSuite = CU_get_suite_by_index((unsigned int) iSuite + 1, 266 CU_get_registry()); 267 268 if (!pSuite) { 269 fprintf(stderr, "Invalid suite id : %d\n", iSuite + 1); 270 continue; 271 } 272 273 printf("Suite: %2d: %8s: %s\n", 274 iSuite + 1, 275 pSuite->fActive ? "ENABLED" : "DISABLED", 276 suites[iSuite].pName); 277 278 if (!pSuite->fActive) 279 continue; 280 281 for (iTest = 0; suites[iSuite].pTests[iTest].pName != NULL; 282 iTest++) { 283 pTest = CU_get_test_by_index((unsigned int) iTest + 1, 284 pSuite); 285 if (!pTest) { 286 fprintf(stderr, "Invalid test id : %d\n", iTest + 1); 287 continue; 288 } 289 printf(" Test: %2d: %8s: %s\n", 290 iTest + 1, 291 pSuite->fActive && pTest->fActive ? "ENABLED" : "DISABLED", 292 suites[iSuite].pTests[iTest].pName); 293 } 294 } 295} 296 297/** Help string for command line parameters */ 298static const char usage[] = 299 "Usage: %s [-hlpr] [<-s <suite id>> [-t <test id>] [-f]] " 300 "[-b <pci_bus_id> [-d <pci_device_id>]]\n" 301 "where:\n" 302 " l - Display all suites and their tests\n" 303 " r - Run the tests on render node\n" 304 " b - Specify device's PCI bus id to run tests\n" 305 " d - Specify device's PCI device id to run tests (optional)\n" 306 " p - Display information of AMDGPU devices in system\n" 307 " f - Force executing inactive suite or test\n" 308 " h - Display this help\n"; 309/** Specified options strings for getopt */ 310static const char options[] = "hlrps:t:b:d:f"; 311 312/* Open AMD devices. 313 * Return the number of AMD device opened. 314 */ 315static int amdgpu_open_devices(int open_render_node) 316{ 317 drmDevicePtr devices[MAX_CARDS_SUPPORTED]; 318 int i; 319 int drm_node; 320 int amd_index = 0; 321 int drm_count; 322 int fd; 323 drmVersionPtr version; 324 325 for (i = 0; i < MAX_CARDS_SUPPORTED; i++) { 326 drm_amdgpu[i] = -1; 327 } 328 329 drm_count = drmGetDevices2(0, devices, MAX_CARDS_SUPPORTED); 330 331 if (drm_count < 0) { 332 fprintf(stderr, 333 "drmGetDevices2() returned an error %d\n", 334 drm_count); 335 return 0; 336 } 337 338 for (i = 0; i < drm_count; i++) { 339 /* If this is not PCI device, skip*/ 340 if (devices[i]->bustype != DRM_BUS_PCI) 341 continue; 342 343 /* If this is not AMD GPU vender ID, skip*/ 344 if (devices[i]->deviceinfo.pci->vendor_id != 0x1002) 345 continue; 346 347 if (open_render_node) 348 drm_node = DRM_NODE_RENDER; 349 else 350 drm_node = DRM_NODE_PRIMARY; 351 352 fd = -1; 353 if (devices[i]->available_nodes & 1 << drm_node) 354 fd = open( 355 devices[i]->nodes[drm_node], 356 O_RDWR | O_CLOEXEC); 357 358 /* This node is not available. */ 359 if (fd < 0) continue; 360 361 version = drmGetVersion(fd); 362 if (!version) { 363 fprintf(stderr, 364 "Warning: Cannot get version for %s." 365 "Error is %s\n", 366 devices[i]->nodes[drm_node], 367 strerror(errno)); 368 close(fd); 369 continue; 370 } 371 372 if (strcmp(version->name, "amdgpu")) { 373 /* This is not AMDGPU driver, skip.*/ 374 drmFreeVersion(version); 375 close(fd); 376 continue; 377 } 378 379 drmFreeVersion(version); 380 381 drm_amdgpu[amd_index] = fd; 382 amd_index++; 383 } 384 385 drmFreeDevices(devices, drm_count); 386 return amd_index; 387} 388 389/* Close AMD devices. 390 */ 391void amdgpu_close_devices() 392{ 393 int i; 394 for (i = 0; i < MAX_CARDS_SUPPORTED; i++) 395 if (drm_amdgpu[i] >=0) { 396 close(drm_amdgpu[i]); 397 } 398} 399 400/* Print AMD devices information */ 401static void amdgpu_print_devices() 402{ 403 int i; 404 drmDevicePtr device; 405 406 /* Open the first AMD device to print driver information. */ 407 if (drm_amdgpu[0] >=0) { 408 /* Display AMD driver version information.*/ 409 drmVersionPtr retval = drmGetVersion(drm_amdgpu[0]); 410 411 if (retval == NULL) { 412 perror("Cannot get version for AMDGPU device"); 413 return; 414 } 415 416 printf("Driver name: %s, Date: %s, Description: %s.\n", 417 retval->name, retval->date, retval->desc); 418 drmFreeVersion(retval); 419 } 420 421 /* Display information of AMD devices */ 422 printf("Devices:\n"); 423 for (i = 0; i < MAX_CARDS_SUPPORTED && drm_amdgpu[i] >=0; i++) 424 if (drmGetDevice2(drm_amdgpu[i], 425 DRM_DEVICE_GET_PCI_REVISION, 426 &device) == 0) { 427 if (device->bustype == DRM_BUS_PCI) { 428 printf("PCI "); 429 printf(" domain:%04x", 430 device->businfo.pci->domain); 431 printf(" bus:%02x", 432 device->businfo.pci->bus); 433 printf(" device:%02x", 434 device->businfo.pci->dev); 435 printf(" function:%01x", 436 device->businfo.pci->func); 437 printf(" vendor_id:%04x", 438 device->deviceinfo.pci->vendor_id); 439 printf(" device_id:%04x", 440 device->deviceinfo.pci->device_id); 441 printf(" subvendor_id:%04x", 442 device->deviceinfo.pci->subvendor_id); 443 printf(" subdevice_id:%04x", 444 device->deviceinfo.pci->subdevice_id); 445 printf(" revision_id:%02x", 446 device->deviceinfo.pci->revision_id); 447 printf("\n"); 448 } 449 drmFreeDevice(&device); 450 } 451} 452 453/* Find a match AMD device in PCI bus 454 * Return the index of the device or -1 if not found 455 */ 456static int amdgpu_find_device(uint8_t bus, uint16_t dev) 457{ 458 int i; 459 drmDevicePtr device; 460 461 for (i = 0; i < MAX_CARDS_SUPPORTED && drm_amdgpu[i] >= 0; i++) { 462 if (drmGetDevice2(drm_amdgpu[i], 463 DRM_DEVICE_GET_PCI_REVISION, 464 &device) == 0) { 465 if (device->bustype == DRM_BUS_PCI) 466 if ((bus == 0xFF || device->businfo.pci->bus == bus) && 467 device->deviceinfo.pci->device_id == dev) { 468 drmFreeDevice(&device); 469 return i; 470 } 471 472 drmFreeDevice(&device); 473 } 474 } 475 476 return -1; 477} 478 479static void amdgpu_disable_suites() 480{ 481 amdgpu_device_handle device_handle; 482 uint32_t major_version, minor_version, family_id; 483 drmDevicePtr devices[MAX_CARDS_SUPPORTED]; 484 int i, drm_count; 485 int size = sizeof(suites_active_stat) / sizeof(suites_active_stat[0]); 486 487 if (amdgpu_device_initialize(drm_amdgpu[0], &major_version, 488 &minor_version, &device_handle)) 489 return; 490 491 family_id = device_handle->info.family_id; 492 493 if (amdgpu_device_deinitialize(device_handle)) 494 return; 495 496 drm_count = drmGetDevices2(0, devices, MAX_CARDS_SUPPORTED); 497 498 /* Set active status for suites based on their policies */ 499 for (i = 0; i < size; ++i) 500 if (amdgpu_set_suite_active(suites_active_stat[i].pName, 501 suites_active_stat[i].pActive())) 502 fprintf(stderr, "suite deactivation failed - %s\n", CU_get_error_msg()); 503 504 /* Explicitly disable specific tests due to known bugs or preferences */ 505 /* 506 * BUG: Compute ring stalls and never recovers when the address is 507 * written after the command already submitted 508 */ 509 if (amdgpu_set_test_active(DEADLOCK_TESTS_STR, 510 "compute ring block test (set amdgpu.lockup_timeout=50)", CU_FALSE)) 511 fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); 512 513 if (amdgpu_set_test_active(DEADLOCK_TESTS_STR, 514 "sdma ring block test (set amdgpu.lockup_timeout=50)", CU_FALSE)) 515 fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); 516 517 /* This test was ran on GFX9 only */ 518 //if (family_id < AMDGPU_FAMILY_AI || family_id > AMDGPU_FAMILY_RV) 519 if (amdgpu_set_test_active(DEADLOCK_TESTS_STR, 520 "gfx ring bad dispatch test (set amdgpu.lockup_timeout=50)", CU_FALSE)) 521 fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); 522 523 /* This test was ran on GFX9 only */ 524 //if (family_id < AMDGPU_FAMILY_AI || family_id > AMDGPU_FAMILY_RV) 525 if (amdgpu_set_test_active(DEADLOCK_TESTS_STR, 526 "compute ring bad dispatch test (set amdgpu.lockup_timeout=50,50)", CU_FALSE)) 527 fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); 528 529 /* This test was ran on GFX9 only */ 530 //if (family_id < AMDGPU_FAMILY_AI || family_id > AMDGPU_FAMILY_RV) 531 if (amdgpu_set_test_active(DEADLOCK_TESTS_STR, 532 "gfx ring bad slow dispatch test (set amdgpu.lockup_timeout=50)", CU_FALSE)) 533 fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); 534 535 /* This test was ran on GFX9 only */ 536 //if (family_id < AMDGPU_FAMILY_AI || family_id > AMDGPU_FAMILY_RV) 537 if (amdgpu_set_test_active(DEADLOCK_TESTS_STR, 538 "compute ring bad slow dispatch test (set amdgpu.lockup_timeout=50,50)", CU_FALSE)) 539 fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); 540 541 //if (family_id < AMDGPU_FAMILY_AI || family_id > AMDGPU_FAMILY_RV) 542 if (amdgpu_set_test_active(DEADLOCK_TESTS_STR, 543 "gfx ring bad draw test (set amdgpu.lockup_timeout=50)", CU_FALSE)) 544 fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); 545 546 /* This test was ran on GFX9 only */ 547 //if (family_id < AMDGPU_FAMILY_AI || family_id > AMDGPU_FAMILY_RV) 548 if (amdgpu_set_test_active(DEADLOCK_TESTS_STR, 549 "gfx ring slow bad draw test (set amdgpu.lockup_timeout=50)", CU_FALSE)) 550 fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); 551 552 if (amdgpu_set_test_active(BASIC_TESTS_STR, "bo eviction Test", CU_FALSE)) 553 fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); 554 555 /* This test was ran on GFX8 and GFX9 only */ 556 if (family_id < AMDGPU_FAMILY_VI || family_id > AMDGPU_FAMILY_RV) 557 if (amdgpu_set_test_active(BASIC_TESTS_STR, "Sync dependency Test", CU_FALSE)) 558 fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); 559 560 /* This test was ran on GFX9 only */ 561 if (family_id < AMDGPU_FAMILY_AI || family_id > AMDGPU_FAMILY_RV) { 562 if (amdgpu_set_test_active(BASIC_TESTS_STR, "Dispatch Test (GFX)", CU_FALSE)) 563 fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); 564 if (amdgpu_set_test_active(BASIC_TESTS_STR, "Dispatch Test (Compute)", CU_FALSE)) 565 fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); 566 } 567 568 /* This test was ran on GFX9 only */ 569 if (family_id < AMDGPU_FAMILY_AI || family_id > AMDGPU_FAMILY_RV) 570 if (amdgpu_set_test_active(BASIC_TESTS_STR, "Draw Test", CU_FALSE)) 571 fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); 572 573 /* This test was ran on GFX9 only */ 574 //if (family_id < AMDGPU_FAMILY_AI || family_id > AMDGPU_FAMILY_RV) 575 if (amdgpu_set_test_active(BASIC_TESTS_STR, "GPU reset Test", CU_FALSE)) 576 fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); 577 578 /* You need at least 2 devices for this */ 579 if (drm_count < 2) 580 if (amdgpu_set_test_active(HOTUNPLUG_TESTS_STR, "Unplug with exported fence", CU_FALSE)) 581 fprintf(stderr, "test deactivation failed - %s\n", CU_get_error_msg()); 582} 583 584int test_device_index; 585 586int amdgpu_open_device_on_test_index(int render_node) 587{ 588 int i; 589 590 if (amdgpu_open_devices(open_render_node) <= 0) { 591 perror("Cannot open AMDGPU device"); 592 return -1; 593 } 594 595 if (test_device_index >= 0) { 596 /* Most tests run on device of drm_amdgpu[0]. 597 * Swap the chosen device to drm_amdgpu[0]. 598 */ 599 i = drm_amdgpu[0]; 600 drm_amdgpu[0] = drm_amdgpu[test_device_index]; 601 drm_amdgpu[test_device_index] = i; 602 } 603 604 return 0; 605 606 607} 608 609 610static bool amdgpu_node_is_drm(int maj, int min) 611{ 612#ifdef __linux__ 613 char path[64]; 614 struct stat sbuf; 615 616 snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device/drm", 617 maj, min); 618 return stat(path, &sbuf) == 0; 619#elif defined(__FreeBSD__) 620 char name[SPECNAMELEN]; 621 622 if (!devname_r(makedev(maj, min), S_IFCHR, name, sizeof(name))) 623 return 0; 624 /* Handle drm/ and dri/ as both are present in different FreeBSD version 625 * FreeBSD on amd64/i386/powerpc external kernel modules create node in 626 * in /dev/drm/ and links in /dev/dri while a WIP in kernel driver creates 627 * only device nodes in /dev/dri/ */ 628 return (!strncmp(name, "drm/", 4) || !strncmp(name, "dri/", 4)); 629#else 630 return maj == DRM_MAJOR; 631#endif 632} 633 634char *amdgpu_get_device_from_fd(int fd) 635{ 636#ifdef __linux__ 637 struct stat sbuf; 638 char path[PATH_MAX + 1]; 639 unsigned int maj, min; 640 641 if (fstat(fd, &sbuf)) 642 return NULL; 643 644 maj = major(sbuf.st_rdev); 645 min = minor(sbuf.st_rdev); 646 647 if (!amdgpu_node_is_drm(maj, min) || !S_ISCHR(sbuf.st_mode)) 648 return NULL; 649 650 snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device", maj, min); 651 return strdup(path); 652#else 653 return NULL; 654#endif 655} 656 657/* The main() function for setting up and running the tests. 658 * Returns a CUE_SUCCESS on successful running, another 659 * CUnit error code on failure. 660 */ 661int main(int argc, char **argv) 662{ 663 int c; /* Character received from getopt */ 664 int i = 0; 665 int suite_id = -1; /* By default run everything */ 666 int test_id = -1; /* By default run all tests in the suite */ 667 int pci_bus_id = -1; /* By default PC bus ID is not specified */ 668 int pci_device_id = 0; /* By default PC device ID is zero */ 669 int display_devices = 0;/* By default not to display devices' info */ 670 CU_pSuite pSuite = NULL; 671 CU_pTest pTest = NULL; 672 int display_list = 0; 673 int force_run = 0; 674 675 for (i = 0; i < MAX_CARDS_SUPPORTED; i++) 676 drm_amdgpu[i] = -1; 677 678 679 /* Parse command line string */ 680 opterr = 0; /* Do not print error messages from getopt */ 681 while ((c = getopt(argc, argv, options)) != -1) { 682 switch (c) { 683 case 'l': 684 display_list = 1; 685 break; 686 case 's': 687 suite_id = atoi(optarg); 688 break; 689 case 't': 690 test_id = atoi(optarg); 691 break; 692 case 'b': 693 pci_bus_id = atoi(optarg); 694 break; 695 case 'd': 696 sscanf(optarg, "%x", &pci_device_id); 697 break; 698 case 'p': 699 display_devices = 1; 700 break; 701 case 'r': 702 open_render_node = 1; 703 break; 704 case 'f': 705 force_run = 1; 706 break; 707 case '?': 708 case 'h': 709 fprintf(stderr, usage, argv[0]); 710 exit(EXIT_SUCCESS); 711 default: 712 fprintf(stderr, usage, argv[0]); 713 exit(EXIT_FAILURE); 714 } 715 } 716 717 if (amdgpu_open_devices(open_render_node) <= 0) { 718 perror("Cannot open AMDGPU device"); 719 exit(EXIT_FAILURE); 720 } 721 722 if (drm_amdgpu[0] < 0) { 723 perror("Cannot open AMDGPU device"); 724 exit(EXIT_FAILURE); 725 } 726 727 if (display_devices) { 728 amdgpu_print_devices(); 729 amdgpu_close_devices(); 730 exit(EXIT_SUCCESS); 731 } 732 733 if (pci_bus_id > 0 || pci_device_id) { 734 /* A device was specified to run the test */ 735 test_device_index = amdgpu_find_device(pci_bus_id, 736 pci_device_id); 737 738 if (test_device_index >= 0) { 739 /* Most tests run on device of drm_amdgpu[0]. 740 * Swap the chosen device to drm_amdgpu[0]. 741 */ 742 i = drm_amdgpu[0]; 743 drm_amdgpu[0] = drm_amdgpu[test_device_index]; 744 drm_amdgpu[test_device_index] = i; 745 } else { 746 fprintf(stderr, 747 "The specified GPU device does not exist.\n"); 748 exit(EXIT_FAILURE); 749 } 750 } 751 752 /* Initialize test suites to run */ 753 754 /* initialize the CUnit test registry */ 755 if (CUE_SUCCESS != CU_initialize_registry()) { 756 amdgpu_close_devices(); 757 return CU_get_error(); 758 } 759 760 /* Register suites. */ 761 if (CU_register_suites(suites) != CUE_SUCCESS) { 762 fprintf(stderr, "suite registration failed - %s\n", 763 CU_get_error_msg()); 764 CU_cleanup_registry(); 765 amdgpu_close_devices(); 766 exit(EXIT_FAILURE); 767 } 768 769 /* Run tests using the CUnit Basic interface */ 770 CU_basic_set_mode(CU_BRM_VERBOSE); 771 772 /* Disable suites and individual tests based on misc. conditions */ 773 amdgpu_disable_suites(); 774 775 if (display_list) { 776 display_test_suites(); 777 goto end; 778 } 779 780 if (suite_id != -1) { /* If user specify particular suite? */ 781 pSuite = CU_get_suite_by_index((unsigned int) suite_id, 782 CU_get_registry()); 783 784 if (pSuite) { 785 786 if (force_run) 787 CU_set_suite_active(pSuite, CU_TRUE); 788 789 if (test_id != -1) { /* If user specify test id */ 790 pTest = CU_get_test_by_index( 791 (unsigned int) test_id, 792 pSuite); 793 if (pTest) { 794 if (force_run) 795 CU_set_test_active(pTest, CU_TRUE); 796 797 CU_basic_run_test(pSuite, pTest); 798 } 799 else { 800 fprintf(stderr, "Invalid test id: %d\n", 801 test_id); 802 CU_cleanup_registry(); 803 amdgpu_close_devices(); 804 exit(EXIT_FAILURE); 805 } 806 } else 807 CU_basic_run_suite(pSuite); 808 } else { 809 fprintf(stderr, "Invalid suite id : %d\n", 810 suite_id); 811 CU_cleanup_registry(); 812 amdgpu_close_devices(); 813 exit(EXIT_FAILURE); 814 } 815 } else 816 CU_basic_run_tests(); 817 818end: 819 CU_cleanup_registry(); 820 amdgpu_close_devices(); 821 return CU_get_error(); 822} 823