app/test: fix EAL flags check
[dpdk.git] / 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         /* 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 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);