tools/perf/builtin-test.c

   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/debug.h"
  10 #include "util/debugfs.h"
  11 #include "util/evlist.h"
  12 #include "util/parse-options.h"
  13 #include "util/parse-events.h"
  14 #include "util/symbol.h"
  15 #include "util/thread_map.h"
  16 #include "../../include/linux/hw_breakpoint.h"
  17
  18 #include <sys/mman.h>
  19
  20 static int vmlinux_matches_kallsyms_filter(struct map *map __used, struct symbol *sym)
  21 {
  22         bool *visited = symbol__priv(sym);
  23         *visited = true;
  24         return 0;
  25 }
  26
  27 static int test__vmlinux_matches_kallsyms(void)
  28 {
  29         int err = -1;
  30         struct rb_node *nd;
  31         struct symbol *sym;
  32         struct map *kallsyms_map, *vmlinux_map;
  33         struct machine kallsyms, vmlinux;
  34         enum map_type type = MAP__FUNCTION;
  35         long page_size = sysconf(_SC_PAGE_SIZE);
  36         struct ref_reloc_sym ref_reloc_sym = { .name = "_stext", };
  37
  38         /*
  39          * Step 1:
  40          *
  41          * Init the machines that will hold kernel, modules obtained from
  42          * both vmlinux + .ko files and from /proc/kallsyms split by modules.
  43          */
  44         machine__init(&kallsyms, "", HOST_KERNEL_ID);
  45         machine__init(&vmlinux, "", HOST_KERNEL_ID);
  46
  47         /*
  48          * Step 2:
  49          *
  50          * Create the kernel maps for kallsyms and the DSO where we will then
  51          * load /proc/kallsyms. Also create the modules maps from /proc/modules
  52          * and find the .ko files that match them in /lib/modules/`uname -r`/.
  53          */
  54         if (machine__create_kernel_maps(&kallsyms) < 0) {
  55                 pr_debug("machine__create_kernel_maps ");
  56                 return -1;
  57         }
  58
  59         /*
  60          * Step 3:
  61          *
  62          * Load and split /proc/kallsyms into multiple maps, one per module.
  63          */
  64         if (machine__load_kallsyms(&kallsyms, "/proc/kallsyms", type, NULL) <= 0) {
  65                 pr_debug("dso__load_kallsyms ");
  66                 goto out;
  67         }
  68
  69         /*
  70          * Step 4:
  71          *
  72          * kallsyms will be internally on demand sorted by name so that we can
  73          * find the reference relocation * symbol, i.e. the symbol we will use
  74          * to see if the running kernel was relocated by checking if it has the
  75          * same value in the vmlinux file we load.
  76          */
  77         kallsyms_map = machine__kernel_map(&kallsyms, type);
  78
  79         sym = map__find_symbol_by_name(kallsyms_map, ref_reloc_sym.name, NULL);
  80         if (sym == NULL) {
  81                 pr_debug("dso__find_symbol_by_name ");
  82                 goto out;
  83         }
  84
  85         ref_reloc_sym.addr = sym->start;
  86
  87         /*
  88          * Step 5:
  89          *
  90          * Now repeat step 2, this time for the vmlinux file we'll auto-locate.
  91          */
  92         if (machine__create_kernel_maps(&vmlinux) < 0) {
  93                 pr_debug("machine__create_kernel_maps ");
  94                 goto out;
  95         }
  96
  97         vmlinux_map = machine__kernel_map(&vmlinux, type);
  98         map__kmap(vmlinux_map)->ref_reloc_sym = &ref_reloc_sym;
  99
 100         /*
 101          * Step 6:
 102          *
 103          * Locate a vmlinux file in the vmlinux path that has a buildid that
 104          * matches the one of the running kernel.
 105          *
 106          * While doing that look if we find the ref reloc symbol, if we find it
 107          * we'll have its ref_reloc_symbol.unrelocated_addr and then
 108          * maps__reloc_vmlinux will notice and set proper ->[un]map_ip routines
 109          * to fixup the symbols.
 110          */
 111         if (machine__load_vmlinux_path(&vmlinux, type,
 112                                        vmlinux_matches_kallsyms_filter) <= 0) {
 113                 pr_debug("machine__load_vmlinux_path ");
 114                 goto out;
 115         }
 116
 117         err = 0;
 118         /*
 119          * Step 7:
 120          *
 121          * Now look at the symbols in the vmlinux DSO and check if we find all of them
 122          * in the kallsyms dso. For the ones that are in both, check its names and
 123          * end addresses too.
 124          */
 125         for (nd = rb_first(&vmlinux_map->dso->symbols[type]); nd; nd = rb_next(nd)) {
 126                 struct symbol *pair, *first_pair;
 127                 bool backwards = true;
 128
 129                 sym  = rb_entry(nd, struct symbol, rb_node);
 130
 131                 if (sym->start == sym->end)
 132                         continue;
 133
 134                 first_pair = machine__find_kernel_symbol(&kallsyms, type, sym->start, NULL, NULL);
 135                 pair = first_pair;
 136
 137                 if (pair && pair->start == sym->start) {
 138 next_pair:
 139                         if (strcmp(sym->name, pair->name) == 0) {
 140                                 /*
 141                                  * kallsyms don't have the symbol end, so we
 142                                  * set that by using the next symbol start - 1,
 143                                  * in some cases we get this up to a page
 144                                  * wrong, trace_kmalloc when I was developing
 145                                  * this code was one such example, 2106 bytes
 146                                  * off the real size. More than that and we
 147                                  * _really_ have a problem.
 148                                  */
 149                                 s64 skew = sym->end - pair->end;
 150                                 if (llabs(skew) < page_size)
 151                                         continue;
 152
 153                                 pr_debug("%#" PRIx64 ": diff end addr for %s v: %#" PRIx64 " k: %#" PRIx64 "\n",
 154                                          sym->start, sym->name, sym->end, pair->end);
 155                         } else {
 156                                 struct rb_node *nnd;
 157 detour:
 158                                 nnd = backwards ? rb_prev(&pair->rb_node) :
 159                                                   rb_next(&pair->rb_node);
 160                                 if (nnd) {
 161                                         struct symbol *next = rb_entry(nnd, struct symbol, rb_node);
 162
 163                                         if (next->start == sym->start) {
 164                                                 pair = next;
 165                                                 goto next_pair;
 166                                         }
 167                                 }
 168
 169                                 if (backwards) {
 170                                         backwards = false;
 171                                         pair = first_pair;
 172                                         goto detour;
 173                                 }
 174
 175                                 pr_debug("%#" PRIx64 ": diff name v: %s k: %s\n",
 176                                          sym->start, sym->name, pair->name);
 177                         }
 178                 } else
 179                         pr_debug("%#" PRIx64 ": %s not on kallsyms\n", sym->start, sym->name);
 180
 181                 err = -1;
 182         }
 183
 184         if (!verbose)
 185                 goto out;
 186
 187         pr_info("Maps only in vmlinux:\n");
 188
 189         for (nd = rb_first(&vmlinux.kmaps.maps[type]); nd; nd = rb_next(nd)) {
 190                 struct map *pos = rb_entry(nd, struct map, rb_node), *pair;
 191                 /*
 192                  * If it is the kernel, kallsyms is always "[kernel.kallsyms]", while
 193                  * the kernel will have the path for the vmlinux file being used,
 194                  * so use the short name, less descriptive but the same ("[kernel]" in
 195                  * both cases.
 196                  */
 197                 pair = map_groups__find_by_name(&kallsyms.kmaps, type,
 198                                                 (pos->dso->kernel ?
 199                                                         pos->dso->short_name :
 200                                                         pos->dso->name));
 201                 if (pair)
 202                         pair->priv = 1;
 203                 else
 204                         map__fprintf(pos, stderr);
 205         }
 206
 207         pr_info("Maps in vmlinux with a different name in kallsyms:\n");
 208
 209         for (nd = rb_first(&vmlinux.kmaps.maps[type]); nd; nd = rb_next(nd)) {
 210                 struct map *pos = rb_entry(nd, struct map, rb_node), *pair;
 211
 212                 pair = map_groups__find(&kallsyms.kmaps, type, pos->start);
 213                 if (pair == NULL || pair->priv)
 214                         continue;
 215
 216                 if (pair->start == pos->start) {
 217                         pair->priv = 1;
 218                         pr_info(" %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s in kallsyms as",
 219                                 pos->start, pos->end, pos->pgoff, pos->dso->name);
 220                         if (pos->pgoff != pair->pgoff || pos->end != pair->end)
 221                                 pr_info(": \n*%" PRIx64 "-%" PRIx64 " %" PRIx64 "",
 222                                         pair->start, pair->end, pair->pgoff);
 223                         pr_info(" %s\n", pair->dso->name);
 224                         pair->priv = 1;
 225                 }
 226         }
 227
 228         pr_info("Maps only in kallsyms:\n");
 229
 230         for (nd = rb_first(&kallsyms.kmaps.maps[type]);
 231              nd; nd = rb_next(nd)) {
 232                 struct map *pos = rb_entry(nd, struct map, rb_node);
 233
 234                 if (!pos->priv)
 235                         map__fprintf(pos, stderr);
 236         }
 237 out:
 238         return err;
 239 }
 240
 241 #include "util/cpumap.h"
 242 #include "util/evsel.h"
 243 #include <sys/types.h>
 244
 245 static int trace_event__id(const char *evname)
 246 {
 247         char *filename;
 248         int err = -1, fd;
 249
 250         if (asprintf(&filename,
 251                      "%s/syscalls/%s/id",
 252                      tracing_events_path, evname) < 0)
 253                 return -1;
 254
 255         fd = open(filename, O_RDONLY);
 256         if (fd >= 0) {
 257                 char id[16];
 258                 if (read(fd, id, sizeof(id)) > 0)
 259                         err = atoi(id);
 260                 close(fd);
 261         }
 262
 263         free(filename);
 264         return err;
 265 }
 266
 267 static int test__open_syscall_event(void)
 268 {
 269         int err = -1, fd;
 270         struct thread_map *threads;
 271         struct perf_evsel *evsel;
 272         struct perf_event_attr attr;
 273         unsigned int nr_open_calls = 111, i;
 274         int id = trace_event__id("sys_enter_open");
 275
 276         if (id < 0) {
 277                 pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
 278                 return -1;
 279         }
 280
 281         threads = thread_map__new(-1, getpid(), UINT_MAX);
 282         if (threads == NULL) {
 283                 pr_debug("thread_map__new\n");
 284                 return -1;
 285         }
 286
 287         memset(&attr, 0, sizeof(attr));
 288         attr.type = PERF_TYPE_TRACEPOINT;
 289         attr.config = id;
 290         evsel = perf_evsel__new(&attr, 0);
 291         if (evsel == NULL) {
 292                 pr_debug("perf_evsel__new\n");
 293                 goto out_thread_map_delete;
 294         }
 295
 296         if (perf_evsel__open_per_thread(evsel, threads, false, NULL) < 0) {
 297                 pr_debug("failed to open counter: %s, "
 298                          "tweak /proc/sys/kernel/perf_event_paranoid?\n",
 299                          strerror(errno));
 300                 goto out_evsel_delete;
 301         }
 302
 303         for (i = 0; i < nr_open_calls; ++i) {
 304                 fd = open("/etc/passwd", O_RDONLY);
 305                 close(fd);
 306         }
 307
 308         if (perf_evsel__read_on_cpu(evsel, 0, 0) < 0) {
 309                 pr_debug("perf_evsel__read_on_cpu\n");
 310                 goto out_close_fd;
 311         }
 312
 313         if (evsel->counts->cpu[0].val != nr_open_calls) {
 314                 pr_debug("perf_evsel__read_on_cpu: expected to intercept %d calls, got %" PRIu64 "\n",
 315                          nr_open_calls, evsel->counts->cpu[0].val);
 316                 goto out_close_fd;
 317         }
 318
 319         err = 0;
 320 out_close_fd:
 321         perf_evsel__close_fd(evsel, 1, threads->nr);
 322 out_evsel_delete:
 323         perf_evsel__delete(evsel);
 324 out_thread_map_delete:
 325         thread_map__delete(threads);
 326         return err;
 327 }
 328
 329 #include <sched.h>
 330
 331 static int test__open_syscall_event_on_all_cpus(void)
 332 {
 333         int err = -1, fd, cpu;
 334         struct thread_map *threads;
 335         struct cpu_map *cpus;
 336         struct perf_evsel *evsel;
 337         struct perf_event_attr attr;
 338         unsigned int nr_open_calls = 111, i;
 339         cpu_set_t cpu_set;
 340         int id = trace_event__id("sys_enter_open");
 341
 342         if (id < 0) {
 343                 pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
 344                 return -1;
 345         }
 346
 347         threads = thread_map__new(-1, getpid(), UINT_MAX);
 348         if (threads == NULL) {
 349                 pr_debug("thread_map__new\n");
 350                 return -1;
 351         }
 352
 353         cpus = cpu_map__new(NULL);
 354         if (cpus == NULL) {
 355                 pr_debug("cpu_map__new\n");
 356                 goto out_thread_map_delete;
 357         }
 358
 359
 360         CPU_ZERO(&cpu_set);
 361
 362         memset(&attr, 0, sizeof(attr));
 363         attr.type = PERF_TYPE_TRACEPOINT;
 364         attr.config = id;
 365         evsel = perf_evsel__new(&attr, 0);
 366         if (evsel == NULL) {
 367                 pr_debug("perf_evsel__new\n");
 368                 goto out_thread_map_delete;
 369         }
 370
 371         if (perf_evsel__open(evsel, cpus, threads, false, NULL) < 0) {
 372                 pr_debug("failed to open counter: %s, "
 373                          "tweak /proc/sys/kernel/perf_event_paranoid?\n",
 374                          strerror(errno));
 375                 goto out_evsel_delete;
 376         }
 377
 378         for (cpu = 0; cpu < cpus->nr; ++cpu) {
 379                 unsigned int ncalls = nr_open_calls + cpu;
 380                 /*
 381                  * XXX eventually lift this restriction in a way that
 382                  * keeps perf building on older glibc installations
 383                  * without CPU_ALLOC. 1024 cpus in 2010 still seems
 384                  * a reasonable upper limit tho :-)
 385                  */
 386                 if (cpus->map[cpu] >= CPU_SETSIZE) {
 387                         pr_debug("Ignoring CPU %d\n", cpus->map[cpu]);
 388                         continue;
 389                 }
 390
 391                 CPU_SET(cpus->map[cpu], &cpu_set);
 392                 if (sched_setaffinity(0, sizeof(cpu_set), &cpu_set) < 0) {
 393                         pr_debug("sched_setaffinity() failed on CPU %d: %s ",
 394                                  cpus->map[cpu],
 395                                  strerror(errno));
 396                         goto out_close_fd;
 397                 }
 398                 for (i = 0; i < ncalls; ++i) {
 399                         fd = open("/etc/passwd", O_RDONLY);
 400                         close(fd);
 401                 }
 402                 CPU_CLR(cpus->map[cpu], &cpu_set);
 403         }
 404
 405         /*
 406          * Here we need to explicitely preallocate the counts, as if
 407          * we use the auto allocation it will allocate just for 1 cpu,
 408          * as we start by cpu 0.
 409          */
 410         if (perf_evsel__alloc_counts(evsel, cpus->nr) < 0) {
 411                 pr_debug("perf_evsel__alloc_counts(ncpus=%d)\n", cpus->nr);
 412                 goto out_close_fd;
 413         }
 414
 415         err = 0;
 416
 417         for (cpu = 0; cpu < cpus->nr; ++cpu) {
 418                 unsigned int expected;
 419
 420                 if (cpus->map[cpu] >= CPU_SETSIZE)
 421                         continue;
 422
 423                 if (perf_evsel__read_on_cpu(evsel, cpu, 0) < 0) {
 424                         pr_debug("perf_evsel__read_on_cpu\n");
 425                         err = -1;
 426                         break;
 427                 }
 428
 429                 expected = nr_open_calls + cpu;
 430                 if (evsel->counts->cpu[cpu].val != expected) {
 431                         pr_debug("perf_evsel__read_on_cpu: expected to intercept %d calls on cpu %d, got %" PRIu64 "\n",
 432                                  expected, cpus->map[cpu], evsel->counts->cpu[cpu].val);
 433                         err = -1;
 434                 }
 435         }
 436
 437 out_close_fd:
 438         perf_evsel__close_fd(evsel, 1, threads->nr);
 439 out_evsel_delete:
 440         perf_evsel__delete(evsel);
 441 out_thread_map_delete:
 442         thread_map__delete(threads);
 443         return err;
 444 }
 445
 446 /*
 447  * This test will generate random numbers of calls to some getpid syscalls,
 448  * then establish an mmap for a group of events that are created to monitor
 449  * the syscalls.
 450  *
 451  * It will receive the events, using mmap, use its PERF_SAMPLE_ID generated
 452  * sample.id field to map back to its respective perf_evsel instance.
 453  *
 454  * Then it checks if the number of syscalls reported as perf events by
 455  * the kernel corresponds to the number of syscalls made.
 456  */
 457 static int test__basic_mmap(void)
 458 {
 459         int err = -1;
 460         union perf_event *event;
 461         struct thread_map *threads;
 462         struct cpu_map *cpus;
 463         struct perf_evlist *evlist;
 464         struct perf_event_attr attr = {
 465                 .type           = PERF_TYPE_TRACEPOINT,
 466                 .read_format    = PERF_FORMAT_ID,
 467                 .sample_type    = PERF_SAMPLE_ID,
 468                 .watermark      = 0,
 469         };
 470         cpu_set_t cpu_set;
 471         const char *syscall_names[] = { "getsid", "getppid", "getpgrp",
 472                                         "getpgid", };
 473         pid_t (*syscalls[])(void) = { (void *)getsid, getppid, getpgrp,
 474                                       (void*)getpgid };
 475 #define nsyscalls ARRAY_SIZE(syscall_names)
 476         int ids[nsyscalls];
 477         unsigned int nr_events[nsyscalls],
 478                      expected_nr_events[nsyscalls], i, j;
 479         struct perf_evsel *evsels[nsyscalls], *evsel;
 480         int sample_size = __perf_evsel__sample_size(attr.sample_type);
 481
 482         for (i = 0; i < nsyscalls; ++i) {
 483                 char name[64];
 484
 485                 snprintf(name, sizeof(name), "sys_enter_%s", syscall_names[i]);
 486                 ids[i] = trace_event__id(name);
 487                 if (ids[i] < 0) {
 488                         pr_debug("Is debugfs mounted on /sys/kernel/debug?\n");
 489                         return -1;
 490                 }
 491                 nr_events[i] = 0;
 492                 expected_nr_events[i] = random() % 257;
 493         }
 494
 495         threads = thread_map__new(-1, getpid(), UINT_MAX);
 496         if (threads == NULL) {
 497                 pr_debug("thread_map__new\n");
 498                 return -1;
 499         }
 500
 501         cpus = cpu_map__new(NULL);
 502         if (cpus == NULL) {
 503                 pr_debug("cpu_map__new\n");
 504                 goto out_free_threads;
 505         }
 506
 507         CPU_ZERO(&cpu_set);
 508         CPU_SET(cpus->map[0], &cpu_set);
 509         sched_setaffinity(0, sizeof(cpu_set), &cpu_set);
 510         if (sched_setaffinity(0, sizeof(cpu_set), &cpu_set) < 0) {
 511                 pr_debug("sched_setaffinity() failed on CPU %d: %s ",
 512                          cpus->map[0], strerror(errno));
 513                 goto out_free_cpus;
 514         }
 515
 516         evlist = perf_evlist__new(cpus, threads);
 517         if (evlist == NULL) {
 518                 pr_debug("perf_evlist__new\n");
 519                 goto out_free_cpus;
 520         }
 521
 522         /* anonymous union fields, can't be initialized above */
 523         attr.wakeup_events = 1;
 524         attr.sample_period = 1;
 525
 526         for (i = 0; i < nsyscalls; ++i) {
 527                 attr.config = ids[i];
 528                 evsels[i] = perf_evsel__new(&attr, i);
 529                 if (evsels[i] == NULL) {
 530                         pr_debug("perf_evsel__new\n");
 531                         goto out_free_evlist;
 532                 }
 533
 534                 perf_evlist__add(evlist, evsels[i]);
 535
 536                 if (perf_evsel__open(evsels[i], cpus, threads, false, NULL) < 0) {
 537                         pr_debug("failed to open counter: %s, "
 538                                  "tweak /proc/sys/kernel/perf_event_paranoid?\n",
 539                                  strerror(errno));
 540                         goto out_close_fd;
 541                 }
 542         }
 543
 544         if (perf_evlist__mmap(evlist, 128, true) < 0) {
 545                 pr_debug("failed to mmap events: %d (%s)\n", errno,
 546                          strerror(errno));
 547                 goto out_close_fd;
 548         }
 549
 550         for (i = 0; i < nsyscalls; ++i)
 551                 for (j = 0; j < expected_nr_events[i]; ++j) {
 552                         int foo = syscalls[i]();
 553                         ++foo;
 554                 }
 555
 556         while ((event = perf_evlist__mmap_read(evlist, 0)) != NULL) {
 557                 struct perf_sample sample;
 558
 559                 if (event->header.type != PERF_RECORD_SAMPLE) {
 560                         pr_debug("unexpected %s event\n",
 561                                  perf_event__name(event->header.type));
 562                         goto out_munmap;
 563                 }
 564
 565                 err = perf_event__parse_sample(event, attr.sample_type, sample_size,
 566                                                false, &sample, false);
 567                 if (err) {
 568                         pr_err("Can't parse sample, err = %d\n", err);
 569                         goto out_munmap;
 570                 }
 571
 572                 evsel = perf_evlist__id2evsel(evlist, sample.id);
 573                 if (evsel == NULL) {
 574                         pr_debug("event with id %" PRIu64
 575                                  " doesn't map to an evsel\n", sample.id);
 576                         goto out_munmap;
 577                 }
 578                 nr_events[evsel->idx]++;
 579         }
 580
 581         list_for_each_entry(evsel, &evlist->entries, node) {
 582                 if (nr_events[evsel->idx] != expected_nr_events[evsel->idx]) {
 583                         pr_debug("expected %d %s events, got %d\n",
 584                                  expected_nr_events[evsel->idx],
 585                                  event_name(evsel), nr_events[evsel->idx]);
 586                         goto out_munmap;
 587                 }
 588         }
 589
 590         err = 0;
 591 out_munmap:
 592         perf_evlist__munmap(evlist);
 593 out_close_fd:
 594         for (i = 0; i < nsyscalls; ++i)
 595                 perf_evsel__close_fd(evsels[i], 1, threads->nr);
 596 out_free_evlist:
 597         perf_evlist__delete(evlist);
 598 out_free_cpus:
 599         cpu_map__delete(cpus);
 600 out_free_threads:
 601         thread_map__delete(threads);
 602         return err;
 603 #undef nsyscalls
 604 }
 605
 606 #define TEST_ASSERT_VAL(text, cond) \
 607 do { \
 608         if (!(cond)) { \
 609                 pr_debug("FAILED %s:%d %s\n", __FILE__, __LINE__, text); \
 610                 return -1; \
 611         } \
 612 } while (0)
 613
 614 static int test__checkevent_tracepoint(struct perf_evlist *evlist)
 615 {
 616         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 617                                               struct perf_evsel, node);
 618
 619         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
 620         TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->attr.type);
 621         TEST_ASSERT_VAL("wrong sample_type",
 622                 (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | PERF_SAMPLE_CPU) ==
 623                 evsel->attr.sample_type);
 624         TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->attr.sample_period);
 625         return 0;
 626 }
 627
 628 static int test__checkevent_tracepoint_multi(struct perf_evlist *evlist)
 629 {
 630         struct perf_evsel *evsel;
 631
 632         TEST_ASSERT_VAL("wrong number of entries", evlist->nr_entries > 1);
 633
 634         list_for_each_entry(evsel, &evlist->entries, node) {
 635                 TEST_ASSERT_VAL("wrong type",
 636                         PERF_TYPE_TRACEPOINT == evsel->attr.type);
 637                 TEST_ASSERT_VAL("wrong sample_type",
 638                         (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | PERF_SAMPLE_CPU)
 639                         == evsel->attr.sample_type);
 640                 TEST_ASSERT_VAL("wrong sample_period",
 641                         1 == evsel->attr.sample_period);
 642         }
 643         return 0;
 644 }
 645
 646 static int test__checkevent_raw(struct perf_evlist *evlist)
 647 {
 648         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 649                                               struct perf_evsel, node);
 650
 651         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
 652         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->attr.type);
 653         TEST_ASSERT_VAL("wrong config", 1 == evsel->attr.config);
 654         return 0;
 655 }
 656
 657 static int test__checkevent_numeric(struct perf_evlist *evlist)
 658 {
 659         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 660                                               struct perf_evsel, node);
 661
 662         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
 663         TEST_ASSERT_VAL("wrong type", 1 == evsel->attr.type);
 664         TEST_ASSERT_VAL("wrong config", 1 == evsel->attr.config);
 665         return 0;
 666 }
 667
 668 static int test__checkevent_symbolic_name(struct perf_evlist *evlist)
 669 {
 670         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 671                                               struct perf_evsel, node);
 672
 673         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
 674         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
 675         TEST_ASSERT_VAL("wrong config",
 676                         PERF_COUNT_HW_INSTRUCTIONS == evsel->attr.config);
 677         return 0;
 678 }
 679
 680 static int test__checkevent_symbolic_alias(struct perf_evlist *evlist)
 681 {
 682         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 683                                               struct perf_evsel, node);
 684
 685         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
 686         TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->attr.type);
 687         TEST_ASSERT_VAL("wrong config",
 688                         PERF_COUNT_SW_PAGE_FAULTS == evsel->attr.config);
 689         return 0;
 690 }
 691
 692 static int test__checkevent_genhw(struct perf_evlist *evlist)
 693 {
 694         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 695                                               struct perf_evsel, node);
 696
 697         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
 698         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HW_CACHE == evsel->attr.type);
 699         TEST_ASSERT_VAL("wrong config", (1 << 16) == evsel->attr.config);
 700         return 0;
 701 }
 702
 703 static int test__checkevent_breakpoint(struct perf_evlist *evlist)
 704 {
 705         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 706                                               struct perf_evsel, node);
 707
 708         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
 709         TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->attr.type);
 710         TEST_ASSERT_VAL("wrong config", 0 == evsel->attr.config);
 711         TEST_ASSERT_VAL("wrong bp_type", (HW_BREAKPOINT_R | HW_BREAKPOINT_W) ==
 712                                          evsel->attr.bp_type);
 713         TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_4 ==
 714                                         evsel->attr.bp_len);
 715         return 0;
 716 }
 717
 718 static int test__checkevent_breakpoint_x(struct perf_evlist *evlist)
 719 {
 720         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 721                                               struct perf_evsel, node);
 722
 723         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
 724         TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->attr.type);
 725         TEST_ASSERT_VAL("wrong config", 0 == evsel->attr.config);
 726         TEST_ASSERT_VAL("wrong bp_type",
 727                         HW_BREAKPOINT_X == evsel->attr.bp_type);
 728         TEST_ASSERT_VAL("wrong bp_len", sizeof(long) == evsel->attr.bp_len);
 729         return 0;
 730 }
 731
 732 static int test__checkevent_breakpoint_r(struct perf_evlist *evlist)
 733 {
 734         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 735                                               struct perf_evsel, node);
 736
 737         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
 738         TEST_ASSERT_VAL("wrong type",
 739                         PERF_TYPE_BREAKPOINT == evsel->attr.type);
 740         TEST_ASSERT_VAL("wrong config", 0 == evsel->attr.config);
 741         TEST_ASSERT_VAL("wrong bp_type",
 742                         HW_BREAKPOINT_R == evsel->attr.bp_type);
 743         TEST_ASSERT_VAL("wrong bp_len",
 744                         HW_BREAKPOINT_LEN_4 == evsel->attr.bp_len);
 745         return 0;
 746 }
 747
 748 static int test__checkevent_breakpoint_w(struct perf_evlist *evlist)
 749 {
 750         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 751                                               struct perf_evsel, node);
 752
 753         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
 754         TEST_ASSERT_VAL("wrong type",
 755                         PERF_TYPE_BREAKPOINT == evsel->attr.type);
 756         TEST_ASSERT_VAL("wrong config", 0 == evsel->attr.config);
 757         TEST_ASSERT_VAL("wrong bp_type",
 758                         HW_BREAKPOINT_W == evsel->attr.bp_type);
 759         TEST_ASSERT_VAL("wrong bp_len",
 760                         HW_BREAKPOINT_LEN_4 == evsel->attr.bp_len);
 761         return 0;
 762 }
 763
 764 static int test__checkevent_tracepoint_modifier(struct perf_evlist *evlist)
 765 {
 766         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 767                                               struct perf_evsel, node);
 768
 769         TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
 770         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
 771         TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
 772         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
 773
 774         return test__checkevent_tracepoint(evlist);
 775 }
 776
 777 static int
 778 test__checkevent_tracepoint_multi_modifier(struct perf_evlist *evlist)
 779 {
 780         struct perf_evsel *evsel;
 781
 782         TEST_ASSERT_VAL("wrong number of entries", evlist->nr_entries > 1);
 783
 784         list_for_each_entry(evsel, &evlist->entries, node) {
 785                 TEST_ASSERT_VAL("wrong exclude_user",
 786                                 !evsel->attr.exclude_user);
 787                 TEST_ASSERT_VAL("wrong exclude_kernel",
 788                                 evsel->attr.exclude_kernel);
 789                 TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
 790                 TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
 791         }
 792
 793         return test__checkevent_tracepoint_multi(evlist);
 794 }
 795
 796 static int test__checkevent_raw_modifier(struct perf_evlist *evlist)
 797 {
 798         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 799                                               struct perf_evsel, node);
 800
 801         TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
 802         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
 803         TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
 804         TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip);
 805
 806         return test__checkevent_raw(evlist);
 807 }
 808
 809 static int test__checkevent_numeric_modifier(struct perf_evlist *evlist)
 810 {
 811         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 812                                               struct perf_evsel, node);
 813
 814         TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
 815         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
 816         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv);
 817         TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip);
 818
 819         return test__checkevent_numeric(evlist);
 820 }
 821
 822 static int test__checkevent_symbolic_name_modifier(struct perf_evlist *evlist)
 823 {
 824         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 825                                               struct perf_evsel, node);
 826
 827         TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
 828         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
 829         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv);
 830         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
 831
 832         return test__checkevent_symbolic_name(evlist);
 833 }
 834
 835 static int test__checkevent_symbolic_alias_modifier(struct perf_evlist *evlist)
 836 {
 837         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 838                                               struct perf_evsel, node);
 839
 840         TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
 841         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
 842         TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
 843         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
 844
 845         return test__checkevent_symbolic_alias(evlist);
 846 }
 847
 848 static int test__checkevent_genhw_modifier(struct perf_evlist *evlist)
 849 {
 850         struct perf_evsel *evsel = list_entry(evlist->entries.next,
 851                                               struct perf_evsel, node);
 852
 853         TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
 854         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
 855         TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
 856         TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip);
 857
 858         return test__checkevent_genhw(evlist);
 859 }
 860
 861 static struct test__event_st {
 862         const char *name;
 863         __u32 type;
 864         int (*check)(struct perf_evlist *evlist);
 865 } test__events[] = {
 866         {
 867                 .name  = "syscalls:sys_enter_open",
 868                 .check = test__checkevent_tracepoint,
 869         },
 870         {
 871                 .name  = "syscalls:*",
 872                 .check = test__checkevent_tracepoint_multi,
 873         },
 874         {
 875                 .name  = "r1",
 876                 .check = test__checkevent_raw,
 877         },
 878         {
 879                 .name  = "1:1",
 880                 .check = test__checkevent_numeric,
 881         },
 882         {
 883                 .name  = "instructions",
 884                 .check = test__checkevent_symbolic_name,
 885         },
 886         {
 887                 .name  = "faults",
 888                 .check = test__checkevent_symbolic_alias,
 889         },
 890         {
 891                 .name  = "L1-dcache-load-miss",
 892                 .check = test__checkevent_genhw,
 893         },
 894         {
 895                 .name  = "mem:0",
 896                 .check = test__checkevent_breakpoint,
 897         },
 898         {
 899                 .name  = "mem:0:x",
 900                 .check = test__checkevent_breakpoint_x,
 901         },
 902         {
 903                 .name  = "mem:0:r",
 904                 .check = test__checkevent_breakpoint_r,
 905         },
 906         {
 907                 .name  = "mem:0:w",
 908                 .check = test__checkevent_breakpoint_w,
 909         },
 910         {
 911                 .name  = "syscalls:sys_enter_open:k",
 912                 .check = test__checkevent_tracepoint_modifier,
 913         },
 914         {
 915                 .name  = "syscalls:*:u",
 916                 .check = test__checkevent_tracepoint_multi_modifier,
 917         },
 918         {
 919                 .name  = "r1:kp",
 920                 .check = test__checkevent_raw_modifier,
 921         },
 922         {
 923                 .name  = "1:1:hp",
 924                 .check = test__checkevent_numeric_modifier,
 925         },
 926         {
 927                 .name  = "instructions:h",
 928                 .check = test__checkevent_symbolic_name_modifier,
 929         },
 930         {
 931                 .name  = "faults:u",
 932                 .check = test__checkevent_symbolic_alias_modifier,
 933         },
 934         {
 935                 .name  = "L1-dcache-load-miss:kp",
 936                 .check = test__checkevent_genhw_modifier,
 937         },
 938 };
 939
 940 #define TEST__EVENTS_CNT (sizeof(test__events) / sizeof(struct test__event_st))
 941
 942 static int test__parse_events(void)
 943 {
 944         struct perf_evlist *evlist;
 945         u_int i;
 946         int ret = 0;
 947
 948         for (i = 0; i < TEST__EVENTS_CNT; i++) {
 949                 struct test__event_st *e = &test__events[i];
 950
 951                 evlist = perf_evlist__new(NULL, NULL);
 952                 if (evlist == NULL)
 953                         break;
 954
 955                 ret = parse_events(evlist, e->name, 0);
 956                 if (ret) {
 957                         pr_debug("failed to parse event '%s', err %d\n",
 958                                  e->name, ret);
 959                         break;
 960                 }
 961
 962                 ret = e->check(evlist);
 963                 if (ret)
 964                         break;
 965
 966                 perf_evlist__delete(evlist);
 967         }
 968
 969         return ret;
 970 }
 971
 972 static int sched__get_first_possible_cpu(pid_t pid, cpu_set_t **maskp,
 973                                          size_t *sizep)
 974 {
 975         cpu_set_t *mask;
 976         size_t size;
 977         int i, cpu = -1, nrcpus = 1024;
 978 realloc:
 979         mask = CPU_ALLOC(nrcpus);
 980         size = CPU_ALLOC_SIZE(nrcpus);
 981         CPU_ZERO_S(size, mask);
 982
 983         if (sched_getaffinity(pid, size, mask) == -1) {
 984                 CPU_FREE(mask);
 985                 if (errno == EINVAL && nrcpus < (1024 << 8)) {
 986                         nrcpus = nrcpus << 2;
 987                         goto realloc;
 988                 }
 989                 perror("sched_getaffinity");
 990                         return -1;
 991         }
 992
 993         for (i = 0; i < nrcpus; i++) {
 994                 if (CPU_ISSET_S(i, size, mask)) {
 995                         if (cpu == -1) {
 996                                 cpu = i;
 997                                 *maskp = mask;
 998                                 *sizep = size;
 999                         } else
1000                                 CPU_CLR_S(i, size, mask);
1001                 }
1002         }
1003
1004         if (cpu == -1)
1005                 CPU_FREE(mask);
1006
1007         return cpu;
1008 }
1009
1010 static int test__PERF_RECORD(void)
1011 {
1012         struct perf_record_opts opts = {
1013                 .no_delay   = true,
1014                 .freq       = 10,
1015                 .mmap_pages = 256,
1016                 .sample_id_all_avail = true,
1017         };
1018         cpu_set_t *cpu_mask = NULL;
1019         size_t cpu_mask_size = 0;
1020         struct perf_evlist *evlist = perf_evlist__new(NULL, NULL);
1021         struct perf_evsel *evsel;
1022         struct perf_sample sample;
1023         const char *cmd = "sleep";
1024         const char *argv[] = { cmd, "1", NULL, };
1025         char *bname;
1026         u64 sample_type, prev_time = 0;
1027         bool found_cmd_mmap = false,
1028              found_libc_mmap = false,
1029              found_vdso_mmap = false,
1030              found_ld_mmap = false;
1031         int err = -1, errs = 0, i, wakeups = 0, sample_size;
1032         u32 cpu;
1033         int total_events = 0, nr_events[PERF_RECORD_MAX] = { 0, };
1034
1035         if (evlist == NULL || argv == NULL) {
1036                 pr_debug("Not enough memory to create evlist\n");
1037                 goto out;
1038         }
1039
1040         /*
1041          * We need at least one evsel in the evlist, use the default
1042          * one: "cycles".
1043          */
1044         err = perf_evlist__add_default(evlist);
1045         if (err < 0) {
1046                 pr_debug("Not enough memory to create evsel\n");
1047                 goto out_delete_evlist;
1048         }
1049
1050         /*
1051          * Create maps of threads and cpus to monitor. In this case
1052          * we start with all threads and cpus (-1, -1) but then in
1053          * perf_evlist__prepare_workload we'll fill in the only thread
1054          * we're monitoring, the one forked there.
1055          */
1056         err = perf_evlist__create_maps(evlist, opts.target_pid,
1057                                        opts.target_tid, UINT_MAX, opts.cpu_list);
1058         if (err < 0) {
1059                 pr_debug("Not enough memory to create thread/cpu maps\n");
1060                 goto out_delete_evlist;
1061         }
1062
1063         /*
1064          * Prepare the workload in argv[] to run, it'll fork it, and then wait
1065          * for perf_evlist__start_workload() to exec it. This is done this way
1066          * so that we have time to open the evlist (calling sys_perf_event_open
1067          * on all the fds) and then mmap them.
1068          */
1069         err = perf_evlist__prepare_workload(evlist, &opts, argv);
1070         if (err < 0) {
1071                 pr_debug("Couldn't run the workload!\n");
1072                 goto out_delete_evlist;
1073         }
1074
1075         /*
1076          * Config the evsels, setting attr->comm on the first one, etc.
1077          */
1078         evsel = list_entry(evlist->entries.next, struct perf_evsel, node);
1079         evsel->attr.sample_type |= PERF_SAMPLE_CPU;
1080         evsel->attr.sample_type |= PERF_SAMPLE_TID;
1081         evsel->attr.sample_type |= PERF_SAMPLE_TIME;
1082         perf_evlist__config_attrs(evlist, &opts);
1083
1084         err = sched__get_first_possible_cpu(evlist->workload.pid, &cpu_mask,
1085                                             &cpu_mask_size);
1086         if (err < 0) {
1087                 pr_debug("sched__get_first_possible_cpu: %s\n", strerror(errno));
1088                 goto out_delete_evlist;
1089         }
1090
1091         cpu = err;
1092
1093         /*
1094          * So that we can check perf_sample.cpu on all the samples.
1095          */
1096         if (sched_setaffinity(evlist->workload.pid, cpu_mask_size, cpu_mask) < 0) {
1097                 pr_debug("sched_setaffinity: %s\n", strerror(errno));
1098                 goto out_free_cpu_mask;
1099         }
1100
1101         /*
1102          * Call sys_perf_event_open on all the fds on all the evsels,
1103          * grouping them if asked to.
1104          */
1105         err = perf_evlist__open(evlist, opts.group);
1106         if (err < 0) {
1107                 pr_debug("perf_evlist__open: %s\n", strerror(errno));
1108                 goto out_delete_evlist;
1109         }
1110
1111         /*
1112          * mmap the first fd on a given CPU and ask for events for the other
1113          * fds in the same CPU to be injected in the same mmap ring buffer
1114          * (using ioctl(PERF_EVENT_IOC_SET_OUTPUT)).
1115          */
1116         err = perf_evlist__mmap(evlist, opts.mmap_pages, false);
1117         if (err < 0) {
1118                 pr_debug("perf_evlist__mmap: %s\n", strerror(errno));
1119                 goto out_delete_evlist;
1120         }
1121
1122         /*
1123          * We'll need these two to parse the PERF_SAMPLE_* fields in each
1124          * event.
1125          */
1126         sample_type = perf_evlist__sample_type(evlist);
1127         sample_size = __perf_evsel__sample_size(sample_type);
1128
1129         /*
1130          * Now that all is properly set up, enable the events, they will
1131          * count just on workload.pid, which will start...
1132          */
1133         perf_evlist__enable(evlist);
1134
1135         /*
1136          * Now!
1137          */
1138         perf_evlist__start_workload(evlist);
1139
1140         while (1) {
1141                 int before = total_events;
1142
1143                 for (i = 0; i < evlist->nr_mmaps; i++) {
1144                         union perf_event *event;
1145
1146                         while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
1147                                 const u32 type = event->header.type;
1148                                 const char *name = perf_event__name(type);
1149
1150                                 ++total_events;
1151                                 if (type < PERF_RECORD_MAX)
1152                                         nr_events[type]++;
1153
1154                                 err = perf_event__parse_sample(event, sample_type,
1155                                                                sample_size, true,
1156                                                                &sample, false);
1157                                 if (err < 0) {
1158                                         if (verbose)
1159                                                 perf_event__fprintf(event, stderr);
1160                                         pr_debug("Couldn't parse sample\n");
1161                                         goto out_err;
1162                                 }
1163
1164                                 if (verbose) {
1165                                         pr_info("%" PRIu64" %d ", sample.time, sample.cpu);
1166                                         perf_event__fprintf(event, stderr);
1167                                 }
1168
1169                                 if (prev_time > sample.time) {
1170                                         pr_debug("%s going backwards in time, prev=%" PRIu64 ", curr=%" PRIu64 "\n",
1171                                                  name, prev_time, sample.time);
1172                                         ++errs;
1173                                 }
1174
1175                                 prev_time = sample.time;
1176
1177                                 if (sample.cpu != cpu) {
1178                                         pr_debug("%s with unexpected cpu, expected %d, got %d\n",
1179                                                  name, cpu, sample.cpu);
1180                                         ++errs;
1181                                 }
1182
1183                                 if ((pid_t)sample.pid != evlist->workload.pid) {
1184                                         pr_debug("%s with unexpected pid, expected %d, got %d\n",
1185                                                  name, evlist->workload.pid, sample.pid);
1186                                         ++errs;
1187                                 }
1188
1189                                 if ((pid_t)sample.tid != evlist->workload.pid) {
1190                                         pr_debug("%s with unexpected tid, expected %d, got %d\n",
1191                                                  name, evlist->workload.pid, sample.tid);
1192                                         ++errs;
1193                                 }
1194
1195                                 if ((type == PERF_RECORD_COMM ||
1196                                      type == PERF_RECORD_MMAP ||
1197                                      type == PERF_RECORD_FORK ||
1198                                      type == PERF_RECORD_EXIT) &&
1199                                      (pid_t)event->comm.pid != evlist->workload.pid) {
1200                                         pr_debug("%s with unexpected pid/tid\n", name);
1201                                         ++errs;
1202                                 }
1203
1204                                 if ((type == PERF_RECORD_COMM ||
1205                                      type == PERF_RECORD_MMAP) &&
1206                                      event->comm.pid != event->comm.tid) {
1207                                         pr_debug("%s with different pid/tid!\n", name);
1208                                         ++errs;
1209                                 }
1210
1211                                 switch (type) {
1212                                 case PERF_RECORD_COMM:
1213                                         if (strcmp(event->comm.comm, cmd)) {
1214                                                 pr_debug("%s with unexpected comm!\n", name);
1215                                                 ++errs;
1216                                         }
1217                                         break;
1218                                 case PERF_RECORD_EXIT:
1219                                         goto found_exit;
1220                                 case PERF_RECORD_MMAP:
1221                                         bname = strrchr(event->mmap.filename, '/');
1222                                         if (bname != NULL) {
1223                                                 if (!found_cmd_mmap)
1224                                                         found_cmd_mmap = !strcmp(bname + 1, cmd);
1225                                                 if (!found_libc_mmap)
1226                                                         found_libc_mmap = !strncmp(bname + 1, "libc", 4);
1227                                                 if (!found_ld_mmap)
1228                                                         found_ld_mmap = !strncmp(bname + 1, "ld", 2);
1229                                         } else if (!found_vdso_mmap)
1230                                                 found_vdso_mmap = !strcmp(event->mmap.filename, "[vdso]");
1231                                         break;
1232
1233                                 case PERF_RECORD_SAMPLE:
1234                                         /* Just ignore samples for now */
1235                                         break;
1236                                 default:
1237                                         pr_debug("Unexpected perf_event->header.type %d!\n",
1238                                                  type);
1239                                         ++errs;
1240                                 }
1241                         }
1242                 }
1243
1244                 /*
1245                  * We don't use poll here because at least at 3.1 times the
1246                  * PERF_RECORD_{!SAMPLE} events don't honour
1247                  * perf_event_attr.wakeup_events, just PERF_EVENT_SAMPLE does.
1248                  */
1249                 if (total_events == before && false)
1250                         poll(evlist->pollfd, evlist->nr_fds, -1);
1251
1252                 sleep(1);
1253                 if (++wakeups > 5) {
1254                         pr_debug("No PERF_RECORD_EXIT event!\n");
1255                         break;
1256                 }
1257         }
1258
1259 found_exit:
1260         if (nr_events[PERF_RECORD_COMM] > 1) {
1261                 pr_debug("Excessive number of PERF_RECORD_COMM events!\n");
1262                 ++errs;
1263         }
1264
1265         if (nr_events[PERF_RECORD_COMM] == 0) {
1266                 pr_debug("Missing PERF_RECORD_COMM for %s!\n", cmd);
1267                 ++errs;
1268         }
1269
1270         if (!found_cmd_mmap) {
1271                 pr_debug("PERF_RECORD_MMAP for %s missing!\n", cmd);
1272                 ++errs;
1273         }
1274
1275         if (!found_libc_mmap) {
1276                 pr_debug("PERF_RECORD_MMAP for %s missing!\n", "libc");
1277                 ++errs;
1278         }
1279
1280         if (!found_ld_mmap) {
1281                 pr_debug("PERF_RECORD_MMAP for %s missing!\n", "ld");
1282                 ++errs;
1283         }
1284
1285         if (!found_vdso_mmap) {
1286                 pr_debug("PERF_RECORD_MMAP for %s missing!\n", "[vdso]");
1287                 ++errs;
1288         }
1289 out_err:
1290         perf_evlist__munmap(evlist);
1291 out_free_cpu_mask:
1292         CPU_FREE(cpu_mask);
1293 out_delete_evlist:
1294         perf_evlist__delete(evlist);
1295 out:
1296         return (err < 0 || errs > 0) ? -1 : 0;
1297 }
1298
1299
1300 #if defined(__x86_64__) || defined(__i386__)
1301
1302 #define barrier() asm volatile("" ::: "memory")
1303
1304 static u64 rdpmc(unsigned int counter)
1305 {
1306         unsigned int low, high;
1307
1308         asm volatile("rdpmc" : "=a" (low), "=d" (high) : "c" (counter));
1309
1310         return low | ((u64)high) << 32;
1311 }
1312
1313 static u64 rdtsc(void)
1314 {
1315         unsigned int low, high;
1316
1317         asm volatile("rdtsc" : "=a" (low), "=d" (high));
1318
1319         return low | ((u64)high) << 32;
1320 }
1321
1322 static u64 mmap_read_self(void *addr)
1323 {
1324         struct perf_event_mmap_page *pc = addr;
1325         u32 seq, idx, time_mult = 0, time_shift = 0;
1326         u64 count, cyc = 0, time_offset = 0, enabled, running, delta;
1327
1328         do {
1329                 seq = pc->lock;
1330                 barrier();
1331
1332                 enabled = pc->time_enabled;
1333                 running = pc->time_running;
1334
1335                 if (enabled != running) {
1336                         cyc = rdtsc();
1337                         time_mult = pc->time_mult;
1338                         time_shift = pc->time_shift;
1339                         time_offset = pc->time_offset;
1340                 }
1341
1342                 idx = pc->index;
1343                 count = pc->offset;
1344                 if (idx)
1345                         count += rdpmc(idx - 1);
1346
1347                 barrier();
1348         } while (pc->lock != seq);
1349
1350         if (enabled != running) {
1351                 u64 quot, rem;
1352
1353                 quot = (cyc >> time_shift);
1354                 rem = cyc & ((1 << time_shift) - 1);
1355                 delta = time_offset + quot * time_mult +
1356                         ((rem * time_mult) >> time_shift);
1357
1358                 enabled += delta;
1359                 if (idx)
1360                         running += delta;
1361
1362                 quot = count / running;
1363                 rem = count % running;
1364                 count = quot * enabled + (rem * enabled) / running;
1365         }
1366
1367         return count;
1368 }
1369
1370 /*
1371  * If the RDPMC instruction faults then signal this back to the test parent task:
1372  */
1373 static void segfault_handler(int sig __used, siginfo_t *info __used, void *uc __used)
1374 {
1375         exit(-1);
1376 }
1377
1378 static int __test__rdpmc(void)
1379 {
1380         long page_size = sysconf(_SC_PAGE_SIZE);
1381         volatile int tmp = 0;
1382         u64 i, loops = 1000;
1383         int n;
1384         int fd;
1385         void *addr;
1386         struct perf_event_attr attr = {
1387                 .type = PERF_TYPE_HARDWARE,
1388                 .config = PERF_COUNT_HW_INSTRUCTIONS,
1389                 .exclude_kernel = 1,
1390         };
1391         u64 delta_sum = 0;
1392         struct sigaction sa;
1393
1394         sigfillset(&sa.sa_mask);
1395         sa.sa_sigaction = segfault_handler;
1396         sigaction(SIGSEGV, &sa, NULL);
1397
1398         fprintf(stderr, "\n\n");
1399
1400         fd = sys_perf_event_open(&attr, 0, -1, -1, 0);
1401         if (fd < 0) {
1402                 die("Error: sys_perf_event_open() syscall returned "
1403                     "with %d (%s)\n", fd, strerror(errno));
1404         }
1405
1406         addr = mmap(NULL, page_size, PROT_READ, MAP_SHARED, fd, 0);
1407         if (addr == (void *)(-1)) {
1408                 die("Error: mmap() syscall returned "
1409                     "with (%s)\n", strerror(errno));
1410         }
1411
1412         for (n = 0; n < 6; n++) {
1413                 u64 stamp, now, delta;
1414
1415                 stamp = mmap_read_self(addr);
1416
1417                 for (i = 0; i < loops; i++)
1418                         tmp++;
1419
1420                 now = mmap_read_self(addr);
1421                 loops *= 10;
1422
1423                 delta = now - stamp;
1424                 fprintf(stderr, "%14d: %14Lu\n", n, (long long)delta);
1425
1426                 delta_sum += delta;
1427         }
1428
1429         munmap(addr, page_size);
1430         close(fd);
1431
1432         fprintf(stderr, "   ");
1433
1434         if (!delta_sum)
1435                 return -1;
1436
1437         return 0;
1438 }
1439
1440 static int test__rdpmc(void)
1441 {
1442         int status = 0;
1443         int wret = 0;
1444         int ret;
1445         int pid;
1446
1447         pid = fork();
1448         if (pid < 0)
1449                 return -1;
1450
1451         if (!pid) {
1452                 ret = __test__rdpmc();
1453
1454                 exit(ret);
1455         }
1456
1457         wret = waitpid(pid, &status, 0);
1458         if (wret < 0 || status)
1459                 return -1;
1460
1461         return 0;
1462 }
1463
1464 #endif
1465
1466 static struct test {
1467         const char *desc;
1468         int (*func)(void);
1469 } tests[] = {
1470         {
1471                 .desc = "vmlinux symtab matches kallsyms",
1472                 .func = test__vmlinux_matches_kallsyms,
1473         },
1474         {
1475                 .desc = "detect open syscall event",
1476                 .func = test__open_syscall_event,
1477         },
1478         {
1479                 .desc = "detect open syscall event on all cpus",
1480                 .func = test__open_syscall_event_on_all_cpus,
1481         },
1482         {
1483                 .desc = "read samples using the mmap interface",
1484                 .func = test__basic_mmap,
1485         },
1486         {
1487                 .desc = "parse events tests",
1488                 .func = test__parse_events,
1489         },
1490 #if defined(__x86_64__) || defined(__i386__)
1491         {
1492                 .desc = "x86 rdpmc test",
1493                 .func = test__rdpmc,
1494         },
1495 #endif
1496         {
1497                 .desc = "Validate PERF_RECORD_* events & perf_sample fields",
1498                 .func = test__PERF_RECORD,
1499         },
1500         {
1501                 .func = NULL,
1502         },
1503 };
1504
1505 static bool perf_test__matches(int curr, int argc, const char *argv[])
1506 {
1507         int i;
1508
1509         if (argc == 0)
1510                 return true;
1511
1512         for (i = 0; i < argc; ++i) {
1513                 char *end;
1514                 long nr = strtoul(argv[i], &end, 10);
1515
1516                 if (*end == '\0') {
1517                         if (nr == curr + 1)
1518                                 return true;
1519                         continue;
1520                 }
1521
1522                 if (strstr(tests[curr].desc, argv[i]))
1523                         return true;
1524         }
1525
1526         return false;
1527 }
1528
1529 static int __cmd_test(int argc, const char *argv[])
1530 {
1531         int i = 0;
1532
1533         while (tests[i].func) {
1534                 int curr = i++, err;
1535
1536                 if (!perf_test__matches(curr, argc, argv))
1537                         continue;
1538
1539                 pr_info("%2d: %s:", i, tests[curr].desc);
1540                 pr_debug("\n--- start ---\n");
1541                 err = tests[curr].func();
1542                 pr_debug("---- end ----\n%s:", tests[curr].desc);
1543                 pr_info(" %s\n", err ? "FAILED!\n" : "Ok");
1544         }
1545
1546         return 0;
1547 }
1548
1549 static int perf_test__list(int argc, const char **argv)
1550 {
1551         int i = 0;
1552
1553         while (tests[i].func) {
1554                 int curr = i++;
1555
1556                 if (argc > 1 && !strstr(tests[curr].desc, argv[1]))
1557                         continue;
1558
1559                 pr_info("%2d: %s\n", i, tests[curr].desc);
1560         }
1561
1562         return 0;
1563 }
1564
1565 int cmd_test(int argc, const char **argv, const char *prefix __used)
1566 {
1567         const char * const test_usage[] = {
1568         "perf test [<options>] [{list <test-name-fragment>|[<test-name-fragments>|<test-numbers>]}]",
1569         NULL,
1570         };
1571         const struct option test_options[] = {
1572         OPT_INCR('v', "verbose", &verbose,
1573                     "be more verbose (show symbol address, etc)"),
1574         OPT_END()
1575         };
1576
1577         argc = parse_options(argc, argv, test_options, test_usage, 0);
1578         if (argc >= 1 && !strcmp(argv[0], "list"))
1579                 return perf_test__list(argc, argv);
1580
1581         symbol_conf.priv_size = sizeof(int);
1582         symbol_conf.sort_by_name = true;
1583         symbol_conf.try_vmlinux_path = true;
1584
1585         if (symbol__init() < 0)
1586                 return -1;
1587
1588         return __cmd_test(argc, argv);
1589 }