Linux Perf
switch-tracking.c
Go to the documentation of this file.
1 // SPDX-License-Identifier: GPL-2.0
2 #include <sys/time.h>
3 #include <sys/prctl.h>
4 #include <errno.h>
5 #include <time.h>
6 #include <stdlib.h>
7 
8 #include "parse-events.h"
9 #include "evlist.h"
10 #include "evsel.h"
11 #include "thread_map.h"
12 #include "cpumap.h"
13 #include "tests.h"
14 
15 static int spin_sleep(void)
16 {
17  struct timeval start, now, diff, maxtime;
18  struct timespec ts;
19  int err, i;
20 
21  maxtime.tv_sec = 0;
22  maxtime.tv_usec = 50000;
23 
24  err = gettimeofday(&start, NULL);
25  if (err)
26  return err;
27 
28  /* Spin for 50ms */
29  while (1) {
30  for (i = 0; i < 1000; i++)
31  barrier();
32 
33  err = gettimeofday(&now, NULL);
34  if (err)
35  return err;
36 
37  timersub(&now, &start, &diff);
38  if (timercmp(&diff, &maxtime, > /* For checkpatch */))
39  break;
40  }
41 
42  ts.tv_nsec = 50 * 1000 * 1000;
43  ts.tv_sec = 0;
44 
45  /* Sleep for 50ms */
46  err = nanosleep(&ts, NULL);
47  if (err == EINTR)
48  err = 0;
49 
50  return err;
51 }
52 
56  pid_t *tids;
57  int nr_tids;
58  int comm_seen[4];
62 };
63 
65  union perf_event *event, const char *comm, int nr)
66 {
67  if (event->header.type == PERF_RECORD_COMM &&
68  (pid_t)event->comm.pid == getpid() &&
69  (pid_t)event->comm.tid == getpid() &&
70  strcmp(event->comm.comm, comm) == 0) {
71  if (switch_tracking->comm_seen[nr]) {
72  pr_debug("Duplicate comm event\n");
73  return -1;
74  }
75  switch_tracking->comm_seen[nr] = 1;
76  pr_debug3("comm event: %s nr: %d\n", event->comm.comm, nr);
77  return 1;
78  }
79  return 0;
80 }
81 
82 static int check_cpu(struct switch_tracking *switch_tracking, int cpu)
83 {
84  int i, nr = cpu + 1;
85 
86  if (cpu < 0)
87  return -1;
88 
89  if (!switch_tracking->tids) {
90  switch_tracking->tids = calloc(nr, sizeof(pid_t));
91  if (!switch_tracking->tids)
92  return -1;
93  for (i = 0; i < nr; i++)
94  switch_tracking->tids[i] = -1;
95  switch_tracking->nr_tids = nr;
96  return 0;
97  }
98 
99  if (cpu >= switch_tracking->nr_tids) {
100  void *addr;
101 
102  addr = realloc(switch_tracking->tids, nr * sizeof(pid_t));
103  if (!addr)
104  return -1;
105  switch_tracking->tids = addr;
106  for (i = switch_tracking->nr_tids; i < nr; i++)
107  switch_tracking->tids[i] = -1;
108  switch_tracking->nr_tids = nr;
109  return 0;
110  }
111 
112  return 0;
113 }
114 
116  union perf_event *event,
118 {
119  struct perf_sample sample;
120  struct perf_evsel *evsel;
121  pid_t next_tid, prev_tid;
122  int cpu, err;
123 
124  if (perf_evlist__parse_sample(evlist, event, &sample)) {
125  pr_debug("perf_evlist__parse_sample failed\n");
126  return -1;
127  }
128 
129  evsel = perf_evlist__id2evsel(evlist, sample.id);
130  if (evsel == switch_tracking->switch_evsel) {
131  next_tid = perf_evsel__intval(evsel, &sample, "next_pid");
132  prev_tid = perf_evsel__intval(evsel, &sample, "prev_pid");
133  cpu = sample.cpu;
134  pr_debug3("sched_switch: cpu: %d prev_tid %d next_tid %d\n",
135  cpu, prev_tid, next_tid);
136  err = check_cpu(switch_tracking, cpu);
137  if (err)
138  return err;
139  /*
140  * Check for no missing sched_switch events i.e. that the
141  * evsel->system_wide flag has worked.
142  */
143  if (switch_tracking->tids[cpu] != -1 &&
144  switch_tracking->tids[cpu] != prev_tid) {
145  pr_debug("Missing sched_switch events\n");
146  return -1;
147  }
148  switch_tracking->tids[cpu] = next_tid;
149  }
150 
151  if (evsel == switch_tracking->cycles_evsel) {
152  pr_debug3("cycles event\n");
153  if (!switch_tracking->comm_seen[0])
154  switch_tracking->cycles_before_comm_1 = 1;
155  if (switch_tracking->comm_seen[1] &&
156  !switch_tracking->comm_seen[2])
157  switch_tracking->cycles_between_comm_2_and_comm_3 = 1;
158  if (switch_tracking->comm_seen[3])
159  switch_tracking->cycles_after_comm_4 = 1;
160  }
161 
162  return 0;
163 }
164 
165 static int process_event(struct perf_evlist *evlist, union perf_event *event,
167 {
168  if (event->header.type == PERF_RECORD_SAMPLE)
169  return process_sample_event(evlist, event, switch_tracking);
170 
171  if (event->header.type == PERF_RECORD_COMM) {
172  int err, done = 0;
173 
174  err = check_comm(switch_tracking, event, "Test COMM 1", 0);
175  if (err < 0)
176  return -1;
177  done += err;
178  err = check_comm(switch_tracking, event, "Test COMM 2", 1);
179  if (err < 0)
180  return -1;
181  done += err;
182  err = check_comm(switch_tracking, event, "Test COMM 3", 2);
183  if (err < 0)
184  return -1;
185  done += err;
186  err = check_comm(switch_tracking, event, "Test COMM 4", 3);
187  if (err < 0)
188  return -1;
189  done += err;
190  if (done != 1) {
191  pr_debug("Unexpected comm event\n");
192  return -1;
193  }
194  }
195 
196  return 0;
197 }
198 
199 struct event_node {
200  struct list_head list;
203 };
204 
205 static int add_event(struct perf_evlist *evlist, struct list_head *events,
206  union perf_event *event)
207 {
208  struct perf_sample sample;
209  struct event_node *node;
210 
211  node = malloc(sizeof(struct event_node));
212  if (!node) {
213  pr_debug("malloc failed\n");
214  return -1;
215  }
216  node->event = event;
217  list_add(&node->list, events);
218 
219  if (perf_evlist__parse_sample(evlist, event, &sample)) {
220  pr_debug("perf_evlist__parse_sample failed\n");
221  return -1;
222  }
223 
224  if (!sample.time) {
225  pr_debug("event with no time\n");
226  return -1;
227  }
228 
229  node->event_time = sample.time;
230 
231  return 0;
232 }
233 
234 static void free_event_nodes(struct list_head *events)
235 {
236  struct event_node *node;
237 
238  while (!list_empty(events)) {
239  node = list_entry(events->next, struct event_node, list);
240  list_del(&node->list);
241  free(node);
242  }
243 }
244 
245 static int compar(const void *a, const void *b)
246 {
247  const struct event_node *nodea = a;
248  const struct event_node *nodeb = b;
249  s64 cmp = nodea->event_time - nodeb->event_time;
250 
251  return cmp;
252 }
253 
254 static int process_events(struct perf_evlist *evlist,
256 {
257  union perf_event *event;
258  unsigned pos, cnt = 0;
259  LIST_HEAD(events);
260  struct event_node *events_array, *node;
261  struct perf_mmap *md;
262  int i, ret;
263 
264  for (i = 0; i < evlist->nr_mmaps; i++) {
265  md = &evlist->mmap[i];
266  if (perf_mmap__read_init(md) < 0)
267  continue;
268 
269  while ((event = perf_mmap__read_event(md)) != NULL) {
270  cnt += 1;
271  ret = add_event(evlist, &events, event);
272  perf_mmap__consume(md);
273  if (ret < 0)
274  goto out_free_nodes;
275  }
277  }
278 
279  events_array = calloc(cnt, sizeof(struct event_node));
280  if (!events_array) {
281  pr_debug("calloc failed\n");
282  ret = -1;
283  goto out_free_nodes;
284  }
285 
286  pos = 0;
287  list_for_each_entry(node, &events, list)
288  events_array[pos++] = *node;
289 
290  qsort(events_array, cnt, sizeof(struct event_node), compar);
291 
292  for (pos = 0; pos < cnt; pos++) {
293  ret = process_event(evlist, events_array[pos].event,
294  switch_tracking);
295  if (ret < 0)
296  goto out_free;
297  }
298 
299  ret = 0;
300 out_free:
301  pr_debug("%u events recorded\n", cnt);
302  free(events_array);
303 out_free_nodes:
305  return ret;
306 }
307 
316 int test__switch_tracking(struct test *test __maybe_unused, int subtest __maybe_unused)
317 {
318  const char *sched_switch = "sched:sched_switch";
319  struct switch_tracking switch_tracking = { .tids = NULL, };
320  struct record_opts opts = {
321  .mmap_pages = UINT_MAX,
322  .user_freq = UINT_MAX,
323  .user_interval = ULLONG_MAX,
324  .freq = 4000,
325  .target = {
326  .uses_mmap = true,
327  },
328  };
329  struct thread_map *threads = NULL;
330  struct cpu_map *cpus = NULL;
331  struct perf_evlist *evlist = NULL;
332  struct perf_evsel *evsel, *cpu_clocks_evsel, *cycles_evsel;
333  struct perf_evsel *switch_evsel, *tracking_evsel;
334  const char *comm;
335  int err = -1;
336 
337  threads = thread_map__new(-1, getpid(), UINT_MAX);
338  if (!threads) {
339  pr_debug("thread_map__new failed!\n");
340  goto out_err;
341  }
342 
343  cpus = cpu_map__new(NULL);
344  if (!cpus) {
345  pr_debug("cpu_map__new failed!\n");
346  goto out_err;
347  }
348 
349  evlist = perf_evlist__new();
350  if (!evlist) {
351  pr_debug("perf_evlist__new failed!\n");
352  goto out_err;
353  }
354 
355  perf_evlist__set_maps(evlist, cpus, threads);
356 
357  /* First event */
358  err = parse_events(evlist, "cpu-clock:u", NULL);
359  if (err) {
360  pr_debug("Failed to parse event dummy:u\n");
361  goto out_err;
362  }
363 
364  cpu_clocks_evsel = perf_evlist__last(evlist);
365 
366  /* Second event */
367  err = parse_events(evlist, "cycles:u", NULL);
368  if (err) {
369  pr_debug("Failed to parse event cycles:u\n");
370  goto out_err;
371  }
372 
373  cycles_evsel = perf_evlist__last(evlist);
374 
375  /* Third event */
376  if (!perf_evlist__can_select_event(evlist, sched_switch)) {
377  pr_debug("No sched_switch\n");
378  err = 0;
379  goto out;
380  }
381 
382  err = parse_events(evlist, sched_switch, NULL);
383  if (err) {
384  pr_debug("Failed to parse event %s\n", sched_switch);
385  goto out_err;
386  }
387 
388  switch_evsel = perf_evlist__last(evlist);
389 
390  perf_evsel__set_sample_bit(switch_evsel, CPU);
391  perf_evsel__set_sample_bit(switch_evsel, TIME);
392 
393  switch_evsel->system_wide = true;
394  switch_evsel->no_aux_samples = true;
395  switch_evsel->immediate = true;
396 
397  /* Test moving an event to the front */
398  if (cycles_evsel == perf_evlist__first(evlist)) {
399  pr_debug("cycles event already at front");
400  goto out_err;
401  }
402  perf_evlist__to_front(evlist, cycles_evsel);
403  if (cycles_evsel != perf_evlist__first(evlist)) {
404  pr_debug("Failed to move cycles event to front");
405  goto out_err;
406  }
407 
408  perf_evsel__set_sample_bit(cycles_evsel, CPU);
409  perf_evsel__set_sample_bit(cycles_evsel, TIME);
410 
411  /* Fourth event */
412  err = parse_events(evlist, "dummy:u", NULL);
413  if (err) {
414  pr_debug("Failed to parse event dummy:u\n");
415  goto out_err;
416  }
417 
418  tracking_evsel = perf_evlist__last(evlist);
419 
420  perf_evlist__set_tracking_event(evlist, tracking_evsel);
421 
422  tracking_evsel->attr.freq = 0;
423  tracking_evsel->attr.sample_period = 1;
424 
425  perf_evsel__set_sample_bit(tracking_evsel, TIME);
426 
427  /* Config events */
428  perf_evlist__config(evlist, &opts, NULL);
429 
430  /* Check moved event is still at the front */
431  if (cycles_evsel != perf_evlist__first(evlist)) {
432  pr_debug("Front event no longer at front");
433  goto out_err;
434  }
435 
436  /* Check tracking event is tracking */
437  if (!tracking_evsel->attr.mmap || !tracking_evsel->attr.comm) {
438  pr_debug("Tracking event not tracking\n");
439  goto out_err;
440  }
441 
442  /* Check non-tracking events are not tracking */
443  evlist__for_each_entry(evlist, evsel) {
444  if (evsel != tracking_evsel) {
445  if (evsel->attr.mmap || evsel->attr.comm) {
446  pr_debug("Non-tracking event is tracking\n");
447  goto out_err;
448  }
449  }
450  }
451 
452  if (perf_evlist__open(evlist) < 0) {
453  pr_debug("Not supported\n");
454  err = 0;
455  goto out;
456  }
457 
458  err = perf_evlist__mmap(evlist, UINT_MAX);
459  if (err) {
460  pr_debug("perf_evlist__mmap failed!\n");
461  goto out_err;
462  }
463 
464  perf_evlist__enable(evlist);
465 
466  err = perf_evsel__disable(cpu_clocks_evsel);
467  if (err) {
468  pr_debug("perf_evlist__disable_event failed!\n");
469  goto out_err;
470  }
471 
472  err = spin_sleep();
473  if (err) {
474  pr_debug("spin_sleep failed!\n");
475  goto out_err;
476  }
477 
478  comm = "Test COMM 1";
479  err = prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0);
480  if (err) {
481  pr_debug("PR_SET_NAME failed!\n");
482  goto out_err;
483  }
484 
485  err = perf_evsel__disable(cycles_evsel);
486  if (err) {
487  pr_debug("perf_evlist__disable_event failed!\n");
488  goto out_err;
489  }
490 
491  comm = "Test COMM 2";
492  err = prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0);
493  if (err) {
494  pr_debug("PR_SET_NAME failed!\n");
495  goto out_err;
496  }
497 
498  err = spin_sleep();
499  if (err) {
500  pr_debug("spin_sleep failed!\n");
501  goto out_err;
502  }
503 
504  comm = "Test COMM 3";
505  err = prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0);
506  if (err) {
507  pr_debug("PR_SET_NAME failed!\n");
508  goto out_err;
509  }
510 
511  err = perf_evsel__enable(cycles_evsel);
512  if (err) {
513  pr_debug("perf_evlist__disable_event failed!\n");
514  goto out_err;
515  }
516 
517  comm = "Test COMM 4";
518  err = prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0);
519  if (err) {
520  pr_debug("PR_SET_NAME failed!\n");
521  goto out_err;
522  }
523 
524  err = spin_sleep();
525  if (err) {
526  pr_debug("spin_sleep failed!\n");
527  goto out_err;
528  }
529 
530  perf_evlist__disable(evlist);
531 
532  switch_tracking.switch_evsel = switch_evsel;
533  switch_tracking.cycles_evsel = cycles_evsel;
534 
535  err = process_events(evlist, &switch_tracking);
536 
537  zfree(&switch_tracking.tids);
538 
539  if (err)
540  goto out_err;
541 
542  /* Check all 4 comm events were seen i.e. that evsel->tracking works */
543  if (!switch_tracking.comm_seen[0] || !switch_tracking.comm_seen[1] ||
544  !switch_tracking.comm_seen[2] || !switch_tracking.comm_seen[3]) {
545  pr_debug("Missing comm events\n");
546  goto out_err;
547  }
548 
549  /* Check cycles event got enabled */
550  if (!switch_tracking.cycles_before_comm_1) {
551  pr_debug("Missing cycles events\n");
552  goto out_err;
553  }
554 
555  /* Check cycles event got disabled */
556  if (switch_tracking.cycles_between_comm_2_and_comm_3) {
557  pr_debug("cycles events even though event was disabled\n");
558  goto out_err;
559  }
560 
561  /* Check cycles event got enabled again */
562  if (!switch_tracking.cycles_after_comm_4) {
563  pr_debug("Missing cycles events\n");
564  goto out_err;
565  }
566 out:
567  if (evlist) {
568  perf_evlist__disable(evlist);
569  perf_evlist__delete(evlist);
570  } else {
571  cpu_map__put(cpus);
572  thread_map__put(threads);
573  }
574 
575  return err;
576 
577 out_err:
578  err = -1;
579  goto out;
580 }
void perf_evlist__set_maps(struct perf_evlist *evlist, struct cpu_map *cpus, struct thread_map *threads)
Definition: evlist.c:1115
const char * comm
Definition: hists_common.c:16
void perf_mmap__consume(struct perf_mmap *map)
Definition: mmap.c:118
Definition: mem2node.c:7
struct perf_probe_event events[MAX_PROBES]
Definition: builtin-probe.c:57
static void sched_switch(struct timechart *tchart, int cpu, u64 timestamp, int prev_pid, int next_pid, u64 prev_state, const char *backtrace)
static LIST_HEAD(page_alloc_sort_input)
struct perf_mmap * mmap
Definition: evlist.h:45
u32 tid
Definition: event.h:39
void perf_evlist__enable(struct perf_evlist *evlist)
Definition: evlist.c:369
int int err
Definition: 5sec.c:44
bool system_wide
Definition: evsel.h:124
void perf_evlist__delete(struct perf_evlist *evlist)
Definition: evlist.c:133
#define perf_evsel__set_sample_bit(evsel, bit)
Definition: evsel.h:260
Definition: cpumap.h:12
static int spin_sleep(void)
Definition: mmap.h:17
int perf_evsel__disable(struct perf_evsel *evsel)
Definition: evsel.c:1182
#define PR_SET_NAME
Definition: builtin-sched.c:41
union perf_event * event
Definition: comm.h:11
int parse_events(struct perf_evlist *evlist, const char *str, struct parse_events_error *err)
u64 id
Definition: event.h:196
struct perf_evsel * cycles_evsel
bool perf_evlist__can_select_event(struct perf_evlist *evlist, const char *str)
Definition: record.c:259
void * malloc(YYSIZE_T)
void cpu_map__put(struct cpu_map *map)
Definition: cpumap.c:298
void perf_evlist__set_tracking_event(struct perf_evlist *evlist, struct perf_evsel *tracking_evsel)
Definition: evlist.c:1697
int perf_mmap__read_init(struct perf_mmap *map)
Definition: mmap.c:271
static int compar(const void *a, const void *b)
struct perf_evlist * evlist
Definition: evsel.h:92
#define pr_debug(fmt,...)
Definition: json.h:27
int perf_evlist__open(struct perf_evlist *evlist)
Definition: evlist.c:1398
#define evlist__for_each_entry(evlist, evsel)
Definition: evlist.h:247
int perf_evlist__parse_sample(struct perf_evlist *evlist, union perf_event *event, struct perf_sample *sample)
Definition: evlist.c:1561
bool immediate
Definition: evsel.h:123
list cpus
Definition: stat-cpi.py:7
static int check_cpu(struct switch_tracking *switch_tracking, int cpu)
unsigned int mmap_pages
Definition: perf.h:67
struct perf_evsel * perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
Definition: evlist.c:589
static int process_events(struct perf_evlist *evlist, struct switch_tracking *switch_tracking)
#define CPU(he)
#define event
void perf_evlist__to_front(struct perf_evlist *evlist, struct perf_evsel *move_evsel)
Definition: evlist.c:1680
u64 perf_evsel__intval(struct perf_evsel *evsel, struct perf_sample *sample, const char *name)
Definition: evsel.c:2722
void perf_evlist__config(struct perf_evlist *evlist, struct record_opts *opts, struct callchain_param *callchain)
Definition: record.c:135
u32 cpu
Definition: event.h:201
int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages)
Definition: evlist.c:1061
int nr_mmaps
Definition: evlist.h:32
#define zfree(ptr)
Definition: util.h:25
static int process_event(struct perf_evlist *evlist, union perf_event *event, struct switch_tracking *switch_tracking)
struct list_head list
void perf_mmap__read_done(struct perf_mmap *map)
Definition: mmap.c:329
struct perf_event_header header
Definition: event.h:624
static struct perf_evsel * perf_evlist__first(struct perf_evlist *evlist)
Definition: evlist.h:215
union perf_event * perf_mmap__read_event(struct perf_mmap *map)
Definition: mmap.c:78
void perf_evlist__disable(struct perf_evlist *evlist)
Definition: evlist.c:356
int cycles_between_comm_2_and_comm_3
Definition: tests.h:30
int perf_evsel__enable(struct perf_evsel *evsel)
Definition: evsel.c:1175
u64 time
Definition: event.h:194
static int check_comm(struct switch_tracking *switch_tracking, union perf_event *event, const char *comm, int nr)
struct comm_event comm
Definition: event.h:627
void free(void *)
char comm[16]
Definition: event.h:40
static int process_sample_event(struct perf_evlist *evlist, union perf_event *event, struct switch_tracking *switch_tracking)
void thread_map__put(struct thread_map *map)
Definition: thread_map.c:361
struct perf_evsel * switch_evsel
static void free_event_nodes(struct list_head *events)
static struct perf_evsel * perf_evlist__last(struct perf_evlist *evlist)
Definition: evlist.h:220
struct thread_map * thread_map__new(pid_t pid, pid_t tid, uid_t uid)
Definition: thread_map.c:192
bool no_aux_samples
Definition: evsel.h:122
struct cpu_map * cpu_map__new(const char *cpu_list)
Definition: cpumap.c:125
#define pr_debug3(fmt,...)
Definition: debug.h:34
u32 pid
Definition: event.h:39
static bool done
Definition: futex-hash.c:35
int test__switch_tracking(struct test *test __maybe_unused, int subtest __maybe_unused)
struct perf_evlist * perf_evlist__new(void)
Definition: evlist.c:54
struct perf_event_attr attr
Definition: evsel.h:93
static int add_event(struct perf_evlist *evlist, struct list_head *events, union perf_event *event)