Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 1 | #include <sched.h> |
| 2 | #include "evlist.h" |
| 3 | #include "evsel.h" |
| 4 | #include "perf.h" |
| 5 | #include "debug.h" |
| 6 | #include "tests.h" |
| 7 | |
| 8 | static int sched__get_first_possible_cpu(pid_t pid, cpu_set_t *maskp) |
| 9 | { |
| 10 | int i, cpu = -1, nrcpus = 1024; |
| 11 | realloc: |
| 12 | CPU_ZERO(maskp); |
| 13 | |
| 14 | if (sched_getaffinity(pid, sizeof(*maskp), maskp) == -1) { |
| 15 | if (errno == EINVAL && nrcpus < (1024 << 8)) { |
| 16 | nrcpus = nrcpus << 2; |
| 17 | goto realloc; |
| 18 | } |
| 19 | perror("sched_getaffinity"); |
| 20 | return -1; |
| 21 | } |
| 22 | |
| 23 | for (i = 0; i < nrcpus; i++) { |
| 24 | if (CPU_ISSET(i, maskp)) { |
| 25 | if (cpu == -1) |
| 26 | cpu = i; |
| 27 | else |
| 28 | CPU_CLR(i, maskp); |
| 29 | } |
| 30 | } |
| 31 | |
| 32 | return cpu; |
| 33 | } |
| 34 | |
Arnaldo Carvalho de Melo | 721a1f5 | 2015-11-19 12:01:48 -0300 | [diff] [blame] | 35 | int test__PERF_RECORD(int subtest __maybe_unused) |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 36 | { |
Arnaldo Carvalho de Melo | b400679 | 2013-12-19 14:43:45 -0300 | [diff] [blame] | 37 | struct record_opts opts = { |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 38 | .target = { |
| 39 | .uid = UINT_MAX, |
| 40 | .uses_mmap = true, |
| 41 | }, |
Arnaldo Carvalho de Melo | 509051e | 2014-01-14 17:52:14 -0300 | [diff] [blame] | 42 | .no_buffering = true, |
Arnaldo Carvalho de Melo | 509051e | 2014-01-14 17:52:14 -0300 | [diff] [blame] | 43 | .mmap_pages = 256, |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 44 | }; |
| 45 | cpu_set_t cpu_mask; |
| 46 | size_t cpu_mask_size = sizeof(cpu_mask); |
Arnaldo Carvalho de Melo | 69ef8f4 | 2016-01-07 13:17:00 -0300 | [diff] [blame] | 47 | struct perf_evlist *evlist = perf_evlist__new_dummy(); |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 48 | struct perf_evsel *evsel; |
| 49 | struct perf_sample sample; |
| 50 | const char *cmd = "sleep"; |
| 51 | const char *argv[] = { cmd, "1", NULL, }; |
Stephane Eranian | 5c5e854 | 2013-08-21 12:10:25 +0200 | [diff] [blame] | 52 | char *bname, *mmap_filename; |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 53 | u64 prev_time = 0; |
| 54 | bool found_cmd_mmap = false, |
| 55 | found_libc_mmap = false, |
| 56 | found_vdso_mmap = false, |
| 57 | found_ld_mmap = false; |
| 58 | int err = -1, errs = 0, i, wakeups = 0; |
| 59 | u32 cpu; |
| 60 | int total_events = 0, nr_events[PERF_RECORD_MAX] = { 0, }; |
Masami Hiramatsu | ba3dfff | 2014-08-14 02:22:45 +0000 | [diff] [blame] | 61 | char sbuf[STRERR_BUFSIZE]; |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 62 | |
Arnaldo Carvalho de Melo | 69ef8f4 | 2016-01-07 13:17:00 -0300 | [diff] [blame] | 63 | if (evlist == NULL) /* Fallback for kernels lacking PERF_COUNT_SW_DUMMY */ |
| 64 | evlist = perf_evlist__new_default(); |
| 65 | |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 66 | if (evlist == NULL || argv == NULL) { |
| 67 | pr_debug("Not enough memory to create evlist\n"); |
| 68 | goto out; |
| 69 | } |
| 70 | |
| 71 | /* |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 72 | * Create maps of threads and cpus to monitor. In this case |
| 73 | * we start with all threads and cpus (-1, -1) but then in |
| 74 | * perf_evlist__prepare_workload we'll fill in the only thread |
| 75 | * we're monitoring, the one forked there. |
| 76 | */ |
| 77 | err = perf_evlist__create_maps(evlist, &opts.target); |
| 78 | if (err < 0) { |
| 79 | pr_debug("Not enough memory to create thread/cpu maps\n"); |
| 80 | goto out_delete_evlist; |
| 81 | } |
| 82 | |
| 83 | /* |
| 84 | * Prepare the workload in argv[] to run, it'll fork it, and then wait |
| 85 | * for perf_evlist__start_workload() to exec it. This is done this way |
| 86 | * so that we have time to open the evlist (calling sys_perf_event_open |
| 87 | * on all the fds) and then mmap them. |
| 88 | */ |
Arnaldo Carvalho de Melo | 735f7e0 | 2014-01-03 14:56:49 -0300 | [diff] [blame] | 89 | err = perf_evlist__prepare_workload(evlist, &opts.target, argv, false, NULL); |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 90 | if (err < 0) { |
| 91 | pr_debug("Couldn't run the workload!\n"); |
Arnaldo Carvalho de Melo | 03ad974 | 2014-01-03 15:56:06 -0300 | [diff] [blame] | 92 | goto out_delete_evlist; |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 93 | } |
| 94 | |
| 95 | /* |
| 96 | * Config the evsels, setting attr->comm on the first one, etc. |
| 97 | */ |
| 98 | evsel = perf_evlist__first(evlist); |
Arnaldo Carvalho de Melo | 7be5ebe | 2012-12-10 14:53:43 -0300 | [diff] [blame] | 99 | perf_evsel__set_sample_bit(evsel, CPU); |
| 100 | perf_evsel__set_sample_bit(evsel, TID); |
| 101 | perf_evsel__set_sample_bit(evsel, TIME); |
Arnaldo Carvalho de Melo | f77a951 | 2012-12-10 16:41:31 -0300 | [diff] [blame] | 102 | perf_evlist__config(evlist, &opts); |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 103 | |
| 104 | err = sched__get_first_possible_cpu(evlist->workload.pid, &cpu_mask); |
| 105 | if (err < 0) { |
Masami Hiramatsu | ba3dfff | 2014-08-14 02:22:45 +0000 | [diff] [blame] | 106 | pr_debug("sched__get_first_possible_cpu: %s\n", |
| 107 | strerror_r(errno, sbuf, sizeof(sbuf))); |
Arnaldo Carvalho de Melo | 03ad974 | 2014-01-03 15:56:06 -0300 | [diff] [blame] | 108 | goto out_delete_evlist; |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 109 | } |
| 110 | |
| 111 | cpu = err; |
| 112 | |
| 113 | /* |
| 114 | * So that we can check perf_sample.cpu on all the samples. |
| 115 | */ |
| 116 | if (sched_setaffinity(evlist->workload.pid, cpu_mask_size, &cpu_mask) < 0) { |
Masami Hiramatsu | ba3dfff | 2014-08-14 02:22:45 +0000 | [diff] [blame] | 117 | pr_debug("sched_setaffinity: %s\n", |
| 118 | strerror_r(errno, sbuf, sizeof(sbuf))); |
Arnaldo Carvalho de Melo | 03ad974 | 2014-01-03 15:56:06 -0300 | [diff] [blame] | 119 | goto out_delete_evlist; |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 120 | } |
| 121 | |
| 122 | /* |
| 123 | * Call sys_perf_event_open on all the fds on all the evsels, |
| 124 | * grouping them if asked to. |
| 125 | */ |
| 126 | err = perf_evlist__open(evlist); |
| 127 | if (err < 0) { |
Masami Hiramatsu | ba3dfff | 2014-08-14 02:22:45 +0000 | [diff] [blame] | 128 | pr_debug("perf_evlist__open: %s\n", |
| 129 | strerror_r(errno, sbuf, sizeof(sbuf))); |
Arnaldo Carvalho de Melo | 03ad974 | 2014-01-03 15:56:06 -0300 | [diff] [blame] | 130 | goto out_delete_evlist; |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 131 | } |
| 132 | |
| 133 | /* |
| 134 | * mmap the first fd on a given CPU and ask for events for the other |
| 135 | * fds in the same CPU to be injected in the same mmap ring buffer |
| 136 | * (using ioctl(PERF_EVENT_IOC_SET_OUTPUT)). |
| 137 | */ |
| 138 | err = perf_evlist__mmap(evlist, opts.mmap_pages, false); |
| 139 | if (err < 0) { |
Masami Hiramatsu | ba3dfff | 2014-08-14 02:22:45 +0000 | [diff] [blame] | 140 | pr_debug("perf_evlist__mmap: %s\n", |
| 141 | strerror_r(errno, sbuf, sizeof(sbuf))); |
Arnaldo Carvalho de Melo | f26e1c7 | 2014-01-03 16:54:12 -0300 | [diff] [blame] | 142 | goto out_delete_evlist; |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 143 | } |
| 144 | |
| 145 | /* |
| 146 | * Now that all is properly set up, enable the events, they will |
| 147 | * count just on workload.pid, which will start... |
| 148 | */ |
| 149 | perf_evlist__enable(evlist); |
| 150 | |
| 151 | /* |
| 152 | * Now! |
| 153 | */ |
| 154 | perf_evlist__start_workload(evlist); |
| 155 | |
| 156 | while (1) { |
| 157 | int before = total_events; |
| 158 | |
| 159 | for (i = 0; i < evlist->nr_mmaps; i++) { |
| 160 | union perf_event *event; |
| 161 | |
| 162 | while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) { |
| 163 | const u32 type = event->header.type; |
| 164 | const char *name = perf_event__name(type); |
| 165 | |
| 166 | ++total_events; |
| 167 | if (type < PERF_RECORD_MAX) |
| 168 | nr_events[type]++; |
| 169 | |
| 170 | err = perf_evlist__parse_sample(evlist, event, &sample); |
| 171 | if (err < 0) { |
| 172 | if (verbose) |
| 173 | perf_event__fprintf(event, stderr); |
| 174 | pr_debug("Couldn't parse sample\n"); |
Arnaldo Carvalho de Melo | 983874d | 2014-01-03 17:25:49 -0300 | [diff] [blame] | 175 | goto out_delete_evlist; |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 176 | } |
| 177 | |
| 178 | if (verbose) { |
| 179 | pr_info("%" PRIu64" %d ", sample.time, sample.cpu); |
| 180 | perf_event__fprintf(event, stderr); |
| 181 | } |
| 182 | |
| 183 | if (prev_time > sample.time) { |
| 184 | pr_debug("%s going backwards in time, prev=%" PRIu64 ", curr=%" PRIu64 "\n", |
| 185 | name, prev_time, sample.time); |
| 186 | ++errs; |
| 187 | } |
| 188 | |
| 189 | prev_time = sample.time; |
| 190 | |
| 191 | if (sample.cpu != cpu) { |
| 192 | pr_debug("%s with unexpected cpu, expected %d, got %d\n", |
| 193 | name, cpu, sample.cpu); |
| 194 | ++errs; |
| 195 | } |
| 196 | |
| 197 | if ((pid_t)sample.pid != evlist->workload.pid) { |
| 198 | pr_debug("%s with unexpected pid, expected %d, got %d\n", |
| 199 | name, evlist->workload.pid, sample.pid); |
| 200 | ++errs; |
| 201 | } |
| 202 | |
| 203 | if ((pid_t)sample.tid != evlist->workload.pid) { |
| 204 | pr_debug("%s with unexpected tid, expected %d, got %d\n", |
| 205 | name, evlist->workload.pid, sample.tid); |
| 206 | ++errs; |
| 207 | } |
| 208 | |
| 209 | if ((type == PERF_RECORD_COMM || |
| 210 | type == PERF_RECORD_MMAP || |
Stephane Eranian | 5c5e854 | 2013-08-21 12:10:25 +0200 | [diff] [blame] | 211 | type == PERF_RECORD_MMAP2 || |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 212 | type == PERF_RECORD_FORK || |
| 213 | type == PERF_RECORD_EXIT) && |
| 214 | (pid_t)event->comm.pid != evlist->workload.pid) { |
| 215 | pr_debug("%s with unexpected pid/tid\n", name); |
| 216 | ++errs; |
| 217 | } |
| 218 | |
| 219 | if ((type == PERF_RECORD_COMM || |
Stephane Eranian | 5c5e854 | 2013-08-21 12:10:25 +0200 | [diff] [blame] | 220 | type == PERF_RECORD_MMAP || |
| 221 | type == PERF_RECORD_MMAP2) && |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 222 | event->comm.pid != event->comm.tid) { |
| 223 | pr_debug("%s with different pid/tid!\n", name); |
| 224 | ++errs; |
| 225 | } |
| 226 | |
| 227 | switch (type) { |
| 228 | case PERF_RECORD_COMM: |
| 229 | if (strcmp(event->comm.comm, cmd)) { |
| 230 | pr_debug("%s with unexpected comm!\n", name); |
| 231 | ++errs; |
| 232 | } |
| 233 | break; |
| 234 | case PERF_RECORD_EXIT: |
| 235 | goto found_exit; |
| 236 | case PERF_RECORD_MMAP: |
Stephane Eranian | 5c5e854 | 2013-08-21 12:10:25 +0200 | [diff] [blame] | 237 | mmap_filename = event->mmap.filename; |
| 238 | goto check_bname; |
| 239 | case PERF_RECORD_MMAP2: |
| 240 | mmap_filename = event->mmap2.filename; |
| 241 | check_bname: |
| 242 | bname = strrchr(mmap_filename, '/'); |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 243 | if (bname != NULL) { |
| 244 | if (!found_cmd_mmap) |
| 245 | found_cmd_mmap = !strcmp(bname + 1, cmd); |
| 246 | if (!found_libc_mmap) |
| 247 | found_libc_mmap = !strncmp(bname + 1, "libc", 4); |
| 248 | if (!found_ld_mmap) |
| 249 | found_ld_mmap = !strncmp(bname + 1, "ld", 2); |
| 250 | } else if (!found_vdso_mmap) |
Stephane Eranian | 5c5e854 | 2013-08-21 12:10:25 +0200 | [diff] [blame] | 251 | found_vdso_mmap = !strcmp(mmap_filename, "[vdso]"); |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 252 | break; |
| 253 | |
| 254 | case PERF_RECORD_SAMPLE: |
| 255 | /* Just ignore samples for now */ |
| 256 | break; |
| 257 | default: |
| 258 | pr_debug("Unexpected perf_event->header.type %d!\n", |
| 259 | type); |
| 260 | ++errs; |
| 261 | } |
Zhouyi Zhou | 8e50d38 | 2013-10-24 15:43:33 +0800 | [diff] [blame] | 262 | |
| 263 | perf_evlist__mmap_consume(evlist, i); |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 264 | } |
| 265 | } |
| 266 | |
| 267 | /* |
| 268 | * We don't use poll here because at least at 3.1 times the |
| 269 | * PERF_RECORD_{!SAMPLE} events don't honour |
| 270 | * perf_event_attr.wakeup_events, just PERF_EVENT_SAMPLE does. |
| 271 | */ |
| 272 | if (total_events == before && false) |
Arnaldo Carvalho de Melo | f66a889d | 2014-08-18 17:25:59 -0300 | [diff] [blame] | 273 | perf_evlist__poll(evlist, -1); |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 274 | |
| 275 | sleep(1); |
| 276 | if (++wakeups > 5) { |
| 277 | pr_debug("No PERF_RECORD_EXIT event!\n"); |
| 278 | break; |
| 279 | } |
| 280 | } |
| 281 | |
| 282 | found_exit: |
| 283 | if (nr_events[PERF_RECORD_COMM] > 1) { |
| 284 | pr_debug("Excessive number of PERF_RECORD_COMM events!\n"); |
| 285 | ++errs; |
| 286 | } |
| 287 | |
| 288 | if (nr_events[PERF_RECORD_COMM] == 0) { |
| 289 | pr_debug("Missing PERF_RECORD_COMM for %s!\n", cmd); |
| 290 | ++errs; |
| 291 | } |
| 292 | |
| 293 | if (!found_cmd_mmap) { |
| 294 | pr_debug("PERF_RECORD_MMAP for %s missing!\n", cmd); |
| 295 | ++errs; |
| 296 | } |
| 297 | |
| 298 | if (!found_libc_mmap) { |
| 299 | pr_debug("PERF_RECORD_MMAP for %s missing!\n", "libc"); |
| 300 | ++errs; |
| 301 | } |
| 302 | |
| 303 | if (!found_ld_mmap) { |
| 304 | pr_debug("PERF_RECORD_MMAP for %s missing!\n", "ld"); |
| 305 | ++errs; |
| 306 | } |
| 307 | |
| 308 | if (!found_vdso_mmap) { |
| 309 | pr_debug("PERF_RECORD_MMAP for %s missing!\n", "[vdso]"); |
| 310 | ++errs; |
| 311 | } |
Jiri Olsa | 16d00fe | 2012-11-10 01:46:45 +0100 | [diff] [blame] | 312 | out_delete_evlist: |
| 313 | perf_evlist__delete(evlist); |
| 314 | out: |
| 315 | return (err < 0 || errs > 0) ? -1 : 0; |
| 316 | } |