~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/testing/selftests/bpf/test_progs.c

Version: ~ [ linux-5.12-rc7 ] ~ [ linux-5.11.13 ] ~ [ linux-5.10.29 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.111 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.186 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.230 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.266 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.266 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-only
  2 /* Copyright (c) 2017 Facebook
  3  */
  4 #define _GNU_SOURCE
  5 #include "test_progs.h"
  6 #include "cgroup_helpers.h"
  7 #include "bpf_rlimit.h"
  8 #include <argp.h>
  9 #include <pthread.h>
 10 #include <sched.h>
 11 #include <signal.h>
 12 #include <string.h>
 13 #include <execinfo.h> /* backtrace */
 14 
 15 #define EXIT_NO_TEST            2
 16 #define EXIT_ERR_SETUP_INFRA    3
 17 
 18 /* defined in test_progs.h */
 19 struct test_env env = {};
 20 
 21 struct prog_test_def {
 22         const char *test_name;
 23         int test_num;
 24         void (*run_test)(void);
 25         bool force_log;
 26         int error_cnt;
 27         int skip_cnt;
 28         bool tested;
 29         bool need_cgroup_cleanup;
 30 
 31         char *subtest_name;
 32         int subtest_num;
 33 
 34         /* store counts before subtest started */
 35         int old_error_cnt;
 36 };
 37 
 38 /* Override C runtime library's usleep() implementation to ensure nanosleep()
 39  * is always called. Usleep is frequently used in selftests as a way to
 40  * trigger kprobe and tracepoints.
 41  */
 42 int usleep(useconds_t usec)
 43 {
 44         struct timespec ts = {
 45                 .tv_sec = usec / 1000000,
 46                 .tv_nsec = (usec % 1000000) * 1000,
 47         };
 48 
 49         return syscall(__NR_nanosleep, &ts, NULL);
 50 }
 51 
 52 static bool should_run(struct test_selector *sel, int num, const char *name)
 53 {
 54         int i;
 55 
 56         for (i = 0; i < sel->blacklist.cnt; i++) {
 57                 if (strstr(name, sel->blacklist.strs[i]))
 58                         return false;
 59         }
 60 
 61         for (i = 0; i < sel->whitelist.cnt; i++) {
 62                 if (strstr(name, sel->whitelist.strs[i]))
 63                         return true;
 64         }
 65 
 66         if (!sel->whitelist.cnt && !sel->num_set)
 67                 return true;
 68 
 69         return num < sel->num_set_len && sel->num_set[num];
 70 }
 71 
 72 static void dump_test_log(const struct prog_test_def *test, bool failed)
 73 {
 74         if (stdout == env.stdout)
 75                 return;
 76 
 77         fflush(stdout); /* exports env.log_buf & env.log_cnt */
 78 
 79         if (env.verbosity > VERBOSE_NONE || test->force_log || failed) {
 80                 if (env.log_cnt) {
 81                         env.log_buf[env.log_cnt] = '\0';
 82                         fprintf(env.stdout, "%s", env.log_buf);
 83                         if (env.log_buf[env.log_cnt - 1] != '\n')
 84                                 fprintf(env.stdout, "\n");
 85                 }
 86         }
 87 
 88         fseeko(stdout, 0, SEEK_SET); /* rewind */
 89 }
 90 
 91 static void skip_account(void)
 92 {
 93         if (env.test->skip_cnt) {
 94                 env.skip_cnt++;
 95                 env.test->skip_cnt = 0;
 96         }
 97 }
 98 
 99 static void stdio_restore(void);
100 
101 /* A bunch of tests set custom affinity per-thread and/or per-process. Reset
102  * it after each test/sub-test.
103  */
104 static void reset_affinity() {
105 
106         cpu_set_t cpuset;
107         int i, err;
108 
109         CPU_ZERO(&cpuset);
110         for (i = 0; i < env.nr_cpus; i++)
111                 CPU_SET(i, &cpuset);
112 
113         err = sched_setaffinity(0, sizeof(cpuset), &cpuset);
114         if (err < 0) {
115                 stdio_restore();
116                 fprintf(stderr, "Failed to reset process affinity: %d!\n", err);
117                 exit(EXIT_ERR_SETUP_INFRA);
118         }
119         err = pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);
120         if (err < 0) {
121                 stdio_restore();
122                 fprintf(stderr, "Failed to reset thread affinity: %d!\n", err);
123                 exit(EXIT_ERR_SETUP_INFRA);
124         }
125 }
126 
127 static void save_netns(void)
128 {
129         env.saved_netns_fd = open("/proc/self/ns/net", O_RDONLY);
130         if (env.saved_netns_fd == -1) {
131                 perror("open(/proc/self/ns/net)");
132                 exit(EXIT_ERR_SETUP_INFRA);
133         }
134 }
135 
136 static void restore_netns(void)
137 {
138         if (setns(env.saved_netns_fd, CLONE_NEWNET) == -1) {
139                 stdio_restore();
140                 perror("setns(CLONE_NEWNS)");
141                 exit(EXIT_ERR_SETUP_INFRA);
142         }
143 }
144 
145 void test__end_subtest()
146 {
147         struct prog_test_def *test = env.test;
148         int sub_error_cnt = test->error_cnt - test->old_error_cnt;
149 
150         if (sub_error_cnt)
151                 env.fail_cnt++;
152         else
153                 env.sub_succ_cnt++;
154         skip_account();
155 
156         dump_test_log(test, sub_error_cnt);
157 
158         fprintf(env.stdout, "#%d/%d %s:%s\n",
159                test->test_num, test->subtest_num,
160                test->subtest_name, sub_error_cnt ? "FAIL" : "OK");
161 
162         free(test->subtest_name);
163         test->subtest_name = NULL;
164 }
165 
166 bool test__start_subtest(const char *name)
167 {
168         struct prog_test_def *test = env.test;
169 
170         if (test->subtest_name)
171                 test__end_subtest();
172 
173         test->subtest_num++;
174 
175         if (!name || !name[0]) {
176                 fprintf(env.stderr,
177                         "Subtest #%d didn't provide sub-test name!\n",
178                         test->subtest_num);
179                 return false;
180         }
181 
182         if (!should_run(&env.subtest_selector, test->subtest_num, name))
183                 return false;
184 
185         test->subtest_name = strdup(name);
186         if (!test->subtest_name) {
187                 fprintf(env.stderr,
188                         "Subtest #%d: failed to copy subtest name!\n",
189                         test->subtest_num);
190                 return false;
191         }
192         env.test->old_error_cnt = env.test->error_cnt;
193 
194         return true;
195 }
196 
197 void test__force_log() {
198         env.test->force_log = true;
199 }
200 
201 void test__skip(void)
202 {
203         env.test->skip_cnt++;
204 }
205 
206 void test__fail(void)
207 {
208         env.test->error_cnt++;
209 }
210 
211 int test__join_cgroup(const char *path)
212 {
213         int fd;
214 
215         if (!env.test->need_cgroup_cleanup) {
216                 if (setup_cgroup_environment()) {
217                         fprintf(stderr,
218                                 "#%d %s: Failed to setup cgroup environment\n",
219                                 env.test->test_num, env.test->test_name);
220                         return -1;
221                 }
222 
223                 env.test->need_cgroup_cleanup = true;
224         }
225 
226         fd = create_and_get_cgroup(path);
227         if (fd < 0) {
228                 fprintf(stderr,
229                         "#%d %s: Failed to create cgroup '%s' (errno=%d)\n",
230                         env.test->test_num, env.test->test_name, path, errno);
231                 return fd;
232         }
233 
234         if (join_cgroup(path)) {
235                 fprintf(stderr,
236                         "#%d %s: Failed to join cgroup '%s' (errno=%d)\n",
237                         env.test->test_num, env.test->test_name, path, errno);
238                 return -1;
239         }
240 
241         return fd;
242 }
243 
244 int bpf_find_map(const char *test, struct bpf_object *obj, const char *name)
245 {
246         struct bpf_map *map;
247 
248         map = bpf_object__find_map_by_name(obj, name);
249         if (!map) {
250                 fprintf(stdout, "%s:FAIL:map '%s' not found\n", test, name);
251                 test__fail();
252                 return -1;
253         }
254         return bpf_map__fd(map);
255 }
256 
257 static bool is_jit_enabled(void)
258 {
259         const char *jit_sysctl = "/proc/sys/net/core/bpf_jit_enable";
260         bool enabled = false;
261         int sysctl_fd;
262 
263         sysctl_fd = open(jit_sysctl, 0, O_RDONLY);
264         if (sysctl_fd != -1) {
265                 char tmpc;
266 
267                 if (read(sysctl_fd, &tmpc, sizeof(tmpc)) == 1)
268                         enabled = (tmpc != '');
269                 close(sysctl_fd);
270         }
271 
272         return enabled;
273 }
274 
275 int compare_map_keys(int map1_fd, int map2_fd)
276 {
277         __u32 key, next_key;
278         char val_buf[PERF_MAX_STACK_DEPTH *
279                      sizeof(struct bpf_stack_build_id)];
280         int err;
281 
282         err = bpf_map_get_next_key(map1_fd, NULL, &key);
283         if (err)
284                 return err;
285         err = bpf_map_lookup_elem(map2_fd, &key, val_buf);
286         if (err)
287                 return err;
288 
289         while (bpf_map_get_next_key(map1_fd, &key, &next_key) == 0) {
290                 err = bpf_map_lookup_elem(map2_fd, &next_key, val_buf);
291                 if (err)
292                         return err;
293 
294                 key = next_key;
295         }
296         if (errno != ENOENT)
297                 return -1;
298 
299         return 0;
300 }
301 
302 int compare_stack_ips(int smap_fd, int amap_fd, int stack_trace_len)
303 {
304         __u32 key, next_key, *cur_key_p, *next_key_p;
305         char *val_buf1, *val_buf2;
306         int i, err = 0;
307 
308         val_buf1 = malloc(stack_trace_len);
309         val_buf2 = malloc(stack_trace_len);
310         cur_key_p = NULL;
311         next_key_p = &key;
312         while (bpf_map_get_next_key(smap_fd, cur_key_p, next_key_p) == 0) {
313                 err = bpf_map_lookup_elem(smap_fd, next_key_p, val_buf1);
314                 if (err)
315                         goto out;
316                 err = bpf_map_lookup_elem(amap_fd, next_key_p, val_buf2);
317                 if (err)
318                         goto out;
319                 for (i = 0; i < stack_trace_len; i++) {
320                         if (val_buf1[i] != val_buf2[i]) {
321                                 err = -1;
322                                 goto out;
323                         }
324                 }
325                 key = *next_key_p;
326                 cur_key_p = &key;
327                 next_key_p = &next_key;
328         }
329         if (errno != ENOENT)
330                 err = -1;
331 
332 out:
333         free(val_buf1);
334         free(val_buf2);
335         return err;
336 }
337 
338 int extract_build_id(char *build_id, size_t size)
339 {
340         FILE *fp;
341         char *line = NULL;
342         size_t len = 0;
343 
344         fp = popen("readelf -n ./urandom_read | grep 'Build ID'", "r");
345         if (fp == NULL)
346                 return -1;
347 
348         if (getline(&line, &len, fp) == -1)
349                 goto err;
350         fclose(fp);
351 
352         if (len > size)
353                 len = size;
354         memcpy(build_id, line, len);
355         build_id[len] = '\0';
356         free(line);
357         return 0;
358 err:
359         fclose(fp);
360         return -1;
361 }
362 
363 /* extern declarations for test funcs */
364 #define DEFINE_TEST(name) extern void test_##name(void);
365 #include <prog_tests/tests.h>
366 #undef DEFINE_TEST
367 
368 static struct prog_test_def prog_test_defs[] = {
369 #define DEFINE_TEST(name) {             \
370         .test_name = #name,             \
371         .run_test = &test_##name,       \
372 },
373 #include <prog_tests/tests.h>
374 #undef DEFINE_TEST
375 };
376 const int prog_test_cnt = ARRAY_SIZE(prog_test_defs);
377 
378 const char *argp_program_version = "test_progs 0.1";
379 const char *argp_program_bug_address = "<bpf@vger.kernel.org>";
380 const char argp_program_doc[] = "BPF selftests test runner";
381 
382 enum ARG_KEYS {
383         ARG_TEST_NUM = 'n',
384         ARG_TEST_NAME = 't',
385         ARG_TEST_NAME_BLACKLIST = 'b',
386         ARG_VERIFIER_STATS = 's',
387         ARG_VERBOSE = 'v',
388         ARG_GET_TEST_CNT = 'c',
389         ARG_LIST_TEST_NAMES = 'l',
390 };
391 
392 static const struct argp_option opts[] = {
393         { "num", ARG_TEST_NUM, "NUM", 0,
394           "Run test number NUM only " },
395         { "name", ARG_TEST_NAME, "NAMES", 0,
396           "Run tests with names containing any string from NAMES list" },
397         { "name-blacklist", ARG_TEST_NAME_BLACKLIST, "NAMES", 0,
398           "Don't run tests with names containing any string from NAMES list" },
399         { "verifier-stats", ARG_VERIFIER_STATS, NULL, 0,
400           "Output verifier statistics", },
401         { "verbose", ARG_VERBOSE, "LEVEL", OPTION_ARG_OPTIONAL,
402           "Verbose output (use -vv or -vvv for progressively verbose output)" },
403         { "count", ARG_GET_TEST_CNT, NULL, 0,
404           "Get number of selected top-level tests " },
405         { "list", ARG_LIST_TEST_NAMES, NULL, 0,
406           "List test names that would run (without running them) " },
407         {},
408 };
409 
410 static int libbpf_print_fn(enum libbpf_print_level level,
411                            const char *format, va_list args)
412 {
413         if (env.verbosity < VERBOSE_VERY && level == LIBBPF_DEBUG)
414                 return 0;
415         vfprintf(stdout, format, args);
416         return 0;
417 }
418 
419 static void free_str_set(const struct str_set *set)
420 {
421         int i;
422 
423         if (!set)
424                 return;
425 
426         for (i = 0; i < set->cnt; i++)
427                 free((void *)set->strs[i]);
428         free(set->strs);
429 }
430 
431 static int parse_str_list(const char *s, struct str_set *set)
432 {
433         char *input, *state = NULL, *next, **tmp, **strs = NULL;
434         int cnt = 0;
435 
436         input = strdup(s);
437         if (!input)
438                 return -ENOMEM;
439 
440         set->cnt = 0;
441         set->strs = NULL;
442 
443         while ((next = strtok_r(state ? NULL : input, ",", &state))) {
444                 tmp = realloc(strs, sizeof(*strs) * (cnt + 1));
445                 if (!tmp)
446                         goto err;
447                 strs = tmp;
448 
449                 strs[cnt] = strdup(next);
450                 if (!strs[cnt])
451                         goto err;
452 
453                 cnt++;
454         }
455 
456         set->cnt = cnt;
457         set->strs = (const char **)strs;
458         free(input);
459         return 0;
460 err:
461         free(strs);
462         free(input);
463         return -ENOMEM;
464 }
465 
466 extern int extra_prog_load_log_flags;
467 
468 static error_t parse_arg(int key, char *arg, struct argp_state *state)
469 {
470         struct test_env *env = state->input;
471 
472         switch (key) {
473         case ARG_TEST_NUM: {
474                 char *subtest_str = strchr(arg, '/');
475 
476                 if (subtest_str) {
477                         *subtest_str = '\0';
478                         if (parse_num_list(subtest_str + 1,
479                                            &env->subtest_selector.num_set,
480                                            &env->subtest_selector.num_set_len)) {
481                                 fprintf(stderr,
482                                         "Failed to parse subtest numbers.\n");
483                                 return -EINVAL;
484                         }
485                 }
486                 if (parse_num_list(arg, &env->test_selector.num_set,
487                                    &env->test_selector.num_set_len)) {
488                         fprintf(stderr, "Failed to parse test numbers.\n");
489                         return -EINVAL;
490                 }
491                 break;
492         }
493         case ARG_TEST_NAME: {
494                 char *subtest_str = strchr(arg, '/');
495 
496                 if (subtest_str) {
497                         *subtest_str = '\0';
498                         if (parse_str_list(subtest_str + 1,
499                                            &env->subtest_selector.whitelist))
500                                 return -ENOMEM;
501                 }
502                 if (parse_str_list(arg, &env->test_selector.whitelist))
503                         return -ENOMEM;
504                 break;
505         }
506         case ARG_TEST_NAME_BLACKLIST: {
507                 char *subtest_str = strchr(arg, '/');
508 
509                 if (subtest_str) {
510                         *subtest_str = '\0';
511                         if (parse_str_list(subtest_str + 1,
512                                            &env->subtest_selector.blacklist))
513                                 return -ENOMEM;
514                 }
515                 if (parse_str_list(arg, &env->test_selector.blacklist))
516                         return -ENOMEM;
517                 break;
518         }
519         case ARG_VERIFIER_STATS:
520                 env->verifier_stats = true;
521                 break;
522         case ARG_VERBOSE:
523                 env->verbosity = VERBOSE_NORMAL;
524                 if (arg) {
525                         if (strcmp(arg, "v") == 0) {
526                                 env->verbosity = VERBOSE_VERY;
527                                 extra_prog_load_log_flags = 1;
528                         } else if (strcmp(arg, "vv") == 0) {
529                                 env->verbosity = VERBOSE_SUPER;
530                                 extra_prog_load_log_flags = 2;
531                         } else {
532                                 fprintf(stderr,
533                                         "Unrecognized verbosity setting ('%s'), only -v and -vv are supported\n",
534                                         arg);
535                                 return -EINVAL;
536                         }
537                 }
538                 break;
539         case ARG_GET_TEST_CNT:
540                 env->get_test_cnt = true;
541                 break;
542         case ARG_LIST_TEST_NAMES:
543                 env->list_test_names = true;
544                 break;
545         case ARGP_KEY_ARG:
546                 argp_usage(state);
547                 break;
548         case ARGP_KEY_END:
549                 break;
550         default:
551                 return ARGP_ERR_UNKNOWN;
552         }
553         return 0;
554 }
555 
556 static void stdio_hijack(void)
557 {
558 #ifdef __GLIBC__
559         env.stdout = stdout;
560         env.stderr = stderr;
561 
562         if (env.verbosity > VERBOSE_NONE) {
563                 /* nothing to do, output to stdout by default */
564                 return;
565         }
566 
567         /* stdout and stderr -> buffer */
568         fflush(stdout);
569 
570         stdout = open_memstream(&env.log_buf, &env.log_cnt);
571         if (!stdout) {
572                 stdout = env.stdout;
573                 perror("open_memstream");
574                 return;
575         }
576 
577         stderr = stdout;
578 #endif
579 }
580 
581 static void stdio_restore(void)
582 {
583 #ifdef __GLIBC__
584         if (stdout == env.stdout)
585                 return;
586 
587         fclose(stdout);
588         free(env.log_buf);
589 
590         env.log_buf = NULL;
591         env.log_cnt = 0;
592 
593         stdout = env.stdout;
594         stderr = env.stderr;
595 #endif
596 }
597 
598 /*
599  * Determine if test_progs is running as a "flavored" test runner and switch
600  * into corresponding sub-directory to load correct BPF objects.
601  *
602  * This is done by looking at executable name. If it contains "-flavor"
603  * suffix, then we are running as a flavored test runner.
604  */
605 int cd_flavor_subdir(const char *exec_name)
606 {
607         /* General form of argv[0] passed here is:
608          * some/path/to/test_progs[-flavor], where -flavor part is optional.
609          * First cut out "test_progs[-flavor]" part, then extract "flavor"
610          * part, if it's there.
611          */
612         const char *flavor = strrchr(exec_name, '/');
613 
614         if (!flavor)
615                 return 0;
616         flavor++;
617         flavor = strrchr(flavor, '-');
618         if (!flavor)
619                 return 0;
620         flavor++;
621         if (env.verbosity > VERBOSE_NONE)
622                 fprintf(stdout, "Switching to flavor '%s' subdirectory...\n", flavor);
623 
624         return chdir(flavor);
625 }
626 
627 #define MAX_BACKTRACE_SZ 128
628 void crash_handler(int signum)
629 {
630         void *bt[MAX_BACKTRACE_SZ];
631         size_t sz;
632 
633         sz = backtrace(bt, ARRAY_SIZE(bt));
634 
635         if (env.test)
636                 dump_test_log(env.test, true);
637         if (env.stdout)
638                 stdio_restore();
639 
640         fprintf(stderr, "Caught signal #%d!\nStack trace:\n", signum);
641         backtrace_symbols_fd(bt, sz, STDERR_FILENO);
642 }
643 
644 int main(int argc, char **argv)
645 {
646         static const struct argp argp = {
647                 .options = opts,
648                 .parser = parse_arg,
649                 .doc = argp_program_doc,
650         };
651         struct sigaction sigact = {
652                 .sa_handler = crash_handler,
653                 .sa_flags = SA_RESETHAND,
654         };
655         int err, i;
656 
657         sigaction(SIGSEGV, &sigact, NULL);
658 
659         err = argp_parse(&argp, argc, argv, 0, NULL, &env);
660         if (err)
661                 return err;
662 
663         err = cd_flavor_subdir(argv[0]);
664         if (err)
665                 return err;
666 
667         libbpf_set_print(libbpf_print_fn);
668 
669         srand(time(NULL));
670 
671         env.jit_enabled = is_jit_enabled();
672         env.nr_cpus = libbpf_num_possible_cpus();
673         if (env.nr_cpus < 0) {
674                 fprintf(stderr, "Failed to get number of CPUs: %d!\n",
675                         env.nr_cpus);
676                 return -1;
677         }
678 
679         save_netns();
680         stdio_hijack();
681         for (i = 0; i < prog_test_cnt; i++) {
682                 struct prog_test_def *test = &prog_test_defs[i];
683 
684                 env.test = test;
685                 test->test_num = i + 1;
686 
687                 if (!should_run(&env.test_selector,
688                                 test->test_num, test->test_name))
689                         continue;
690 
691                 if (env.get_test_cnt) {
692                         env.succ_cnt++;
693                         continue;
694                 }
695 
696                 if (env.list_test_names) {
697                         fprintf(env.stdout, "%s\n", test->test_name);
698                         env.succ_cnt++;
699                         continue;
700                 }
701 
702                 test->run_test();
703                 /* ensure last sub-test is finalized properly */
704                 if (test->subtest_name)
705                         test__end_subtest();
706 
707                 test->tested = true;
708                 if (test->error_cnt)
709                         env.fail_cnt++;
710                 else
711                         env.succ_cnt++;
712                 skip_account();
713 
714                 dump_test_log(test, test->error_cnt);
715 
716                 fprintf(env.stdout, "#%d %s:%s\n",
717                         test->test_num, test->test_name,
718                         test->error_cnt ? "FAIL" : "OK");
719 
720                 reset_affinity();
721                 restore_netns();
722                 if (test->need_cgroup_cleanup)
723                         cleanup_cgroup_environment();
724         }
725         stdio_restore();
726 
727         if (env.get_test_cnt) {
728                 printf("%d\n", env.succ_cnt);
729                 goto out;
730         }
731 
732         if (env.list_test_names)
733                 goto out;
734 
735         fprintf(stdout, "Summary: %d/%d PASSED, %d SKIPPED, %d FAILED\n",
736                 env.succ_cnt, env.sub_succ_cnt, env.skip_cnt, env.fail_cnt);
737 
738 out:
739         free_str_set(&env.test_selector.blacklist);
740         free_str_set(&env.test_selector.whitelist);
741         free(env.test_selector.num_set);
742         free_str_set(&env.subtest_selector.blacklist);
743         free_str_set(&env.subtest_selector.whitelist);
744         free(env.subtest_selector.num_set);
745         close(env.saved_netns_fd);
746 
747         if (env.succ_cnt + env.fail_cnt + env.skip_cnt == 0)
748                 return EXIT_NO_TEST;
749 
750         return env.fail_cnt ? EXIT_FAILURE : EXIT_SUCCESS;
751 }
752 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp