app/test/test_eal_flags.c

   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         /* out-of-range value */
 702         const char *argv3[] = { prgname, prefix, no_huge, no_shconf, "-c", "1", "-n", "9" };
 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 static struct test_command eal_flags_cmd = {
1445         .command = "eal_flags_autotest",
1446         .callback = test_eal_flags,
1447 };
1448 REGISTER_TEST_COMMAND(eal_flags_cmd);