?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf tests: Move test__vmlinux_matches_kallsyms into separate object
[linux-2.6.git] / tools / perf / tests / builtin-test.c
blob5bc9063bf30fb96018af6260c9c54960ab8646fd
1 /*
2 * builtin-test.c
3 *
4 * Builtin regression testing command: ever growing number of sanity tests
5 */
6 #include "builtin.h"
7
8 #include "util/cache.h"
9 #include "util/color.h"
10 #include "util/debug.h"
11 #include "util/debugfs.h"
12 #include "util/evlist.h"
13 #include "util/machine.h"
14 #include "util/parse-options.h"
15 #include "util/parse-events.h"
16 #include "util/symbol.h"
17 #include "util/thread_map.h"
18 #include "util/pmu.h"
19 #include "event-parse.h"
20 #include "../../include/linux/hw_breakpoint.h"
21
22 #include <sys/mman.h>
23
24 #include "util/cpumap.h"
25 #include "util/evsel.h"
26 #include <sys/types.h>
27
28 #include "tests.h"
29
30 static int trace_event__id(const char *evname)
31 {
32 char *filename;
33 int err = -1, fd;
34
35 if (asprintf(&filename,
36 "%s/syscalls/%s/id",
37 tracing_events_path, evname) < 0)
38 return -1;
39
40 fd = open(filename, O_RDONLY);
41 if (fd >= 0) {
42 char id[16];
43 if (read(fd, id, sizeof(id)) > 0)
44 err = atoi(id);
45 close(fd);
46 }
47
48 free(filename);
49 return err;
50 }
51
52 static int test__open_syscall_event(void)
53 {
54 int err = -1, fd;
55 struct thread_map *threads;
56 struct perf_evsel *evsel;
57 struct perf_event_attr attr;
58 unsigned int nr_open_calls = 111, i;
59 int id = trace_event__id("sys_enter_open");
60
61 if (id < 0) {
62 pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
63 return -1;
64 }
65
66 threads = thread_map__new(-1, getpid(), UINT_MAX);
67 if (threads == NULL) {
68 pr_debug("thread_map__new\n");
69 return -1;
70 }
71
72 memset(&attr, 0, sizeof(attr));
73 attr.type = PERF_TYPE_TRACEPOINT;
74 attr.config = id;
75 evsel = perf_evsel__new(&attr, 0);
76 if (evsel == NULL) {
77 pr_debug("perf_evsel__new\n");
78 goto out_thread_map_delete;
79 }
80
81 if (perf_evsel__open_per_thread(evsel, threads) < 0) {
82 pr_debug("failed to open counter: %s, "
83 "tweak /proc/sys/kernel/perf_event_paranoid?\n",
84 strerror(errno));
85 goto out_evsel_delete;
86 }
87
88 for (i = 0; i < nr_open_calls; ++i) {
89 fd = open("/etc/passwd", O_RDONLY);
90 close(fd);
91 }
92
93 if (perf_evsel__read_on_cpu(evsel, 0, 0) < 0) {
94 pr_debug("perf_evsel__read_on_cpu\n");
95 goto out_close_fd;
96 }
97
98 if (evsel->counts->cpu[0].val != nr_open_calls) {
99 pr_debug("perf_evsel__read_on_cpu: expected to intercept %d calls, got %" PRIu64 "\n",
100 nr_open_calls, evsel->counts->cpu[0].val);
101 goto out_close_fd;
102 }
103
104 err = 0;
105 out_close_fd:
106 perf_evsel__close_fd(evsel, 1, threads->nr);
107 out_evsel_delete:
108 perf_evsel__delete(evsel);
109 out_thread_map_delete:
110 thread_map__delete(threads);
111 return err;
112 }
113
114 #include <sched.h>
115
116 static int test__open_syscall_event_on_all_cpus(void)
117 {
118 int err = -1, fd, cpu;
119 struct thread_map *threads;
120 struct cpu_map *cpus;
121 struct perf_evsel *evsel;
122 struct perf_event_attr attr;
123 unsigned int nr_open_calls = 111, i;
124 cpu_set_t cpu_set;
125 int id = trace_event__id("sys_enter_open");
126
127 if (id < 0) {
128 pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
129 return -1;
130 }
131
132 threads = thread_map__new(-1, getpid(), UINT_MAX);
133 if (threads == NULL) {
134 pr_debug("thread_map__new\n");
135 return -1;
136 }
137
138 cpus = cpu_map__new(NULL);
139 if (cpus == NULL) {
140 pr_debug("cpu_map__new\n");
141 goto out_thread_map_delete;
142 }
143
144
145 CPU_ZERO(&cpu_set);
146
147 memset(&attr, 0, sizeof(attr));
148 attr.type = PERF_TYPE_TRACEPOINT;
149 attr.config = id;
150 evsel = perf_evsel__new(&attr, 0);
151 if (evsel == NULL) {
152 pr_debug("perf_evsel__new\n");
153 goto out_thread_map_delete;
154 }
155
156 if (perf_evsel__open(evsel, cpus, threads) < 0) {
157 pr_debug("failed to open counter: %s, "
158 "tweak /proc/sys/kernel/perf_event_paranoid?\n",
159 strerror(errno));
160 goto out_evsel_delete;
161 }
162
163 for (cpu = 0; cpu < cpus->nr; ++cpu) {
164 unsigned int ncalls = nr_open_calls + cpu;
165 /*
166 * XXX eventually lift this restriction in a way that
167 * keeps perf building on older glibc installations
168 * without CPU_ALLOC. 1024 cpus in 2010 still seems
169 * a reasonable upper limit tho :-)
170 */
171 if (cpus->map[cpu] >= CPU_SETSIZE) {
172 pr_debug("Ignoring CPU %d\n", cpus->map[cpu]);
173 continue;
174 }
175
176 CPU_SET(cpus->map[cpu], &cpu_set);
177 if (sched_setaffinity(0, sizeof(cpu_set), &cpu_set) < 0) {
178 pr_debug("sched_setaffinity() failed on CPU %d: %s ",
179 cpus->map[cpu],
180 strerror(errno));
181 goto out_close_fd;
182 }
183 for (i = 0; i < ncalls; ++i) {
184 fd = open("/etc/passwd", O_RDONLY);
185 close(fd);
186 }
187 CPU_CLR(cpus->map[cpu], &cpu_set);
188 }
189
190 /*
191 * Here we need to explicitely preallocate the counts, as if
192 * we use the auto allocation it will allocate just for 1 cpu,
193 * as we start by cpu 0.
194 */
195 if (perf_evsel__alloc_counts(evsel, cpus->nr) < 0) {
196 pr_debug("perf_evsel__alloc_counts(ncpus=%d)\n", cpus->nr);
197 goto out_close_fd;
198 }
199
200 err = 0;
201
202 for (cpu = 0; cpu < cpus->nr; ++cpu) {
203 unsigned int expected;
204
205 if (cpus->map[cpu] >= CPU_SETSIZE)
206 continue;
207
208 if (perf_evsel__read_on_cpu(evsel, cpu, 0) < 0) {
209 pr_debug("perf_evsel__read_on_cpu\n");
210 err = -1;
211 break;
212 }
213
214 expected = nr_open_calls + cpu;
215 if (evsel->counts->cpu[cpu].val != expected) {
216 pr_debug("perf_evsel__read_on_cpu: expected to intercept %d calls on cpu %d, got %" PRIu64 "\n",
217 expected, cpus->map[cpu], evsel->counts->cpu[cpu].val);
218 err = -1;
219 }
220 }
221
222 out_close_fd:
223 perf_evsel__close_fd(evsel, 1, threads->nr);
224 out_evsel_delete:
225 perf_evsel__delete(evsel);
226 out_thread_map_delete:
227 thread_map__delete(threads);
228 return err;
229 }
230
231 /*
232 * This test will generate random numbers of calls to some getpid syscalls,
233 * then establish an mmap for a group of events that are created to monitor
234 * the syscalls.
235 *
236 * It will receive the events, using mmap, use its PERF_SAMPLE_ID generated
237 * sample.id field to map back to its respective perf_evsel instance.
238 *
239 * Then it checks if the number of syscalls reported as perf events by
240 * the kernel corresponds to the number of syscalls made.
241 */
242 static int test__basic_mmap(void)
243 {
244 int err = -1;
245 union perf_event *event;
246 struct thread_map *threads;
247 struct cpu_map *cpus;
248 struct perf_evlist *evlist;
249 struct perf_event_attr attr = {
250 .type = PERF_TYPE_TRACEPOINT,
251 .read_format = PERF_FORMAT_ID,
252 .sample_type = PERF_SAMPLE_ID,
253 .watermark = 0,
254 };
255 cpu_set_t cpu_set;
256 const char *syscall_names[] = { "getsid", "getppid", "getpgrp",
257 "getpgid", };
258 pid_t (*syscalls[])(void) = { (void *)getsid, getppid, getpgrp,
259 (void*)getpgid };
260 #define nsyscalls ARRAY_SIZE(syscall_names)
261 int ids[nsyscalls];
262 unsigned int nr_events[nsyscalls],
263 expected_nr_events[nsyscalls], i, j;
264 struct perf_evsel *evsels[nsyscalls], *evsel;
265
266 for (i = 0; i < nsyscalls; ++i) {
267 char name[64];
268
269 snprintf(name, sizeof(name), "sys_enter_%s", syscall_names[i]);
270 ids[i] = trace_event__id(name);
271 if (ids[i] < 0) {
272 pr_debug("Is debugfs mounted on /sys/kernel/debug?\n");
273 return -1;
274 }
275 nr_events[i] = 0;
276 expected_nr_events[i] = random() % 257;
277 }
278
279 threads = thread_map__new(-1, getpid(), UINT_MAX);
280 if (threads == NULL) {
281 pr_debug("thread_map__new\n");
282 return -1;
283 }
284
285 cpus = cpu_map__new(NULL);
286 if (cpus == NULL) {
287 pr_debug("cpu_map__new\n");
288 goto out_free_threads;
289 }
290
291 CPU_ZERO(&cpu_set);
292 CPU_SET(cpus->map[0], &cpu_set);
293 sched_setaffinity(0, sizeof(cpu_set), &cpu_set);
294 if (sched_setaffinity(0, sizeof(cpu_set), &cpu_set) < 0) {
295 pr_debug("sched_setaffinity() failed on CPU %d: %s ",
296 cpus->map[0], strerror(errno));
297 goto out_free_cpus;
298 }
299
300 evlist = perf_evlist__new(cpus, threads);
301 if (evlist == NULL) {
302 pr_debug("perf_evlist__new\n");
303 goto out_free_cpus;
304 }
305
306 /* anonymous union fields, can't be initialized above */
307 attr.wakeup_events = 1;
308 attr.sample_period = 1;
309
310 for (i = 0; i < nsyscalls; ++i) {
311 attr.config = ids[i];
312 evsels[i] = perf_evsel__new(&attr, i);
313 if (evsels[i] == NULL) {
314 pr_debug("perf_evsel__new\n");
315 goto out_free_evlist;
316 }
317
318 perf_evlist__add(evlist, evsels[i]);
319
320 if (perf_evsel__open(evsels[i], cpus, threads) < 0) {
321 pr_debug("failed to open counter: %s, "
322 "tweak /proc/sys/kernel/perf_event_paranoid?\n",
323 strerror(errno));
324 goto out_close_fd;
325 }
326 }
327
328 if (perf_evlist__mmap(evlist, 128, true) < 0) {
329 pr_debug("failed to mmap events: %d (%s)\n", errno,
330 strerror(errno));
331 goto out_close_fd;
332 }
333
334 for (i = 0; i < nsyscalls; ++i)
335 for (j = 0; j < expected_nr_events[i]; ++j) {
336 int foo = syscalls[i]();
337 ++foo;
338 }
339
340 while ((event = perf_evlist__mmap_read(evlist, 0)) != NULL) {
341 struct perf_sample sample;
342
343 if (event->header.type != PERF_RECORD_SAMPLE) {
344 pr_debug("unexpected %s event\n",
345 perf_event__name(event->header.type));
346 goto out_munmap;
347 }
348
349 err = perf_evlist__parse_sample(evlist, event, &sample);
350 if (err) {
351 pr_err("Can't parse sample, err = %d\n", err);
352 goto out_munmap;
353 }
354
355 evsel = perf_evlist__id2evsel(evlist, sample.id);
356 if (evsel == NULL) {
357 pr_debug("event with id %" PRIu64
358 " doesn't map to an evsel\n", sample.id);
359 goto out_munmap;
360 }
361 nr_events[evsel->idx]++;
362 }
363
364 list_for_each_entry(evsel, &evlist->entries, node) {
365 if (nr_events[evsel->idx] != expected_nr_events[evsel->idx]) {
366 pr_debug("expected %d %s events, got %d\n",
367 expected_nr_events[evsel->idx],
368 perf_evsel__name(evsel), nr_events[evsel->idx]);
369 goto out_munmap;
370 }
371 }
372
373 err = 0;
374 out_munmap:
375 perf_evlist__munmap(evlist);
376 out_close_fd:
377 for (i = 0; i < nsyscalls; ++i)
378 perf_evsel__close_fd(evsels[i], 1, threads->nr);
379 out_free_evlist:
380 perf_evlist__delete(evlist);
381 out_free_cpus:
382 cpu_map__delete(cpus);
383 out_free_threads:
384 thread_map__delete(threads);
385 return err;
386 #undef nsyscalls
387 }
388
389 static int sched__get_first_possible_cpu(pid_t pid, cpu_set_t *maskp)
390 {
391 int i, cpu = -1, nrcpus = 1024;
392 realloc:
393 CPU_ZERO(maskp);
394
395 if (sched_getaffinity(pid, sizeof(*maskp), maskp) == -1) {
396 if (errno == EINVAL && nrcpus < (1024 << 8)) {
397 nrcpus = nrcpus << 2;
398 goto realloc;
399 }
400 perror("sched_getaffinity");
401 return -1;
402 }
403
404 for (i = 0; i < nrcpus; i++) {
405 if (CPU_ISSET(i, maskp)) {
406 if (cpu == -1)
407 cpu = i;
408 else
409 CPU_CLR(i, maskp);
410 }
411 }
412
413 return cpu;
414 }
415
416 static int test__PERF_RECORD(void)
417 {
418 struct perf_record_opts opts = {
419 .target = {
420 .uid = UINT_MAX,
421 .uses_mmap = true,
422 },
423 .no_delay = true,
424 .freq = 10,
425 .mmap_pages = 256,
426 };
427 cpu_set_t cpu_mask;
428 size_t cpu_mask_size = sizeof(cpu_mask);
429 struct perf_evlist *evlist = perf_evlist__new(NULL, NULL);
430 struct perf_evsel *evsel;
431 struct perf_sample sample;
432 const char *cmd = "sleep";
433 const char *argv[] = { cmd, "1", NULL, };
434 char *bname;
435 u64 prev_time = 0;
436 bool found_cmd_mmap = false,
437 found_libc_mmap = false,
438 found_vdso_mmap = false,
439 found_ld_mmap = false;
440 int err = -1, errs = 0, i, wakeups = 0;
441 u32 cpu;
442 int total_events = 0, nr_events[PERF_RECORD_MAX] = { 0, };
443
444 if (evlist == NULL || argv == NULL) {
445 pr_debug("Not enough memory to create evlist\n");
446 goto out;
447 }
448
449 /*
450 * We need at least one evsel in the evlist, use the default
451 * one: "cycles".
452 */
453 err = perf_evlist__add_default(evlist);
454 if (err < 0) {
455 pr_debug("Not enough memory to create evsel\n");
456 goto out_delete_evlist;
457 }
458
459 /*
460 * Create maps of threads and cpus to monitor. In this case
461 * we start with all threads and cpus (-1, -1) but then in
462 * perf_evlist__prepare_workload we'll fill in the only thread
463 * we're monitoring, the one forked there.
464 */
465 err = perf_evlist__create_maps(evlist, &opts.target);
466 if (err < 0) {
467 pr_debug("Not enough memory to create thread/cpu maps\n");
468 goto out_delete_evlist;
469 }
470
471 /*
472 * Prepare the workload in argv[] to run, it'll fork it, and then wait
473 * for perf_evlist__start_workload() to exec it. This is done this way
474 * so that we have time to open the evlist (calling sys_perf_event_open
475 * on all the fds) and then mmap them.
476 */
477 err = perf_evlist__prepare_workload(evlist, &opts, argv);
478 if (err < 0) {
479 pr_debug("Couldn't run the workload!\n");
480 goto out_delete_evlist;
481 }
482
483 /*
484 * Config the evsels, setting attr->comm on the first one, etc.
485 */
486 evsel = perf_evlist__first(evlist);
487 evsel->attr.sample_type |= PERF_SAMPLE_CPU;
488 evsel->attr.sample_type |= PERF_SAMPLE_TID;
489 evsel->attr.sample_type |= PERF_SAMPLE_TIME;
490 perf_evlist__config_attrs(evlist, &opts);
491
492 err = sched__get_first_possible_cpu(evlist->workload.pid, &cpu_mask);
493 if (err < 0) {
494 pr_debug("sched__get_first_possible_cpu: %s\n", strerror(errno));
495 goto out_delete_evlist;
496 }
497
498 cpu = err;
499
500 /*
501 * So that we can check perf_sample.cpu on all the samples.
502 */
503 if (sched_setaffinity(evlist->workload.pid, cpu_mask_size, &cpu_mask) < 0) {
504 pr_debug("sched_setaffinity: %s\n", strerror(errno));
505 goto out_delete_evlist;
506 }
507
508 /*
509 * Call sys_perf_event_open on all the fds on all the evsels,
510 * grouping them if asked to.
511 */
512 err = perf_evlist__open(evlist);
513 if (err < 0) {
514 pr_debug("perf_evlist__open: %s\n", strerror(errno));
515 goto out_delete_evlist;
516 }
517
518 /*
519 * mmap the first fd on a given CPU and ask for events for the other
520 * fds in the same CPU to be injected in the same mmap ring buffer
521 * (using ioctl(PERF_EVENT_IOC_SET_OUTPUT)).
522 */
523 err = perf_evlist__mmap(evlist, opts.mmap_pages, false);
524 if (err < 0) {
525 pr_debug("perf_evlist__mmap: %s\n", strerror(errno));
526 goto out_delete_evlist;
527 }
528
529 /*
530 * Now that all is properly set up, enable the events, they will
531 * count just on workload.pid, which will start...
532 */
533 perf_evlist__enable(evlist);
534
535 /*
536 * Now!
537 */
538 perf_evlist__start_workload(evlist);
539
540 while (1) {
541 int before = total_events;
542
543 for (i = 0; i < evlist->nr_mmaps; i++) {
544 union perf_event *event;
545
546 while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
547 const u32 type = event->header.type;
548 const char *name = perf_event__name(type);
549
550 ++total_events;
551 if (type < PERF_RECORD_MAX)
552 nr_events[type]++;
553
554 err = perf_evlist__parse_sample(evlist, event, &sample);
555 if (err < 0) {
556 if (verbose)
557 perf_event__fprintf(event, stderr);
558 pr_debug("Couldn't parse sample\n");
559 goto out_err;
560 }
561
562 if (verbose) {
563 pr_info("%" PRIu64" %d ", sample.time, sample.cpu);
564 perf_event__fprintf(event, stderr);
565 }
566
567 if (prev_time > sample.time) {
568 pr_debug("%s going backwards in time, prev=%" PRIu64 ", curr=%" PRIu64 "\n",
569 name, prev_time, sample.time);
570 ++errs;
571 }
572
573 prev_time = sample.time;
574
575 if (sample.cpu != cpu) {
576 pr_debug("%s with unexpected cpu, expected %d, got %d\n",
577 name, cpu, sample.cpu);
578 ++errs;
579 }
580
581 if ((pid_t)sample.pid != evlist->workload.pid) {
582 pr_debug("%s with unexpected pid, expected %d, got %d\n",
583 name, evlist->workload.pid, sample.pid);
584 ++errs;
585 }
586
587 if ((pid_t)sample.tid != evlist->workload.pid) {
588 pr_debug("%s with unexpected tid, expected %d, got %d\n",
589 name, evlist->workload.pid, sample.tid);
590 ++errs;
591 }
592
593 if ((type == PERF_RECORD_COMM ||
594 type == PERF_RECORD_MMAP ||
595 type == PERF_RECORD_FORK ||
596 type == PERF_RECORD_EXIT) &&
597 (pid_t)event->comm.pid != evlist->workload.pid) {
598 pr_debug("%s with unexpected pid/tid\n", name);
599 ++errs;
600 }
601
602 if ((type == PERF_RECORD_COMM ||
603 type == PERF_RECORD_MMAP) &&
604 event->comm.pid != event->comm.tid) {
605 pr_debug("%s with different pid/tid!\n", name);
606 ++errs;
607 }
608
609 switch (type) {
610 case PERF_RECORD_COMM:
611 if (strcmp(event->comm.comm, cmd)) {
612 pr_debug("%s with unexpected comm!\n", name);
613 ++errs;
614 }
615 break;
616 case PERF_RECORD_EXIT:
617 goto found_exit;
618 case PERF_RECORD_MMAP:
619 bname = strrchr(event->mmap.filename, '/');
620 if (bname != NULL) {
621 if (!found_cmd_mmap)
622 found_cmd_mmap = !strcmp(bname + 1, cmd);
623 if (!found_libc_mmap)
624 found_libc_mmap = !strncmp(bname + 1, "libc", 4);
625 if (!found_ld_mmap)
626 found_ld_mmap = !strncmp(bname + 1, "ld", 2);
627 } else if (!found_vdso_mmap)
628 found_vdso_mmap = !strcmp(event->mmap.filename, "[vdso]");
629 break;
630
631 case PERF_RECORD_SAMPLE:
632 /* Just ignore samples for now */
633 break;
634 default:
635 pr_debug("Unexpected perf_event->header.type %d!\n",
636 type);
637 ++errs;
638 }
639 }
640 }
641
642 /*
643 * We don't use poll here because at least at 3.1 times the
644 * PERF_RECORD_{!SAMPLE} events don't honour
645 * perf_event_attr.wakeup_events, just PERF_EVENT_SAMPLE does.
646 */
647 if (total_events == before && false)
648 poll(evlist->pollfd, evlist->nr_fds, -1);
649
650 sleep(1);
651 if (++wakeups > 5) {
652 pr_debug("No PERF_RECORD_EXIT event!\n");
653 break;
654 }
655 }
656
657 found_exit:
658 if (nr_events[PERF_RECORD_COMM] > 1) {
659 pr_debug("Excessive number of PERF_RECORD_COMM events!\n");
660 ++errs;
661 }
662
663 if (nr_events[PERF_RECORD_COMM] == 0) {
664 pr_debug("Missing PERF_RECORD_COMM for %s!\n", cmd);
665 ++errs;
666 }
667
668 if (!found_cmd_mmap) {
669 pr_debug("PERF_RECORD_MMAP for %s missing!\n", cmd);
670 ++errs;
671 }
672
673 if (!found_libc_mmap) {
674 pr_debug("PERF_RECORD_MMAP for %s missing!\n", "libc");
675 ++errs;
676 }
677
678 if (!found_ld_mmap) {
679 pr_debug("PERF_RECORD_MMAP for %s missing!\n", "ld");
680 ++errs;
681 }
682
683 if (!found_vdso_mmap) {
684 pr_debug("PERF_RECORD_MMAP for %s missing!\n", "[vdso]");
685 ++errs;
686 }
687 out_err:
688 perf_evlist__munmap(evlist);
689 out_delete_evlist:
690 perf_evlist__delete(evlist);
691 out:
692 return (err < 0 || errs > 0) ? -1 : 0;
693 }
694
695
696 #if defined(__x86_64__) || defined(__i386__)
697
698 #define barrier() asm volatile("" ::: "memory")
699
700 static u64 rdpmc(unsigned int counter)
701 {
702 unsigned int low, high;
703
704 asm volatile("rdpmc" : "=a" (low), "=d" (high) : "c" (counter));
705
706 return low | ((u64)high) << 32;
707 }
708
709 static u64 rdtsc(void)
710 {
711 unsigned int low, high;
712
713 asm volatile("rdtsc" : "=a" (low), "=d" (high));
714
715 return low | ((u64)high) << 32;
716 }
717
718 static u64 mmap_read_self(void *addr)
719 {
720 struct perf_event_mmap_page *pc = addr;
721 u32 seq, idx, time_mult = 0, time_shift = 0;
722 u64 count, cyc = 0, time_offset = 0, enabled, running, delta;
723
724 do {
725 seq = pc->lock;
726 barrier();
727
728 enabled = pc->time_enabled;
729 running = pc->time_running;
730
731 if (enabled != running) {
732 cyc = rdtsc();
733 time_mult = pc->time_mult;
734 time_shift = pc->time_shift;
735 time_offset = pc->time_offset;
736 }
737
738 idx = pc->index;
739 count = pc->offset;
740 if (idx)
741 count += rdpmc(idx - 1);
742
743 barrier();
744 } while (pc->lock != seq);
745
746 if (enabled != running) {
747 u64 quot, rem;
748
749 quot = (cyc >> time_shift);
750 rem = cyc & ((1 << time_shift) - 1);
751 delta = time_offset + quot * time_mult +
752 ((rem * time_mult) >> time_shift);
753
754 enabled += delta;
755 if (idx)
756 running += delta;
757
758 quot = count / running;
759 rem = count % running;
760 count = quot * enabled + (rem * enabled) / running;
761 }
762
763 return count;
764 }
765
766 /*
767 * If the RDPMC instruction faults then signal this back to the test parent task:
768 */
769 static void segfault_handler(int sig __maybe_unused,
770 siginfo_t *info __maybe_unused,
771 void *uc __maybe_unused)
772 {
773 exit(-1);
774 }
775
776 static int __test__rdpmc(void)
777 {
778 volatile int tmp = 0;
779 u64 i, loops = 1000;
780 int n;
781 int fd;
782 void *addr;
783 struct perf_event_attr attr = {
784 .type = PERF_TYPE_HARDWARE,
785 .config = PERF_COUNT_HW_INSTRUCTIONS,
786 .exclude_kernel = 1,
787 };
788 u64 delta_sum = 0;
789 struct sigaction sa;
790
791 sigfillset(&sa.sa_mask);
792 sa.sa_sigaction = segfault_handler;
793 sigaction(SIGSEGV, &sa, NULL);
794
795 fd = sys_perf_event_open(&attr, 0, -1, -1, 0);
796 if (fd < 0) {
797 pr_err("Error: sys_perf_event_open() syscall returned "
798 "with %d (%s)\n", fd, strerror(errno));
799 return -1;
800 }
801
802 addr = mmap(NULL, page_size, PROT_READ, MAP_SHARED, fd, 0);
803 if (addr == (void *)(-1)) {
804 pr_err("Error: mmap() syscall returned with (%s)\n",
805 strerror(errno));
806 goto out_close;
807 }
808
809 for (n = 0; n < 6; n++) {
810 u64 stamp, now, delta;
811
812 stamp = mmap_read_self(addr);
813
814 for (i = 0; i < loops; i++)
815 tmp++;
816
817 now = mmap_read_self(addr);
818 loops *= 10;
819
820 delta = now - stamp;
821 pr_debug("%14d: %14Lu\n", n, (long long)delta);
822
823 delta_sum += delta;
824 }
825
826 munmap(addr, page_size);
827 pr_debug(" ");
828 out_close:
829 close(fd);
830
831 if (!delta_sum)
832 return -1;
833
834 return 0;
835 }
836
837 static int test__rdpmc(void)
838 {
839 int status = 0;
840 int wret = 0;
841 int ret;
842 int pid;
843
844 pid = fork();
845 if (pid < 0)
846 return -1;
847
848 if (!pid) {
849 ret = __test__rdpmc();
850
851 exit(ret);
852 }
853
854 wret = waitpid(pid, &status, 0);
855 if (wret < 0 || status)
856 return -1;
857
858 return 0;
859 }
860
861 #endif
862
863 static int test__perf_pmu(void)
864 {
865 return perf_pmu__test();
866 }
867
868 static int perf_evsel__roundtrip_cache_name_test(void)
869 {
870 char name[128];
871 int type, op, err = 0, ret = 0, i, idx;
872 struct perf_evsel *evsel;
873 struct perf_evlist *evlist = perf_evlist__new(NULL, NULL);
874
875 if (evlist == NULL)
876 return -ENOMEM;
877
878 for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
879 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
880 /* skip invalid cache type */
881 if (!perf_evsel__is_cache_op_valid(type, op))
882 continue;
883
884 for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
885 __perf_evsel__hw_cache_type_op_res_name(type, op, i,
886 name, sizeof(name));
887 err = parse_events(evlist, name, 0);
888 if (err)
889 ret = err;
890 }
891 }
892 }
893
894 idx = 0;
895 evsel = perf_evlist__first(evlist);
896
897 for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
898 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
899 /* skip invalid cache type */
900 if (!perf_evsel__is_cache_op_valid(type, op))
901 continue;
902
903 for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
904 __perf_evsel__hw_cache_type_op_res_name(type, op, i,
905 name, sizeof(name));
906 if (evsel->idx != idx)
907 continue;
908
909 ++idx;
910
911 if (strcmp(perf_evsel__name(evsel), name)) {
912 pr_debug("%s != %s\n", perf_evsel__name(evsel), name);
913 ret = -1;
914 }
915
916 evsel = perf_evsel__next(evsel);
917 }
918 }
919 }
920
921 perf_evlist__delete(evlist);
922 return ret;
923 }
924
925 static int __perf_evsel__name_array_test(const char *names[], int nr_names)
926 {
927 int i, err;
928 struct perf_evsel *evsel;
929 struct perf_evlist *evlist = perf_evlist__new(NULL, NULL);
930
931 if (evlist == NULL)
932 return -ENOMEM;
933
934 for (i = 0; i < nr_names; ++i) {
935 err = parse_events(evlist, names[i], 0);
936 if (err) {
937 pr_debug("failed to parse event '%s', err %d\n",
938 names[i], err);
939 goto out_delete_evlist;
940 }
941 }
942
943 err = 0;
944 list_for_each_entry(evsel, &evlist->entries, node) {
945 if (strcmp(perf_evsel__name(evsel), names[evsel->idx])) {
946 --err;
947 pr_debug("%s != %s\n", perf_evsel__name(evsel), names[evsel->idx]);
948 }
949 }
950
951 out_delete_evlist:
952 perf_evlist__delete(evlist);
953 return err;
954 }
955
956 #define perf_evsel__name_array_test(names) \
957 __perf_evsel__name_array_test(names, ARRAY_SIZE(names))
958
959 static int perf_evsel__roundtrip_name_test(void)
960 {
961 int err = 0, ret = 0;
962
963 err = perf_evsel__name_array_test(perf_evsel__hw_names);
964 if (err)
965 ret = err;
966
967 err = perf_evsel__name_array_test(perf_evsel__sw_names);
968 if (err)
969 ret = err;
970
971 err = perf_evsel__roundtrip_cache_name_test();
972 if (err)
973 ret = err;
974
975 return ret;
976 }
977
978 static int perf_evsel__test_field(struct perf_evsel *evsel, const char *name,
979 int size, bool should_be_signed)
980 {
981 struct format_field *field = perf_evsel__field(evsel, name);
982 int is_signed;
983 int ret = 0;
984
985 if (field == NULL) {
986 pr_debug("%s: \"%s\" field not found!\n", evsel->name, name);
987 return -1;
988 }
989
990 is_signed = !!(field->flags | FIELD_IS_SIGNED);
991 if (should_be_signed && !is_signed) {
992 pr_debug("%s: \"%s\" signedness(%d) is wrong, should be %d\n",
993 evsel->name, name, is_signed, should_be_signed);
994 ret = -1;
995 }
996
997 if (field->size != size) {
998 pr_debug("%s: \"%s\" size (%d) should be %d!\n",
999 evsel->name, name, field->size, size);
1000 ret = -1;
1001 }
1002
1003 return ret;
1004 }
1005
1006 static int perf_evsel__tp_sched_test(void)
1007 {
1008 struct perf_evsel *evsel = perf_evsel__newtp("sched", "sched_switch", 0);
1009 int ret = 0;
1010
1011 if (evsel == NULL) {
1012 pr_debug("perf_evsel__new\n");
1013 return -1;
1014 }
1015
1016 if (perf_evsel__test_field(evsel, "prev_comm", 16, true))
1017 ret = -1;
1018
1019 if (perf_evsel__test_field(evsel, "prev_pid", 4, true))
1020 ret = -1;
1021
1022 if (perf_evsel__test_field(evsel, "prev_prio", 4, true))
1023 ret = -1;
1024
1025 if (perf_evsel__test_field(evsel, "prev_state", 8, true))
1026 ret = -1;
1027
1028 if (perf_evsel__test_field(evsel, "next_comm", 16, true))
1029 ret = -1;
1030
1031 if (perf_evsel__test_field(evsel, "next_pid", 4, true))
1032 ret = -1;
1033
1034 if (perf_evsel__test_field(evsel, "next_prio", 4, true))
1035 ret = -1;
1036
1037 perf_evsel__delete(evsel);
1038
1039 evsel = perf_evsel__newtp("sched", "sched_wakeup", 0);
1040
1041 if (perf_evsel__test_field(evsel, "comm", 16, true))
1042 ret = -1;
1043
1044 if (perf_evsel__test_field(evsel, "pid", 4, true))
1045 ret = -1;
1046
1047 if (perf_evsel__test_field(evsel, "prio", 4, true))
1048 ret = -1;
1049
1050 if (perf_evsel__test_field(evsel, "success", 4, true))
1051 ret = -1;
1052
1053 if (perf_evsel__test_field(evsel, "target_cpu", 4, true))
1054 ret = -1;
1055
1056 return ret;
1057 }
1058
1059 static int test__syscall_open_tp_fields(void)
1060 {
1061 struct perf_record_opts opts = {
1062 .target = {
1063 .uid = UINT_MAX,
1064 .uses_mmap = true,
1065 },
1066 .no_delay = true,
1067 .freq = 1,
1068 .mmap_pages = 256,
1069 .raw_samples = true,
1070 };
1071 const char *filename = "/etc/passwd";
1072 int flags = O_RDONLY | O_DIRECTORY;
1073 struct perf_evlist *evlist = perf_evlist__new(NULL, NULL);
1074 struct perf_evsel *evsel;
1075 int err = -1, i, nr_events = 0, nr_polls = 0;
1076
1077 if (evlist == NULL) {
1078 pr_debug("%s: perf_evlist__new\n", __func__);
1079 goto out;
1080 }
1081
1082 evsel = perf_evsel__newtp("syscalls", "sys_enter_open", 0);
1083 if (evsel == NULL) {
1084 pr_debug("%s: perf_evsel__newtp\n", __func__);
1085 goto out_delete_evlist;
1086 }
1087
1088 perf_evlist__add(evlist, evsel);
1089
1090 err = perf_evlist__create_maps(evlist, &opts.target);
1091 if (err < 0) {
1092 pr_debug("%s: perf_evlist__create_maps\n", __func__);
1093 goto out_delete_evlist;
1094 }
1095
1096 perf_evsel__config(evsel, &opts, evsel);
1097
1098 evlist->threads->map[0] = getpid();
1099
1100 err = perf_evlist__open(evlist);
1101 if (err < 0) {
1102 pr_debug("perf_evlist__open: %s\n", strerror(errno));
1103 goto out_delete_evlist;
1104 }
1105
1106 err = perf_evlist__mmap(evlist, UINT_MAX, false);
1107 if (err < 0) {
1108 pr_debug("perf_evlist__mmap: %s\n", strerror(errno));
1109 goto out_delete_evlist;
1110 }
1111
1112 perf_evlist__enable(evlist);
1113
1114 /*
1115 * Generate the event:
1116 */
1117 open(filename, flags);
1118
1119 while (1) {
1120 int before = nr_events;
1121
1122 for (i = 0; i < evlist->nr_mmaps; i++) {
1123 union perf_event *event;
1124
1125 while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
1126 const u32 type = event->header.type;
1127 int tp_flags;
1128 struct perf_sample sample;
1129
1130 ++nr_events;
1131
1132 if (type != PERF_RECORD_SAMPLE)
1133 continue;
1134
1135 err = perf_evsel__parse_sample(evsel, event, &sample);
1136 if (err) {
1137 pr_err("Can't parse sample, err = %d\n", err);
1138 goto out_munmap;
1139 }
1140
1141 tp_flags = perf_evsel__intval(evsel, &sample, "flags");
1142
1143 if (flags != tp_flags) {
1144 pr_debug("%s: Expected flags=%#x, got %#x\n",
1145 __func__, flags, tp_flags);
1146 goto out_munmap;
1147 }
1148
1149 goto out_ok;
1150 }
1151 }
1152
1153 if (nr_events == before)
1154 poll(evlist->pollfd, evlist->nr_fds, 10);
1155
1156 if (++nr_polls > 5) {
1157 pr_debug("%s: no events!\n", __func__);
1158 goto out_munmap;
1159 }
1160 }
1161 out_ok:
1162 err = 0;
1163 out_munmap:
1164 perf_evlist__munmap(evlist);
1165 out_delete_evlist:
1166 perf_evlist__delete(evlist);
1167 out:
1168 return err;
1169 }
1170
1171 static struct test {
1172 const char *desc;
1173 int (*func)(void);
1174 } tests[] = {
1175 {
1176 .desc = "vmlinux symtab matches kallsyms",
1177 .func = test__vmlinux_matches_kallsyms,
1178 },
1179 {
1180 .desc = "detect open syscall event",
1181 .func = test__open_syscall_event,
1182 },
1183 {
1184 .desc = "detect open syscall event on all cpus",
1185 .func = test__open_syscall_event_on_all_cpus,
1186 },
1187 {
1188 .desc = "read samples using the mmap interface",
1189 .func = test__basic_mmap,
1190 },
1191 {
1192 .desc = "parse events tests",
1193 .func = parse_events__test,
1194 },
1195 #if defined(__x86_64__) || defined(__i386__)
1196 {
1197 .desc = "x86 rdpmc test",
1198 .func = test__rdpmc,
1199 },
1200 #endif
1201 {
1202 .desc = "Validate PERF_RECORD_* events & perf_sample fields",
1203 .func = test__PERF_RECORD,
1204 },
1205 {
1206 .desc = "Test perf pmu format parsing",
1207 .func = test__perf_pmu,
1208 },
1209 {
1210 .desc = "Test dso data interface",
1211 .func = dso__test_data,
1212 },
1213 {
1214 .desc = "roundtrip evsel->name check",
1215 .func = perf_evsel__roundtrip_name_test,
1216 },
1217 {
1218 .desc = "Check parsing of sched tracepoints fields",
1219 .func = perf_evsel__tp_sched_test,
1220 },
1221 {
1222 .desc = "Generate and check syscalls:sys_enter_open event fields",
1223 .func = test__syscall_open_tp_fields,
1224 },
1225 {
1226 .desc = "struct perf_event_attr setup",
1227 .func = test_attr__run,
1228 },
1229 {
1230 .func = NULL,
1231 },
1232 };
1233
1234 static bool perf_test__matches(int curr, int argc, const char *argv[])
1235 {
1236 int i;
1237
1238 if (argc == 0)
1239 return true;
1240
1241 for (i = 0; i < argc; ++i) {
1242 char *end;
1243 long nr = strtoul(argv[i], &end, 10);
1244
1245 if (*end == '\0') {
1246 if (nr == curr + 1)
1247 return true;
1248 continue;
1249 }
1250
1251 if (strstr(tests[curr].desc, argv[i]))
1252 return true;
1253 }
1254
1255 return false;
1256 }
1257
1258 static int __cmd_test(int argc, const char *argv[])
1259 {
1260 int i = 0;
1261 int width = 0;
1262
1263 while (tests[i].func) {
1264 int len = strlen(tests[i].desc);
1265
1266 if (width < len)
1267 width = len;
1268 ++i;
1269 }
1270
1271 i = 0;
1272 while (tests[i].func) {
1273 int curr = i++, err;
1274
1275 if (!perf_test__matches(curr, argc, argv))
1276 continue;
1277
1278 pr_info("%2d: %-*s:", i, width, tests[curr].desc);
1279 pr_debug("\n--- start ---\n");
1280 err = tests[curr].func();
1281 pr_debug("---- end ----\n%s:", tests[curr].desc);
1282 if (err)
1283 color_fprintf(stderr, PERF_COLOR_RED, " FAILED!\n");
1284 else
1285 pr_info(" Ok\n");
1286 }
1287
1288 return 0;
1289 }
1290
1291 static int perf_test__list(int argc, const char **argv)
1292 {
1293 int i = 0;
1294
1295 while (tests[i].func) {
1296 int curr = i++;
1297
1298 if (argc > 1 && !strstr(tests[curr].desc, argv[1]))
1299 continue;
1300
1301 pr_info("%2d: %s\n", i, tests[curr].desc);
1302 }
1303
1304 return 0;
1305 }
1306
1307 int cmd_test(int argc, const char **argv, const char *prefix __maybe_unused)
1308 {
1309 const char * const test_usage[] = {
1310 "perf test [<options>] [{list <test-name-fragment>|[<test-name-fragments>|<test-numbers>]}]",
1311 NULL,
1312 };
1313 const struct option test_options[] = {
1314 OPT_INCR('v', "verbose", &verbose,
1315 "be more verbose (show symbol address, etc)"),
1316 OPT_END()
1317 };
1318
1319 argc = parse_options(argc, argv, test_options, test_usage, 0);
1320 if (argc >= 1 && !strcmp(argv[0], "list"))
1321 return perf_test__list(argc, argv);
1322
1323 symbol_conf.priv_size = sizeof(int);
1324 symbol_conf.sort_by_name = true;
1325 symbol_conf.try_vmlinux_path = true;
1326
1327 if (symbol__init() < 0)
1328 return -1;
1329
1330 return __cmd_test(argc, argv);
1331 }
Linus' kernel tree