mmap-basic.c 4.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168
  1. // SPDX-License-Identifier: GPL-2.0
  2. #include <errno.h>
  3. #include <inttypes.h>
  4. /* For the CLR_() macros */
  5. #include <pthread.h>
  6. #include <stdlib.h>
  7. #include <perf/cpumap.h>
  8. #include "debug.h"
  9. #include "evlist.h"
  10. #include "evsel.h"
  11. #include "thread_map.h"
  12. #include "tests.h"
  13. #include "util/mmap.h"
  14. #include <linux/err.h>
  15. #include <linux/kernel.h>
  16. #include <linux/string.h>
  17. #include <perf/evlist.h>
  18. #include <perf/mmap.h>
  19. /*
  20. * This test will generate random numbers of calls to some getpid syscalls,
  21. * then establish an mmap for a group of events that are created to monitor
  22. * the syscalls.
  23. *
  24. * It will receive the events, using mmap, use its PERF_SAMPLE_ID generated
  25. * sample.id field to map back to its respective perf_evsel instance.
  26. *
  27. * Then it checks if the number of syscalls reported as perf events by
  28. * the kernel corresponds to the number of syscalls made.
  29. */
  30. int test__basic_mmap(struct test *test __maybe_unused, int subtest __maybe_unused)
  31. {
  32. int err = -1;
  33. union perf_event *event;
  34. struct perf_thread_map *threads;
  35. struct perf_cpu_map *cpus;
  36. struct evlist *evlist;
  37. cpu_set_t cpu_set;
  38. const char *syscall_names[] = { "getsid", "getppid", "getpgid", };
  39. pid_t (*syscalls[])(void) = { (void *)getsid, getppid, (void*)getpgid };
  40. #define nsyscalls ARRAY_SIZE(syscall_names)
  41. unsigned int nr_events[nsyscalls],
  42. expected_nr_events[nsyscalls], i, j;
  43. struct evsel *evsels[nsyscalls], *evsel;
  44. char sbuf[STRERR_BUFSIZE];
  45. struct mmap *md;
  46. threads = thread_map__new(-1, getpid(), UINT_MAX);
  47. if (threads == NULL) {
  48. pr_debug("thread_map__new\n");
  49. return -1;
  50. }
  51. cpus = perf_cpu_map__new(NULL);
  52. if (cpus == NULL) {
  53. pr_debug("perf_cpu_map__new\n");
  54. goto out_free_threads;
  55. }
  56. CPU_ZERO(&cpu_set);
  57. CPU_SET(cpus->map[0], &cpu_set);
  58. sched_setaffinity(0, sizeof(cpu_set), &cpu_set);
  59. if (sched_setaffinity(0, sizeof(cpu_set), &cpu_set) < 0) {
  60. pr_debug("sched_setaffinity() failed on CPU %d: %s ",
  61. cpus->map[0], str_error_r(errno, sbuf, sizeof(sbuf)));
  62. goto out_free_cpus;
  63. }
  64. evlist = evlist__new();
  65. if (evlist == NULL) {
  66. pr_debug("perf_evlist__new\n");
  67. goto out_free_cpus;
  68. }
  69. perf_evlist__set_maps(&evlist->core, cpus, threads);
  70. for (i = 0; i < nsyscalls; ++i) {
  71. char name[64];
  72. snprintf(name, sizeof(name), "sys_enter_%s", syscall_names[i]);
  73. evsels[i] = evsel__newtp("syscalls", name);
  74. if (IS_ERR(evsels[i])) {
  75. pr_debug("evsel__new(%s)\n", name);
  76. goto out_delete_evlist;
  77. }
  78. evsels[i]->core.attr.wakeup_events = 1;
  79. evsel__set_sample_id(evsels[i], false);
  80. evlist__add(evlist, evsels[i]);
  81. if (evsel__open(evsels[i], cpus, threads) < 0) {
  82. pr_debug("failed to open counter: %s, "
  83. "tweak /proc/sys/kernel/perf_event_paranoid?\n",
  84. str_error_r(errno, sbuf, sizeof(sbuf)));
  85. goto out_delete_evlist;
  86. }
  87. nr_events[i] = 0;
  88. expected_nr_events[i] = 1 + rand() % 127;
  89. }
  90. if (evlist__mmap(evlist, 128) < 0) {
  91. pr_debug("failed to mmap events: %d (%s)\n", errno,
  92. str_error_r(errno, sbuf, sizeof(sbuf)));
  93. goto out_delete_evlist;
  94. }
  95. for (i = 0; i < nsyscalls; ++i)
  96. for (j = 0; j < expected_nr_events[i]; ++j) {
  97. int foo = syscalls[i]();
  98. ++foo;
  99. }
  100. md = &evlist->mmap[0];
  101. if (perf_mmap__read_init(&md->core) < 0)
  102. goto out_init;
  103. while ((event = perf_mmap__read_event(&md->core)) != NULL) {
  104. struct perf_sample sample;
  105. if (event->header.type != PERF_RECORD_SAMPLE) {
  106. pr_debug("unexpected %s event\n",
  107. perf_event__name(event->header.type));
  108. goto out_delete_evlist;
  109. }
  110. err = perf_evlist__parse_sample(evlist, event, &sample);
  111. if (err) {
  112. pr_err("Can't parse sample, err = %d\n", err);
  113. goto out_delete_evlist;
  114. }
  115. err = -1;
  116. evsel = perf_evlist__id2evsel(evlist, sample.id);
  117. if (evsel == NULL) {
  118. pr_debug("event with id %" PRIu64
  119. " doesn't map to an evsel\n", sample.id);
  120. goto out_delete_evlist;
  121. }
  122. nr_events[evsel->idx]++;
  123. perf_mmap__consume(&md->core);
  124. }
  125. perf_mmap__read_done(&md->core);
  126. out_init:
  127. err = 0;
  128. evlist__for_each_entry(evlist, evsel) {
  129. if (nr_events[evsel->idx] != expected_nr_events[evsel->idx]) {
  130. pr_debug("expected %d %s events, got %d\n",
  131. expected_nr_events[evsel->idx],
  132. evsel__name(evsel), nr_events[evsel->idx]);
  133. err = -1;
  134. goto out_delete_evlist;
  135. }
  136. }
  137. out_delete_evlist:
  138. evlist__delete(evlist);
  139. cpus = NULL;
  140. threads = NULL;
  141. out_free_cpus:
  142. perf_cpu_map__put(cpus);
  143. out_free_threads:
  144. perf_thread_map__put(threads);
  145. return err;
  146. }