1 /*- 2 * BSD LICENSE 3 * 4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. 5 * Copyright(c) 2014 6WIND S.A. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * * Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * * Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in 16 * the documentation and/or other materials provided with the 17 * distribution. 18 * * Neither the name of Intel Corporation nor the names of its 19 * contributors may be used to endorse or promote products derived 20 * from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 25 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 26 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 */ 34 #include <stdio.h> 35 36 #include "test.h" 37 38 #include <string.h> 39 #include <stdarg.h> 40 #include <libgen.h> 41 #include <stdio.h> 42 #include <stdlib.h> 43 #include <errno.h> 44 #include <unistd.h> 45 #include <dirent.h> 46 #include <sys/wait.h> 47 #include <sys/file.h> 48 #include <limits.h> 49 50 #include <rte_debug.h> 51 #include <rte_string_fns.h> 52 53 #include "process.h" 54 55 #ifdef RTE_LIBRTE_XEN_DOM0 56 #define DEFAULT_MEM_SIZE "30" 57 #else 58 #define DEFAULT_MEM_SIZE "18" 59 #endif 60 #define mp_flag "--proc-type=secondary" 61 #define no_hpet "--no-hpet" 62 #define no_huge "--no-huge" 63 #define no_shconf "--no-shconf" 64 #define pci_whitelist "--pci-whitelist" 65 #define vdev "--vdev" 66 #define memtest "memtest" 67 #define memtest1 "memtest1" 68 #define memtest2 "memtest2" 69 #define SOCKET_MEM_STRLEN (RTE_MAX_NUMA_NODES * 10) 70 #define launch_proc(ARGV) process_dup(ARGV, \ 71 sizeof(ARGV)/(sizeof(ARGV[0])), __func__) 72 73 enum hugepage_action { 74 HUGEPAGE_CHECK_EXISTS = 0, 75 HUGEPAGE_CHECK_LOCKED, 76 HUGEPAGE_DELETE, 77 HUGEPAGE_INVALID 78 }; 79 80 /* if string contains a hugepage path */ 81 static int 82 get_hugepage_path(char * src, int src_len, char * dst, int dst_len) 83 { 84 #define NUM_TOKENS 4 85 char *tokens[NUM_TOKENS]; 86 87 /* if we couldn't properly split the string */ 88 if (rte_strsplit(src, src_len, tokens, NUM_TOKENS, ' ') < NUM_TOKENS) 89 return 0; 90 91 if (strncmp(tokens[2], "hugetlbfs", sizeof("hugetlbfs")) == 0) { 92 snprintf(dst, dst_len, "%s", tokens[1]); 93 return 1; 94 } 95 return 0; 96 } 97 98 /* 99 * Cycles through hugepage directories and looks for hugepage 100 * files associated with a given prefix. Depending on value of 101 * action, the hugepages are checked if they exist, checked if 102 * they can be locked, or are simply deleted. 103 * 104 * Returns 1 if it finds at least one hugepage matching the action 105 * Returns 0 if no matching hugepages were found 106 * Returns -1 if it encounters an error 107 */ 108 static int 109 process_hugefiles(const char * prefix, enum hugepage_action action) 110 { 111 FILE * hugedir_handle = NULL; 112 DIR * hugepage_dir = NULL; 113 struct dirent *dirent = NULL; 114 115 char hugefile_prefix[PATH_MAX] = {0}; 116 char hugedir[PATH_MAX] = {0}; 117 char line[PATH_MAX] = {0}; 118 119 int fd, lck_result, result = 0; 120 121 const int prefix_len = snprintf(hugefile_prefix, 122 sizeof(hugefile_prefix), "%smap_", prefix); 123 if (prefix_len <= 0 || prefix_len >= (int)sizeof(hugefile_prefix) 124 || prefix_len >= (int)sizeof(dirent->d_name)) { 125 printf("Error creating hugefile filename prefix\n"); 126 return -1; 127 } 128 129 /* get hugetlbfs mountpoints from /proc/mounts */ 130 hugedir_handle = fopen("/proc/mounts", "r"); 131 132 if (hugedir_handle == NULL) { 133 printf("Error parsing /proc/mounts!\n"); 134 return -1; 135 } 136 137 /* read and parse script output */ 138 while (fgets(line, sizeof(line), hugedir_handle) != NULL) { 139 140 /* check if we have a hugepage filesystem path */ 141 if (!get_hugepage_path(line, sizeof(line), hugedir, sizeof(hugedir))) 142 continue; 143 144 /* check if directory exists */ 145 if ((hugepage_dir = opendir(hugedir)) == NULL) { 146 fclose(hugedir_handle); 147 printf("Error reading %s: %s\n", hugedir, strerror(errno)); 148 return -1; 149 } 150 151 while ((dirent = readdir(hugepage_dir)) != NULL) { 152 if (memcmp(dirent->d_name, hugefile_prefix, prefix_len) != 0) 153 continue; 154 155 switch (action) { 156 case HUGEPAGE_CHECK_EXISTS: 157 { 158 /* file exists, return */ 159 result = 1; 160 goto end; 161 } 162 break; 163 case HUGEPAGE_DELETE: 164 { 165 char file_path[PATH_MAX] = {0}; 166 167 snprintf(file_path, sizeof(file_path), 168 "%s/%s", hugedir, dirent->d_name); 169 170 /* remove file */ 171 if (remove(file_path) < 0) { 172 printf("Error deleting %s - %s!\n", 173 dirent->d_name, strerror(errno)); 174 closedir(hugepage_dir); 175 result = -1; 176 goto end; 177 } 178 result = 1; 179 } 180 break; 181 case HUGEPAGE_CHECK_LOCKED: 182 { 183 /* try and lock the file */ 184 fd = openat(dirfd(hugepage_dir), dirent->d_name, O_RDONLY); 185 186 /* this shouldn't happen */ 187 if (fd == -1) { 188 printf("Error opening %s - %s!\n", 189 dirent->d_name, strerror(errno)); 190 closedir(hugepage_dir); 191 result = -1; 192 goto end; 193 } 194 195 /* non-blocking lock */ 196 lck_result = flock(fd, LOCK_EX | LOCK_NB); 197 198 /* if lock succeeds, there's something wrong */ 199 if (lck_result != -1) { 200 result = 0; 201 202 /* unlock the resulting lock */ 203 flock(fd, LOCK_UN); 204 close(fd); 205 closedir(hugepage_dir); 206 goto end; 207 } 208 result = 1; 209 close(fd); 210 } 211 break; 212 /* shouldn't happen */ 213 default: 214 goto end; 215 } /* switch */ 216 217 } /* read hugepage directory */ 218 closedir(hugepage_dir); 219 } /* read /proc/mounts */ 220 end: 221 fclose(hugedir_handle); 222 return result; 223 } 224 225 #ifdef RTE_EXEC_ENV_LINUXAPP 226 /* 227 * count the number of "node*" files in /sys/devices/system/node/ 228 */ 229 static int 230 get_number_of_sockets(void) 231 { 232 struct dirent *dirent = NULL; 233 const char * nodedir = "/sys/devices/system/node/"; 234 DIR * dir = NULL; 235 int result = 0; 236 237 /* check if directory exists */ 238 if ((dir = opendir(nodedir)) == NULL) { 239 /* if errno==ENOENT this means we don't have NUMA support */ 240 if (errno == ENOENT) { 241 printf("No NUMA nodes detected: assuming 1 available socket\n"); 242 return 1; 243 } 244 printf("Error opening %s: %s\n", nodedir, strerror(errno)); 245 return -1; 246 } 247 248 while ((dirent = readdir(dir)) != NULL) 249 if (strncmp(dirent->d_name, "node", sizeof("node") - 1) == 0) 250 result++; 251 252 closedir(dir); 253 return result; 254 } 255 #endif 256 257 static char* 258 get_current_prefix(char * prefix, int size) 259 { 260 char path[PATH_MAX] = {0}; 261 char buf[PATH_MAX] = {0}; 262 263 /* get file for config (fd is always 3) */ 264 snprintf(path, sizeof(path), "/proc/self/fd/%d", 3); 265 266 /* return NULL on error */ 267 if (readlink(path, buf, sizeof(buf)) == -1) 268 return NULL; 269 270 /* get the basename */ 271 snprintf(buf, sizeof(buf), "%s", basename(buf)); 272 273 /* copy string all the way from second char up to start of _config */ 274 snprintf(prefix, size, "%.*s", 275 (int)(strnlen(buf, sizeof(buf)) - sizeof("_config")), 276 &buf[1]); 277 278 return prefix; 279 } 280 281 /* 282 * Test that the app doesn't run with invalid whitelist option. 283 * Final tests ensures it does run with valid options as sanity check (one 284 * test for with Domain+BDF, second for just with BDF) 285 */ 286 static int 287 test_whitelist_flag(void) 288 { 289 unsigned i; 290 #ifdef RTE_EXEC_ENV_BSDAPP 291 /* BSD target doesn't support prefixes at this point */ 292 const char * prefix = ""; 293 #else 294 char prefix[PATH_MAX], tmp[PATH_MAX]; 295 if (get_current_prefix(tmp, sizeof(tmp)) == NULL) { 296 printf("Error - unable to get current prefix!\n"); 297 return -1; 298 } 299 snprintf(prefix, sizeof(prefix), "--file-prefix=%s", tmp); 300 #endif 301 302 const char *wlinval[][11] = { 303 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", 304 pci_whitelist, "error", "", ""}, 305 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", 306 pci_whitelist, "0:0:0", "", ""}, 307 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", 308 pci_whitelist, "0:error:0.1", "", ""}, 309 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", 310 pci_whitelist, "0:0:0.1error", "", ""}, 311 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", 312 pci_whitelist, "error0:0:0.1", "", ""}, 313 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", 314 pci_whitelist, "0:0:0.1.2", "", ""}, 315 }; 316 /* Test with valid whitelist option */ 317 const char *wlval1[] = {prgname, prefix, mp_flag, "-n", "1", "-c", "1", 318 pci_whitelist, "00FF:09:0B.3"}; 319 const char *wlval2[] = {prgname, prefix, mp_flag, "-n", "1", "-c", "1", 320 pci_whitelist, "09:0B.3", pci_whitelist, "0a:0b.1"}; 321 const char *wlval3[] = {prgname, prefix, mp_flag, "-n", "1", "-c", "1", 322 pci_whitelist, "09:0B.3,type=test", 323 pci_whitelist, "08:00.1,type=normal", 324 }; 325 326 for (i = 0; i < sizeof(wlinval) / sizeof(wlinval[0]); i++) { 327 if (launch_proc(wlinval[i]) == 0) { 328 printf("Error - process did run ok with invalid " 329 "whitelist parameter\n"); 330 return -1; 331 } 332 } 333 if (launch_proc(wlval1) != 0 ) { 334 printf("Error - process did not run ok with valid whitelist\n"); 335 return -1; 336 } 337 if (launch_proc(wlval2) != 0 ) { 338 printf("Error - process did not run ok with valid whitelist value set\n"); 339 return -1; 340 } 341 if (launch_proc(wlval3) != 0 ) { 342 printf("Error - process did not run ok with valid whitelist + args\n"); 343 return -1; 344 } 345 346 return 0; 347 } 348 349 /* 350 * Test that the app doesn't run with invalid blacklist option. 351 * Final test ensures it does run with valid options as sanity check 352 */ 353 static int 354 test_invalid_b_flag(void) 355 { 356 #ifdef RTE_EXEC_ENV_BSDAPP 357 /* BSD target doesn't support prefixes at this point */ 358 const char * prefix = ""; 359 #else 360 char prefix[PATH_MAX], tmp[PATH_MAX]; 361 if (get_current_prefix(tmp, sizeof(tmp)) == NULL) { 362 printf("Error - unable to get current prefix!\n"); 363 return -1; 364 } 365 snprintf(prefix, sizeof(prefix), "--file-prefix=%s", tmp); 366 #endif 367 368 const char *blinval[][9] = { 369 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", "-b", "error"}, 370 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", "-b", "0:0:0"}, 371 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", "-b", "0:error:0.1"}, 372 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", "-b", "0:0:0.1error"}, 373 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", "-b", "error0:0:0.1"}, 374 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", "-b", "0:0:0.1.2"}, 375 }; 376 /* Test with valid blacklist option */ 377 const char *blval[] = {prgname, prefix, mp_flag, "-n", "1", "-c", "1", "-b", "FF:09:0B.3"}; 378 379 int i; 380 381 for (i = 0; i != sizeof (blinval) / sizeof (blinval[0]); i++) { 382 if (launch_proc(blinval[i]) == 0) { 383 printf("Error - process did run ok with invalid " 384 "blacklist parameter\n"); 385 return -1; 386 } 387 } 388 if (launch_proc(blval) != 0) { 389 printf("Error - process did not run ok with valid blacklist value\n"); 390 return -1; 391 } 392 return 0; 393 } 394 395 /* 396 * Test that the app doesn't run with invalid vdev option. 397 * Final test ensures it does run with valid options as sanity check 398 */ 399 #ifdef RTE_LIBRTE_PMD_RING 400 static int 401 test_invalid_vdev_flag(void) 402 { 403 #ifdef RTE_EXEC_ENV_BSDAPP 404 /* BSD target doesn't support prefixes at this point, and we also need to 405 * run another primary process here */ 406 const char * prefix = no_shconf; 407 #else 408 const char * prefix = "--file-prefix=vdev"; 409 #endif 410 411 /* Test with invalid vdev option */ 412 const char *vdevinval[] = {prgname, prefix, "-n", "1", 413 "-c", "1", vdev, "eth_dummy"}; 414 415 /* Test with valid vdev option */ 416 const char *vdevval1[] = {prgname, prefix, "-n", "1", 417 "-c", "1", vdev, "eth_ring0"}; 418 419 const char *vdevval2[] = {prgname, prefix, "-n", "1", 420 "-c", "1", vdev, "eth_ring0,args=test"}; 421 422 const char *vdevval3[] = {prgname, prefix, "-n", "1", 423 "-c", "1", vdev, "eth_ring0,nodeaction=r1:0:CREATE"}; 424 425 if (launch_proc(vdevinval) == 0) { 426 printf("Error - process did run ok with invalid " 427 "vdev parameter\n"); 428 return -1; 429 } 430 431 if (launch_proc(vdevval1) != 0) { 432 printf("Error - process did not run ok with valid vdev value\n"); 433 return -1; 434 } 435 436 if (launch_proc(vdevval2) != 0) { 437 printf("Error - process did not run ok with valid vdev value," 438 "with dummy args\n"); 439 return -1; 440 } 441 442 if (launch_proc(vdevval3) != 0) { 443 printf("Error - process did not run ok with valid vdev value," 444 "with valid args\n"); 445 return -1; 446 } 447 return 0; 448 } 449 #endif 450 451 /* 452 * Test that the app doesn't run with invalid -r option. 453 */ 454 static int 455 test_invalid_r_flag(void) 456 { 457 #ifdef RTE_EXEC_ENV_BSDAPP 458 /* BSD target doesn't support prefixes at this point */ 459 const char * prefix = ""; 460 #else 461 char prefix[PATH_MAX], tmp[PATH_MAX]; 462 if (get_current_prefix(tmp, sizeof(tmp)) == NULL) { 463 printf("Error - unable to get current prefix!\n"); 464 return -1; 465 } 466 snprintf(prefix, sizeof(prefix), "--file-prefix=%s", tmp); 467 #endif 468 469 const char *rinval[][9] = { 470 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", "-r", "error"}, 471 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", "-r", "0"}, 472 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", "-r", "-1"}, 473 {prgname, prefix, mp_flag, "-n", "1", "-c", "1", "-r", "17"}, 474 }; 475 /* Test with valid blacklist option */ 476 const char *rval[] = {prgname, prefix, mp_flag, "-n", "1", "-c", "1", "-r", "16"}; 477 478 int i; 479 480 for (i = 0; i != sizeof (rinval) / sizeof (rinval[0]); i++) { 481 if (launch_proc(rinval[i]) == 0) { 482 printf("Error - process did run ok with invalid " 483 "-r (rank) parameter\n"); 484 return -1; 485 } 486 } 487 if (launch_proc(rval) != 0) { 488 printf("Error - process did not run ok with valid -r (rank) value\n"); 489 return -1; 490 } 491 return 0; 492 } 493 494 /* 495 * Test that the app doesn't run without the coremask/corelist flags. In all cases 496 * should give an error and fail to run 497 */ 498 static int 499 test_missing_c_flag(void) 500 { 501 #ifdef RTE_EXEC_ENV_BSDAPP 502 /* BSD target doesn't support prefixes at this point */ 503 const char * prefix = ""; 504 #else 505 char prefix[PATH_MAX], tmp[PATH_MAX]; 506 if (get_current_prefix(tmp, sizeof(tmp)) == NULL) { 507 printf("Error - unable to get current prefix!\n"); 508 return -1; 509 } 510 snprintf(prefix, sizeof(prefix), "--file-prefix=%s", tmp); 511 #endif 512 513 /* -c flag but no coremask value */ 514 const char *argv1[] = { prgname, prefix, mp_flag, "-n", "3", "-c"}; 515 /* No -c, -l or --lcores flag at all */ 516 const char *argv2[] = { prgname, prefix, mp_flag, "-n", "3"}; 517 /* bad coremask value */ 518 const char *argv3[] = { prgname, prefix, mp_flag, 519 "-n", "3", "-c", "error" }; 520 /* sanity check of tests - valid coremask value */ 521 const char *argv4[] = { prgname, prefix, mp_flag, 522 "-n", "3", "-c", "1" }; 523 /* -l flag but no corelist value */ 524 const char *argv5[] = { prgname, prefix, mp_flag, 525 "-n", "3", "-l"}; 526 const char *argv6[] = { prgname, prefix, mp_flag, 527 "-n", "3", "-l", " " }; 528 /* bad corelist values */ 529 const char *argv7[] = { prgname, prefix, mp_flag, 530 "-n", "3", "-l", "error" }; 531 const char *argv8[] = { prgname, prefix, mp_flag, 532 "-n", "3", "-l", "1-" }; 533 const char *argv9[] = { prgname, prefix, mp_flag, 534 "-n", "3", "-l", "1," }; 535 const char *argv10[] = { prgname, prefix, mp_flag, 536 "-n", "3", "-l", "1#2" }; 537 /* sanity check test - valid corelist value */ 538 const char *argv11[] = { prgname, prefix, mp_flag, 539 "-n", "3", "-l", "1-2,3" }; 540 541 /* --lcores flag but no lcores value */ 542 const char *argv12[] = { prgname, prefix, mp_flag, 543 "-n", "3", "--lcores" }; 544 const char *argv13[] = { prgname, prefix, mp_flag, 545 "-n", "3", "--lcores", " " }; 546 /* bad lcores value */ 547 const char *argv14[] = { prgname, prefix, mp_flag, 548 "-n", "3", "--lcores", "1-3-5" }; 549 const char *argv15[] = { prgname, prefix, mp_flag, 550 "-n", "3", "--lcores", "0-1,,2" }; 551 const char *argv16[] = { prgname, prefix, mp_flag, 552 "-n", "3", "--lcores", "0-,1" }; 553 const char *argv17[] = { prgname, prefix, mp_flag, 554 "-n", "3", "--lcores", "(0-,2-4)" }; 555 const char *argv18[] = { prgname, prefix, mp_flag, 556 "-n", "3", "--lcores", "(-1,2)" }; 557 const char *argv19[] = { prgname, prefix, mp_flag, 558 "-n", "3", "--lcores", "(2-4)@(2-4-6)" }; 559 const char *argv20[] = { prgname, prefix, mp_flag, 560 "-n", "3", "--lcores", "(a,2)" }; 561 const char *argv21[] = { prgname, prefix, mp_flag, 562 "-n", "3", "--lcores", "1-3@(1,3)" }; 563 const char *argv22[] = { prgname, prefix, mp_flag, 564 "-n", "3", "--lcores", "3@((1,3)" }; 565 const char *argv23[] = { prgname, prefix, mp_flag, 566 "-n", "3", "--lcores", "(4-7)=(1,3)" }; 567 const char *argv24[] = { prgname, prefix, mp_flag, 568 "-n", "3", "--lcores", "[4-7]@(1,3)" }; 569 /* sanity check of tests - valid lcores value */ 570 const char *argv25[] = { prgname, prefix, mp_flag, 571 "-n", "3", "--lcores", 572 "0-1,2@(5-7),(3-5)@(0,2),(0,6),7"}; 573 574 if (launch_proc(argv2) != 0) { 575 printf("Error - " 576 "process did not run ok when missing -c flag\n"); 577 return -1; 578 } 579 580 if (launch_proc(argv1) == 0 581 || launch_proc(argv3) == 0) { 582 printf("Error - " 583 "process ran without error with invalid -c flag\n"); 584 return -1; 585 } 586 if (launch_proc(argv4) != 0) { 587 printf("Error - " 588 "process did not run ok with valid coremask value\n"); 589 return -1; 590 } 591 592 /* start -l test */ 593 if (launch_proc(argv5) == 0 594 || launch_proc(argv6) == 0 595 || launch_proc(argv7) == 0 596 || launch_proc(argv8) == 0 597 || launch_proc(argv9) == 0 598 || launch_proc(argv10) == 0) { 599 printf("Error - " 600 "process ran without error with invalid -l flag\n"); 601 return -1; 602 } 603 if (launch_proc(argv11) != 0) { 604 printf("Error - " 605 "process did not run ok with valid corelist value\n"); 606 return -1; 607 } 608 609 /* start --lcores tests */ 610 if (launch_proc(argv12) == 0 || launch_proc(argv13) == 0 || 611 launch_proc(argv14) == 0 || launch_proc(argv15) == 0 || 612 launch_proc(argv16) == 0 || launch_proc(argv17) == 0 || 613 launch_proc(argv18) == 0 || launch_proc(argv19) == 0 || 614 launch_proc(argv20) == 0 || launch_proc(argv21) == 0 || 615 launch_proc(argv21) == 0 || launch_proc(argv22) == 0 || 616 launch_proc(argv23) == 0 || launch_proc(argv24) == 0) { 617 printf("Error - " 618 "process ran without error with invalid --lcore flag\n"); 619 return -1; 620 } 621 622 if (launch_proc(argv25) != 0) { 623 printf("Error - " 624 "process did not run ok with valid corelist value\n"); 625 return -1; 626 } 627 628 return 0; 629 } 630 631 /* 632 * Test --master-lcore option with matching coremask 633 */ 634 static int 635 test_master_lcore_flag(void) 636 { 637 #ifdef RTE_EXEC_ENV_BSDAPP 638 /* BSD target doesn't support prefixes at this point */ 639 const char *prefix = ""; 640 #else 641 char prefix[PATH_MAX], tmp[PATH_MAX]; 642 if (get_current_prefix(tmp, sizeof(tmp)) == NULL) { 643 printf("Error - unable to get current prefix!\n"); 644 return -1; 645 } 646 snprintf(prefix, sizeof(prefix), "--file-prefix=%s", tmp); 647 #endif 648 649 /* --master-lcore flag but no value */ 650 const char *argv1[] = { prgname, prefix, mp_flag, "-n", "1", "-c", "3", "--master-lcore"}; 651 /* --master-lcore flag with invalid value */ 652 const char *argv2[] = { prgname, prefix, mp_flag, "-n", "1", "-c", "3", "--master-lcore", "-1"}; 653 const char *argv3[] = { prgname, prefix, mp_flag, "-n", "1", "-c", "3", "--master-lcore", "X"}; 654 /* master lcore not in coremask */ 655 const char *argv4[] = { prgname, prefix, mp_flag, "-n", "1", "-c", "3", "--master-lcore", "2"}; 656 /* valid value */ 657 const char *argv5[] = { prgname, prefix, mp_flag, "-n", "1", "-c", "3", "--master-lcore", "1"}; 658 /* valid value set before coremask */ 659 const char *argv6[] = { prgname, prefix, mp_flag, "-n", "1", "--master-lcore", "1", "-c", "3"}; 660 661 if (launch_proc(argv1) == 0 662 || launch_proc(argv2) == 0 663 || launch_proc(argv3) == 0 664 || launch_proc(argv4) == 0) { 665 printf("Error - process ran without error with wrong --master-lcore\n"); 666 return -1; 667 } 668 if (launch_proc(argv5) != 0 669 || launch_proc(argv6) != 0) { 670 printf("Error - process did not run ok with valid --master-lcore\n"); 671 return -1; 672 } 673 return 0; 674 } 675 676 /* 677 * Test that the app doesn't run with invalid -n flag option. 678 * Final test ensures it does run with valid options as sanity check 679 * Since -n is not compulsory for MP, we instead use --no-huge and --no-shconf 680 * flags. 681 */ 682 static int 683 test_invalid_n_flag(void) 684 { 685 #ifdef RTE_EXEC_ENV_BSDAPP 686 /* BSD target doesn't support prefixes at this point */ 687 const char * prefix = ""; 688 #else 689 char prefix[PATH_MAX], tmp[PATH_MAX]; 690 if (get_current_prefix(tmp, sizeof(tmp)) == NULL) { 691 printf("Error - unable to get current prefix!\n"); 692 return -1; 693 } 694 snprintf(prefix, sizeof(prefix), "--file-prefix=%s", tmp); 695 #endif 696 697 /* -n flag but no value */ 698 const char *argv1[] = { prgname, prefix, no_huge, no_shconf, "-c", "1", "-n"}; 699 /* bad numeric value */ 700 const char *argv2[] = { prgname, prefix, no_huge, no_shconf, "-c", "1", "-n", "e" }; 701 /* zero is invalid */ 702 const char *argv3[] = { prgname, prefix, no_huge, no_shconf, "-c", "1", "-n", "0" }; 703 /* sanity test - check with good value */ 704 const char *argv4[] = { prgname, prefix, no_huge, no_shconf, "-c", "1", "-n", "2" }; 705 /* sanity test - check with no -n flag */ 706 const char *argv5[] = { prgname, prefix, no_huge, no_shconf, "-c", "1"}; 707 708 if (launch_proc(argv1) == 0 709 || launch_proc(argv2) == 0 710 || launch_proc(argv3) == 0) { 711 printf("Error - process ran without error when" 712 "invalid -n flag\n"); 713 return -1; 714 } 715 if (launch_proc(argv4) != 0) { 716 printf("Error - process did not run ok with valid num-channel value\n"); 717 return -1; 718 } 719 if (launch_proc(argv5) != 0) { 720 printf("Error - process did not run ok without -n flag\n"); 721 return -1; 722 } 723 724 return 0; 725 } 726 727 /* 728 * Test that the app runs with HPET, and without HPET 729 */ 730 static int 731 test_no_hpet_flag(void) 732 { 733 char prefix[PATH_MAX], tmp[PATH_MAX]; 734 735 #ifdef RTE_EXEC_ENV_BSDAPP 736 return 0; 737 #endif 738 if (get_current_prefix(tmp, sizeof(tmp)) == NULL) { 739 printf("Error - unable to get current prefix!\n"); 740 return -1; 741 } 742 snprintf(prefix, sizeof(prefix), "--file-prefix=%s", tmp); 743 744 /* With --no-hpet */ 745 const char *argv1[] = {prgname, prefix, mp_flag, no_hpet, "-c", "1", "-n", "2"}; 746 /* Without --no-hpet */ 747 const char *argv2[] = {prgname, prefix, mp_flag, "-c", "1", "-n", "2"}; 748 749 if (launch_proc(argv1) != 0) { 750 printf("Error - process did not run ok with --no-hpet flag\n"); 751 return -1; 752 } 753 if (launch_proc(argv2) != 0) { 754 printf("Error - process did not run ok without --no-hpet flag\n"); 755 return -1; 756 } 757 return 0; 758 } 759 760 /* 761 * Test that the app runs with --no-huge and doesn't run when --socket-mem are 762 * specified with --no-huge. 763 */ 764 static int 765 test_no_huge_flag(void) 766 { 767 #ifdef RTE_EXEC_ENV_BSDAPP 768 /* BSD target doesn't support prefixes at this point, and we also need to 769 * run another primary process here */ 770 const char * prefix = no_shconf; 771 #else 772 const char * prefix = "--file-prefix=nohuge"; 773 #endif 774 775 /* With --no-huge */ 776 const char *argv1[] = {prgname, prefix, no_huge, "-c", "1", "-n", "2"}; 777 /* With --no-huge and -m */ 778 const char *argv2[] = {prgname, prefix, no_huge, "-c", "1", "-n", "2", 779 "-m", DEFAULT_MEM_SIZE}; 780 781 /* With --no-huge and --socket-mem */ 782 const char *argv3[] = {prgname, prefix, no_huge, "-c", "1", "-n", "2", 783 "--socket-mem=" DEFAULT_MEM_SIZE}; 784 /* With --no-huge, -m and --socket-mem */ 785 const char *argv4[] = {prgname, prefix, no_huge, "-c", "1", "-n", "2", 786 "-m", DEFAULT_MEM_SIZE, "--socket-mem=" DEFAULT_MEM_SIZE}; 787 if (launch_proc(argv1) != 0) { 788 printf("Error - process did not run ok with --no-huge flag\n"); 789 return -1; 790 } 791 if (launch_proc(argv2) != 0) { 792 printf("Error - process did not run ok with --no-huge and -m flags\n"); 793 return -1; 794 } 795 #ifdef RTE_EXEC_ENV_BSDAPP 796 /* BSD target does not support NUMA, hence no --socket-mem tests */ 797 return 0; 798 #endif 799 800 if (launch_proc(argv3) == 0) { 801 printf("Error - process run ok with --no-huge and --socket-mem " 802 "flags\n"); 803 return -1; 804 } 805 if (launch_proc(argv4) == 0) { 806 printf("Error - process run ok with --no-huge, -m and " 807 "--socket-mem flags\n"); 808 return -1; 809 } 810 return 0; 811 } 812 813 #ifdef RTE_LIBRTE_XEN_DOM0 814 static int 815 test_dom0_misc_flags(void) 816 { 817 char prefix[PATH_MAX], tmp[PATH_MAX]; 818 819 if (get_current_prefix(tmp, sizeof(tmp)) == NULL) { 820 printf("Error - unable to get current prefix!\n"); 821 return -1; 822 } 823 snprintf(prefix, sizeof(prefix), "--file-prefix=%s", tmp); 824 825 /* check that some general flags don't prevent things from working. 826 * All cases, apart from the first, app should run. 827 * No futher testing of output done. 828 */ 829 /* sanity check - failure with invalid option */ 830 const char *argv0[] = {prgname, prefix, mp_flag, "-c", "1", "--invalid-opt"}; 831 832 /* With --no-pci */ 833 const char *argv1[] = {prgname, prefix, mp_flag, "-c", "1", "--no-pci"}; 834 /* With -v */ 835 const char *argv2[] = {prgname, prefix, mp_flag, "-c", "1", "-v"}; 836 /* With valid --syslog */ 837 const char *argv3[] = {prgname, prefix, mp_flag, "-c", "1", 838 "--syslog", "syslog"}; 839 /* With empty --syslog (should fail) */ 840 const char *argv4[] = {prgname, prefix, mp_flag, "-c", "1", "--syslog"}; 841 /* With invalid --syslog */ 842 const char *argv5[] = {prgname, prefix, mp_flag, "-c", "1", "--syslog", "error"}; 843 /* With no-sh-conf */ 844 const char *argv6[] = {prgname, "-c", "1", "-n", "2", "-m", "20", 845 "--no-shconf", "--file-prefix=noshconf" }; 846 847 if (launch_proc(argv0) == 0) { 848 printf("Error - process ran ok with invalid flag\n"); 849 return -1; 850 } 851 if (launch_proc(argv1) != 0) { 852 printf("Error - process did not run ok with --no-pci flag\n"); 853 return -1; 854 } 855 if (launch_proc(argv2) != 0) { 856 printf("Error - process did not run ok with -v flag\n"); 857 return -1; 858 } 859 if (launch_proc(argv3) != 0) { 860 printf("Error - process did not run ok with --syslog flag\n"); 861 return -1; 862 } 863 if (launch_proc(argv4) == 0) { 864 printf("Error - process run ok with empty --syslog flag\n"); 865 return -1; 866 } 867 if (launch_proc(argv5) == 0) { 868 printf("Error - process run ok with invalid --syslog flag\n"); 869 return -1; 870 } 871 if (launch_proc(argv6) != 0) { 872 printf("Error - process did not run ok with --no-shconf flag\n"); 873 return -1; 874 } 875 876 return 0; 877 } 878 #else 879 static int 880 test_misc_flags(void) 881 { 882 char hugepath[PATH_MAX] = {0}; 883 #ifdef RTE_EXEC_ENV_BSDAPP 884 /* BSD target doesn't support prefixes at this point */ 885 const char * prefix = ""; 886 const char * nosh_prefix = ""; 887 #else 888 char prefix[PATH_MAX], tmp[PATH_MAX]; 889 const char * nosh_prefix = "--file-prefix=noshconf"; 890 FILE * hugedir_handle = NULL; 891 char line[PATH_MAX] = {0}; 892 unsigned i, isempty = 1; 893 if (get_current_prefix(tmp, sizeof(tmp)) == NULL) { 894 printf("Error - unable to get current prefix!\n"); 895 return -1; 896 } 897 snprintf(prefix, sizeof(prefix), "--file-prefix=%s", tmp); 898 899 /* 900 * get first valid hugepage path 901 */ 902 903 /* get hugetlbfs mountpoints from /proc/mounts */ 904 hugedir_handle = fopen("/proc/mounts", "r"); 905 906 if (hugedir_handle == NULL) { 907 printf("Error opening /proc/mounts!\n"); 908 return -1; 909 } 910 911 /* read /proc/mounts */ 912 while (fgets(line, sizeof(line), hugedir_handle) != NULL) { 913 914 /* find first valid hugepath */ 915 if (get_hugepage_path(line, sizeof(line), hugepath, sizeof(hugepath))) 916 break; 917 } 918 919 fclose(hugedir_handle); 920 921 /* check if path is not empty */ 922 for (i = 0; i < sizeof(hugepath); i++) 923 if (hugepath[i] != '\0') 924 isempty = 0; 925 926 if (isempty) { 927 printf("No mounted hugepage dir found!\n"); 928 return -1; 929 } 930 #endif 931 932 933 /* check that some general flags don't prevent things from working. 934 * All cases, apart from the first, app should run. 935 * No futher testing of output done. 936 */ 937 /* sanity check - failure with invalid option */ 938 const char *argv0[] = {prgname, prefix, mp_flag, "-c", "1", "--invalid-opt"}; 939 940 /* With --no-pci */ 941 const char *argv1[] = {prgname, prefix, mp_flag, "-c", "1", "--no-pci"}; 942 /* With -v */ 943 const char *argv2[] = {prgname, prefix, mp_flag, "-c", "1", "-v"}; 944 /* With valid --syslog */ 945 const char *argv3[] = {prgname, prefix, mp_flag, "-c", "1", 946 "--syslog", "syslog"}; 947 /* With empty --syslog (should fail) */ 948 const char *argv4[] = {prgname, prefix, mp_flag, "-c", "1", "--syslog"}; 949 /* With invalid --syslog */ 950 const char *argv5[] = {prgname, prefix, mp_flag, "-c", "1", "--syslog", "error"}; 951 /* With no-sh-conf */ 952 const char *argv6[] = {prgname, "-c", "1", "-n", "2", "-m", DEFAULT_MEM_SIZE, 953 no_shconf, nosh_prefix }; 954 955 #ifdef RTE_EXEC_ENV_BSDAPP 956 return 0; 957 #endif 958 /* With --huge-dir */ 959 const char *argv7[] = {prgname, "-c", "1", "-n", "2", "-m", DEFAULT_MEM_SIZE, 960 "--file-prefix=hugedir", "--huge-dir", hugepath}; 961 /* With empty --huge-dir (should fail) */ 962 const char *argv8[] = {prgname, "-c", "1", "-n", "2", "-m", DEFAULT_MEM_SIZE, 963 "--file-prefix=hugedir", "--huge-dir"}; 964 /* With invalid --huge-dir */ 965 const char *argv9[] = {prgname, "-c", "1", "-n", "2", "-m", DEFAULT_MEM_SIZE, 966 "--file-prefix=hugedir", "--huge-dir", "invalid"}; 967 /* Secondary process with invalid --huge-dir (should run as flag has no 968 * effect on secondary processes) */ 969 const char *argv10[] = {prgname, prefix, mp_flag, "-c", "1", "--huge-dir", "invalid"}; 970 971 /* try running with base-virtaddr param */ 972 const char *argv11[] = {prgname, "--file-prefix=virtaddr", 973 "-c", "1", "-n", "2", "--base-virtaddr=0x12345678"}; 974 975 /* try running with --vfio-intr INTx flag */ 976 const char *argv12[] = {prgname, "--file-prefix=intr", 977 "-c", "1", "-n", "2", "--vfio-intr=legacy"}; 978 979 /* try running with --vfio-intr MSI flag */ 980 const char *argv13[] = {prgname, "--file-prefix=intr", 981 "-c", "1", "-n", "2", "--vfio-intr=msi"}; 982 983 /* try running with --vfio-intr MSI-X flag */ 984 const char *argv14[] = {prgname, "--file-prefix=intr", 985 "-c", "1", "-n", "2", "--vfio-intr=msix"}; 986 987 /* try running with --vfio-intr invalid flag */ 988 const char *argv15[] = {prgname, "--file-prefix=intr", 989 "-c", "1", "-n", "2", "--vfio-intr=invalid"}; 990 991 992 if (launch_proc(argv0) == 0) { 993 printf("Error - process ran ok with invalid flag\n"); 994 return -1; 995 } 996 if (launch_proc(argv1) != 0) { 997 printf("Error - process did not run ok with --no-pci flag\n"); 998 return -1; 999 } 1000 if (launch_proc(argv2) != 0) { 1001 printf("Error - process did not run ok with -v flag\n"); 1002 return -1; 1003 } 1004 if (launch_proc(argv3) != 0) { 1005 printf("Error - process did not run ok with --syslog flag\n"); 1006 return -1; 1007 } 1008 if (launch_proc(argv4) == 0) { 1009 printf("Error - process run ok with empty --syslog flag\n"); 1010 return -1; 1011 } 1012 if (launch_proc(argv5) == 0) { 1013 printf("Error - process run ok with invalid --syslog flag\n"); 1014 return -1; 1015 } 1016 if (launch_proc(argv6) != 0) { 1017 printf("Error - process did not run ok with --no-shconf flag\n"); 1018 return -1; 1019 } 1020 #ifdef RTE_EXEC_ENV_BSDAPP 1021 return 0; 1022 #endif 1023 if (launch_proc(argv7) != 0) { 1024 printf("Error - process did not run ok with --huge-dir flag\n"); 1025 return -1; 1026 } 1027 if (launch_proc(argv8) == 0) { 1028 printf("Error - process run ok with empty --huge-dir flag\n"); 1029 return -1; 1030 } 1031 if (launch_proc(argv9) == 0) { 1032 printf("Error - process run ok with invalid --huge-dir flag\n"); 1033 return -1; 1034 } 1035 if (launch_proc(argv10) != 0) { 1036 printf("Error - secondary process did not run ok with invalid --huge-dir flag\n"); 1037 return -1; 1038 } 1039 if (launch_proc(argv11) != 0) { 1040 printf("Error - process did not run ok with --base-virtaddr parameter\n"); 1041 return -1; 1042 } 1043 if (launch_proc(argv12) != 0) { 1044 printf("Error - process did not run ok with " 1045 "--vfio-intr INTx parameter\n"); 1046 return -1; 1047 } 1048 if (launch_proc(argv13) != 0) { 1049 printf("Error - process did not run ok with " 1050 "--vfio-intr MSI parameter\n"); 1051 return -1; 1052 } 1053 if (launch_proc(argv14) != 0) { 1054 printf("Error - process did not run ok with " 1055 "--vfio-intr MSI-X parameter\n"); 1056 return -1; 1057 } 1058 if (launch_proc(argv15) == 0) { 1059 printf("Error - process run ok with " 1060 "--vfio-intr invalid parameter\n"); 1061 return -1; 1062 } 1063 return 0; 1064 } 1065 #endif 1066 1067 static int 1068 test_file_prefix(void) 1069 { 1070 /* 1071 * 1. check if current process hugefiles are locked 1072 * 2. try to run secondary process without a corresponding primary process 1073 * (while failing to run, it will also remove any unused hugepage files) 1074 * 3. check if current process hugefiles are still in place and are locked 1075 * 4. run a primary process with memtest1 prefix 1076 * 5. check if memtest1 hugefiles are created 1077 * 6. run a primary process with memtest2 prefix 1078 * 7. check that only memtest2 hugefiles are present in the hugedir 1079 */ 1080 1081 #ifdef RTE_EXEC_ENV_BSDAPP 1082 return 0; 1083 #endif 1084 1085 /* this should fail unless the test itself is run with "memtest" prefix */ 1086 const char *argv0[] = {prgname, mp_flag, "-c", "1", "-n", "2", "-m", DEFAULT_MEM_SIZE, 1087 "--file-prefix=" memtest }; 1088 1089 /* primary process with memtest1 */ 1090 const char *argv1[] = {prgname, "-c", "1", "-n", "2", "-m", DEFAULT_MEM_SIZE, 1091 "--file-prefix=" memtest1 }; 1092 1093 /* primary process with memtest2 */ 1094 const char *argv2[] = {prgname, "-c", "1", "-n", "2", "-m", DEFAULT_MEM_SIZE, 1095 "--file-prefix=" memtest2 }; 1096 1097 char prefix[32]; 1098 if (get_current_prefix(prefix, sizeof(prefix)) == NULL) { 1099 printf("Error - unable to get current prefix!\n"); 1100 return -1; 1101 } 1102 #ifdef RTE_LIBRTE_XEN_DOM0 1103 return 0; 1104 #endif 1105 1106 /* check if files for current prefix are present */ 1107 if (process_hugefiles(prefix, HUGEPAGE_CHECK_EXISTS) != 1) { 1108 printf("Error - hugepage files for %s were not created!\n", prefix); 1109 return -1; 1110 } 1111 1112 /* checks if files for current prefix are locked */ 1113 if (process_hugefiles(prefix, HUGEPAGE_CHECK_LOCKED) != 1) { 1114 printf("Error - hugepages for current process aren't locked!\n"); 1115 return -1; 1116 } 1117 1118 /* check if files for secondary process are present */ 1119 if (process_hugefiles(memtest, HUGEPAGE_CHECK_EXISTS) == 1) { 1120 /* check if they are not locked */ 1121 if (process_hugefiles(memtest, HUGEPAGE_CHECK_LOCKED) == 1) { 1122 printf("Error - hugepages for current process are locked!\n"); 1123 return -1; 1124 } 1125 /* they aren't locked, delete them */ 1126 else { 1127 if (process_hugefiles(memtest, HUGEPAGE_DELETE) != 1) { 1128 printf("Error - deleting hugepages failed!\n"); 1129 return -1; 1130 } 1131 } 1132 } 1133 1134 if (launch_proc(argv0) == 0) { 1135 printf("Error - secondary process ran ok without primary process\n"); 1136 return -1; 1137 } 1138 1139 /* check if files for current prefix are present */ 1140 if (process_hugefiles(prefix, HUGEPAGE_CHECK_EXISTS) != 1) { 1141 printf("Error - hugepage files for %s were not created!\n", prefix); 1142 return -1; 1143 } 1144 1145 /* checks if files for current prefix are locked */ 1146 if (process_hugefiles(prefix, HUGEPAGE_CHECK_LOCKED) != 1) { 1147 printf("Error - hugepages for current process aren't locked!\n"); 1148 return -1; 1149 } 1150 1151 if (launch_proc(argv1) != 0) { 1152 printf("Error - failed to run with --file-prefix=%s\n", memtest); 1153 return -1; 1154 } 1155 1156 /* check if memtest1_map0 is present */ 1157 if (process_hugefiles(memtest1, HUGEPAGE_CHECK_EXISTS) != 1) { 1158 printf("Error - hugepage files for %s were not created!\n", memtest1); 1159 return -1; 1160 } 1161 1162 if (launch_proc(argv2) != 0) { 1163 printf("Error - failed to run with --file-prefix=%s\n", memtest2); 1164 return -1; 1165 } 1166 1167 /* check if hugefiles for memtest2 are present */ 1168 if (process_hugefiles(memtest2, HUGEPAGE_CHECK_EXISTS) != 1) { 1169 printf("Error - hugepage files for %s were not created!\n", memtest2); 1170 return -1; 1171 } 1172 1173 /* check if hugefiles for memtest1 are present */ 1174 if (process_hugefiles(memtest1, HUGEPAGE_CHECK_EXISTS) != 0) { 1175 printf("Error - hugepage files for %s were not deleted!\n", memtest1); 1176 return -1; 1177 } 1178 1179 return 0; 1180 } 1181 1182 /* 1183 * Tests for correct handling of -m and --socket-mem flags 1184 */ 1185 static int 1186 test_memory_flags(void) 1187 { 1188 #ifdef RTE_EXEC_ENV_BSDAPP 1189 /* BSD target doesn't support prefixes at this point */ 1190 const char * prefix = ""; 1191 #else 1192 char prefix[PATH_MAX], tmp[PATH_MAX]; 1193 if (get_current_prefix(tmp, sizeof(tmp)) == NULL) { 1194 printf("Error - unable to get current prefix!\n"); 1195 return -1; 1196 } 1197 snprintf(prefix, sizeof(prefix), "--file-prefix=%s", tmp); 1198 #endif 1199 1200 /* valid -m flag and mp flag */ 1201 const char *argv0[] = {prgname, prefix, mp_flag, "-c", "10", 1202 "-n", "2", "-m", DEFAULT_MEM_SIZE}; 1203 1204 /* valid -m flag */ 1205 const char *argv1[] = {prgname, "-c", "10", "-n", "2", 1206 "--file-prefix=" memtest, "-m", DEFAULT_MEM_SIZE}; 1207 1208 /* invalid (zero) --socket-mem flag */ 1209 const char *argv2[] = {prgname, "-c", "10", "-n", "2", 1210 "--file-prefix=" memtest, "--socket-mem=0,0,0,0"}; 1211 1212 /* invalid (incomplete) --socket-mem flag */ 1213 const char *argv3[] = {prgname, "-c", "10", "-n", "2", 1214 "--file-prefix=" memtest, "--socket-mem=2,2,"}; 1215 1216 /* invalid (mixed with invalid data) --socket-mem flag */ 1217 const char *argv4[] = {prgname, "-c", "10", "-n", "2", 1218 "--file-prefix=" memtest, "--socket-mem=2,2,Fred"}; 1219 1220 /* invalid (with numeric value as last character) --socket-mem flag */ 1221 const char *argv5[] = {prgname, "-c", "10", "-n", "2", 1222 "--file-prefix=" memtest, "--socket-mem=2,2,Fred0"}; 1223 1224 /* invalid (with empty socket) --socket-mem flag */ 1225 const char *argv6[] = {prgname, "-c", "10", "-n", "2", 1226 "--file-prefix=" memtest, "--socket-mem=2,,2"}; 1227 1228 /* invalid (null) --socket-mem flag */ 1229 const char *argv7[] = {prgname, "-c", "10", "-n", "2", 1230 "--file-prefix=" memtest, "--socket-mem="}; 1231 1232 /* valid --socket-mem specified together with -m flag */ 1233 const char *argv8[] = {prgname, "-c", "10", "-n", "2", 1234 "--file-prefix=" memtest, "-m", DEFAULT_MEM_SIZE, "--socket-mem=2,2"}; 1235 1236 /* construct an invalid socket mask with 2 megs on each socket plus 1237 * extra 2 megs on socket that doesn't exist on current system */ 1238 char invalid_socket_mem[SOCKET_MEM_STRLEN]; 1239 char buf[SOCKET_MEM_STRLEN]; /* to avoid copying string onto itself */ 1240 1241 #ifdef RTE_EXEC_ENV_BSDAPP 1242 int i, num_sockets = 1; 1243 #else 1244 int i, num_sockets = get_number_of_sockets(); 1245 #endif 1246 1247 if (num_sockets <= 0 || num_sockets > RTE_MAX_NUMA_NODES) { 1248 printf("Error - cannot get number of sockets!\n"); 1249 return -1; 1250 } 1251 1252 snprintf(invalid_socket_mem, sizeof(invalid_socket_mem), "--socket-mem="); 1253 1254 /* add one extra socket */ 1255 for (i = 0; i < num_sockets + 1; i++) { 1256 snprintf(buf, sizeof(buf), "%s%s", invalid_socket_mem, DEFAULT_MEM_SIZE); 1257 snprintf(invalid_socket_mem, sizeof(invalid_socket_mem), "%s", buf); 1258 1259 if (num_sockets + 1 - i > 1) { 1260 snprintf(buf, sizeof(buf), "%s,", invalid_socket_mem); 1261 snprintf(invalid_socket_mem, sizeof(invalid_socket_mem), "%s", buf); 1262 } 1263 } 1264 1265 /* construct a valid socket mask with 2 megs on each existing socket */ 1266 char valid_socket_mem[SOCKET_MEM_STRLEN]; 1267 1268 snprintf(valid_socket_mem, sizeof(valid_socket_mem), "--socket-mem="); 1269 1270 /* add one extra socket */ 1271 for (i = 0; i < num_sockets; i++) { 1272 snprintf(buf, sizeof(buf), "%s%s", valid_socket_mem, DEFAULT_MEM_SIZE); 1273 snprintf(valid_socket_mem, sizeof(valid_socket_mem), "%s", buf); 1274 1275 if (num_sockets - i > 1) { 1276 snprintf(buf, sizeof(buf), "%s,", valid_socket_mem); 1277 snprintf(valid_socket_mem, sizeof(valid_socket_mem), "%s", buf); 1278 } 1279 } 1280 1281 /* invalid --socket-mem flag (with extra socket) */ 1282 const char *argv9[] = {prgname, "-c", "10", "-n", "2", 1283 "--file-prefix=" memtest, invalid_socket_mem}; 1284 1285 /* valid --socket-mem flag */ 1286 const char *argv10[] = {prgname, "-c", "10", "-n", "2", 1287 "--file-prefix=" memtest, valid_socket_mem}; 1288 1289 if (launch_proc(argv0) != 0) { 1290 printf("Error - secondary process failed with valid -m flag !\n"); 1291 return -1; 1292 } 1293 1294 #ifdef RTE_EXEC_ENV_BSDAPP 1295 /* no other tests are applicable to BSD */ 1296 return 0; 1297 #endif 1298 1299 if (launch_proc(argv1) != 0) { 1300 printf("Error - process failed with valid -m flag!\n"); 1301 return -1; 1302 } 1303 #ifdef RTE_LIBRTE_XEN_DOM0 1304 return 0; 1305 #endif 1306 if (launch_proc(argv2) == 0) { 1307 printf("Error - process run ok with invalid (zero) --socket-mem!\n"); 1308 return -1; 1309 } 1310 1311 if (launch_proc(argv3) == 0) { 1312 printf("Error - process run ok with invalid " 1313 "(incomplete) --socket-mem!\n"); 1314 return -1; 1315 } 1316 1317 if (launch_proc(argv4) == 0) { 1318 printf("Error - process run ok with invalid " 1319 "(mixed with invalid input) --socket-mem!\n"); 1320 return -1; 1321 } 1322 1323 if (launch_proc(argv5) == 0) { 1324 printf("Error - process run ok with invalid " 1325 "(mixed with invalid input with a numeric value as " 1326 "last character) --socket-mem!\n"); 1327 return -1; 1328 } 1329 1330 if (launch_proc(argv6) == 0) { 1331 printf("Error - process run ok with invalid " 1332 "(with empty socket) --socket-mem!\n"); 1333 return -1; 1334 } 1335 1336 if (launch_proc(argv7) == 0) { 1337 printf("Error - process run ok with invalid (null) --socket-mem!\n"); 1338 return -1; 1339 } 1340 1341 if (launch_proc(argv8) == 0) { 1342 printf("Error - process run ok with --socket-mem and -m specified!\n"); 1343 return -1; 1344 } 1345 1346 if (launch_proc(argv9) == 0) { 1347 printf("Error - process run ok with extra socket in --socket-mem!\n"); 1348 return -1; 1349 } 1350 1351 if (launch_proc(argv10) != 0) { 1352 printf("Error - process failed with valid --socket-mem!\n"); 1353 return -1; 1354 } 1355 1356 return 0; 1357 } 1358 1359 static int 1360 test_eal_flags(void) 1361 { 1362 int ret = 0; 1363 1364 ret = test_missing_c_flag(); 1365 if (ret < 0) { 1366 printf("Error in test_missing_c_flag()\n"); 1367 return ret; 1368 } 1369 1370 ret = test_master_lcore_flag(); 1371 if (ret < 0) { 1372 printf("Error in test_master_lcore_flag()\n"); 1373 return ret; 1374 } 1375 1376 ret = test_invalid_n_flag(); 1377 if (ret < 0) { 1378 printf("Error in test_invalid_n_flag()\n"); 1379 return ret; 1380 } 1381 1382 ret = test_no_hpet_flag(); 1383 if (ret < 0) { 1384 printf("Error in test_no_hpet_flag()\n"); 1385 return ret; 1386 } 1387 1388 ret = test_no_huge_flag(); 1389 if (ret < 0) { 1390 printf("Error in test_no_huge_flag()\n"); 1391 return ret; 1392 } 1393 1394 ret = test_whitelist_flag(); 1395 if (ret < 0) { 1396 printf("Error in test_invalid_whitelist_flag()\n"); 1397 return ret; 1398 } 1399 1400 ret = test_invalid_b_flag(); 1401 if (ret < 0) { 1402 printf("Error in test_invalid_b_flag()\n"); 1403 return ret; 1404 } 1405 1406 #ifdef RTE_LIBRTE_PMD_RING 1407 ret = test_invalid_vdev_flag(); 1408 if (ret < 0) { 1409 printf("Error in test_invalid_vdev_flag()\n"); 1410 return ret; 1411 } 1412 #endif 1413 ret = test_invalid_r_flag(); 1414 if (ret < 0) { 1415 printf("Error in test_invalid_r_flag()\n"); 1416 return ret; 1417 } 1418 1419 ret = test_memory_flags(); 1420 if (ret < 0) { 1421 printf("Error in test_memory_flags()\n"); 1422 return ret; 1423 } 1424 1425 ret = test_file_prefix(); 1426 if (ret < 0) { 1427 printf("Error in test_file_prefix()\n"); 1428 return ret; 1429 } 1430 1431 #ifdef RTE_LIBRTE_XEN_DOM0 1432 ret = test_dom0_misc_flags(); 1433 #else 1434 ret = test_misc_flags(); 1435 #endif 1436 if (ret < 0) { 1437 printf("Error in test_misc_flags()"); 1438 return ret; 1439 } 1440 1441 return ret; 1442 } 1443 1444 REGISTER_TEST_COMMAND(eal_flags_autotest, test_eal_flags); 1445