| 1 | |
| 2 | #include "debug.h"
|
| 3 | #include "evlist.h"
|
| 4 | #include "evsel.h"
|
| 5 | #include "target.h"
|
| 6 | #include "thread_map.h"
|
| 7 | #include "tests.h"
|
| 8 | #include "util/mmap.h"
|
| 9 |
|
| 10 | #include <errno.h>
|
| 11 | #include <signal.h>
|
| 12 | #include <linux/string.h>
|
| 13 | #include <perf/cpumap.h>
|
| 14 | #include <perf/evlist.h>
|
| 15 | #include <perf/mmap.h>
|
| 16 |
|
| 17 | static int exited;
|
| 18 | static int nr_exit;
|
| 19 |
|
| 20 | static void sig_handler(int sig __maybe_unused)
|
| 21 | {
|
| 22 | exited = 1;
|
| 23 | }
|
| 24 |
|
| 25 | |
| 26 | * evlist__prepare_workload will send a SIGUSR1 if the fork fails, since
|
| 27 | * we asked by setting its exec_error to this handler.
|
| 28 |
|
| 29 | static void workload_exec_failed_signal(int signo __maybe_unused,
|
| 30 | siginfo_t *info __maybe_unused,
|
| 31 | void *ucontext __maybe_unused)
|
| 32 | {
|
| 33 | exited = 1;
|
| 34 | nr_exit = -1;
|
| 35 | }
|
| 36 |
|
| 37 | |
| 38 | * This test will start a workload that does nothing then it checks
|
| 39 | * if the number of exit event reported by the kernel is 1 or not
|
| 40 | * in order to check the kernel returns correct number of event.
|
| 41 |
|
| 42 | static int test__task_exit(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
|
| 43 | {
|
| 44 | int err = -1;
|
| 45 | union perf_event *event;
|
| 46 | struct evsel *evsel;
|
| 47 | struct evlist *evlist;
|
| 48 | struct target target = {
|
| 49 | .uses_mmap = true,
|
| 50 | };
|
| 51 | const char *argv[] = { "true", NULL };
|
| 52 | char sbuf[STRERR_BUFSIZE];
|
| 53 | struct perf_cpu_map *cpus;
|
| 54 | struct perf_thread_map *threads;
|
| 55 | struct mmap *md;
|
| 56 | int retry_count = 0;
|
| 57 |
|
| 58 | signal(SIGCHLD, sig_handler);
|
| 59 |
|
| 60 | evlist = evlist__new_dummy();
|
| 61 | if (evlist == NULL) {
|
| 62 | pr_debug("evlist__new_dummy\n");
|
| 63 | return -1;
|
| 64 | }
|
| 65 |
|
| 66 | |
| 67 | * Create maps of threads and cpus to monitor. In this case
|
| 68 | * we start with all threads and cpus (-1, -1) but then in
|
| 69 | * evlist__prepare_workload we'll fill in the only thread
|
| 70 | * we're monitoring, the one forked there.
|
| 71 |
|
| 72 | cpus = perf_cpu_map__new_any_cpu();
|
| 73 | threads = thread_map__new_by_tid(-1);
|
| 74 | if (!cpus || !threads) {
|
| 75 | err = -ENOMEM;
|
| 76 | pr_debug("Not enough memory to create thread/cpu maps\n");
|
| 77 | goto out_put_evlist;
|
| 78 | }
|
| 79 |
|
| 80 | perf_evlist__set_maps(evlist__core(evlist), cpus, threads);
|
| 81 |
|
| 82 | err = evlist__prepare_workload(evlist, &target, argv, false, workload_exec_failed_signal);
|
| 83 | if (err < 0) {
|
| 84 | pr_debug("Couldn't run the workload!\n");
|
| 85 | goto out_put_evlist;
|
| 86 | }
|
| 87 |
|
| 88 | evsel = evlist__first(evlist);
|
| 89 | evsel->core.attr.task = 1;
|
| 90 | #ifdef __s390x__
|
| 91 | evsel->core.attr.sample_freq = 1000000;
|
| 92 | #else
|
| 93 | evsel->core.attr.sample_freq = 1;
|
| 94 | #endif
|
| 95 | evsel->core.attr.inherit = 0;
|
| 96 | evsel->core.attr.watermark = 0;
|
| 97 | evsel->core.attr.wakeup_events = 1;
|
| 98 | evsel->core.attr.exclude_kernel = 1;
|
| 99 |
|
| 100 | err = evlist__open(evlist);
|
| 101 | if (err < 0) {
|
| 102 | pr_debug("Couldn't open the evlist: %s\n",
|
| 103 | str_error_r(-err, sbuf, sizeof(sbuf)));
|
| 104 | goto out_put_evlist;
|
| 105 | }
|
| 106 |
|
| 107 | if (evlist__do_mmap(evlist, 128) < 0) {
|
| 108 | pr_debug("failed to mmap events: %d (%s)\n", errno,
|
| 109 | str_error_r(errno, sbuf, sizeof(sbuf)));
|
| 110 | err = -1;
|
| 111 | goto out_put_evlist;
|
| 112 | }
|
| 113 |
|
| 114 | evlist__start_workload(evlist);
|
| 115 |
|
| 116 | retry:
|
| 117 | md = &evlist__mmap(evlist)[0];
|
| 118 | if (perf_mmap__read_init(&md->core) < 0)
|
| 119 | goto out_init;
|
| 120 |
|
| 121 | while ((event = perf_mmap__read_event(&md->core)) != NULL) {
|
| 122 | if (event->header.type == PERF_RECORD_EXIT)
|
| 123 | nr_exit++;
|
| 124 |
|
| 125 | perf_mmap__consume(&md->core);
|
| 126 | }
|
| 127 | perf_mmap__read_done(&md->core);
|
| 128 |
|
| 129 | out_init:
|
| 130 | if (!exited || !nr_exit) {
|
| 131 | evlist__poll(evlist, -1);
|
| 132 |
|
| 133 | if (retry_count++ > 1000) {
|
| 134 | pr_debug("Failed after retrying 1000 times\n");
|
| 135 | err = -1;
|
| 136 | goto out_put_evlist;
|
| 137 | }
|
| 138 |
|
| 139 | goto retry;
|
| 140 | }
|
| 141 |
|
| 142 | if (nr_exit != 1) {
|
| 143 | pr_debug("received %d EXIT records\n", nr_exit);
|
| 144 | err = -1;
|
| 145 | }
|
| 146 |
|
| 147 | out_put_evlist:
|
| 148 | perf_cpu_map__put(cpus);
|
| 149 | perf_thread_map__put(threads);
|
| 150 | evlist__put(evlist);
|
| 151 | return err;
|
| 152 | }
|
| 153 |
|
| 154 | struct test_case tests__task_exit[] = {
|
| 155 | TEST_CASE_EXCLUSIVE("Number of exit events of a simple workload", task_exit),
|
| 156 | { .name = NULL, }
|
| 157 | };
|
| 158 | struct test_suite suite__task_exit = {
|
| 159 | .desc = "Number of exit events of a simple workload",
|
| 160 | .test_cases = tests__task_exit,
|
| 161 | };
|