~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/tests/switch-tracking.c

Version: ~ [ linux-5.6-rc1 ] ~ [ linux-5.5.2 ] ~ [ linux-5.4.17 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.102 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.170 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.213 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.213 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 53 struct switch_tracking {
 54         struct perf_evsel *switch_evsel;
 55         struct perf_evsel *cycles_evsel;
 56         pid_t *tids;
 57         int nr_tids;
 58         int comm_seen[4];
 59         int cycles_before_comm_1;
 60         int cycles_between_comm_2_and_comm_3;
 61         int cycles_after_comm_4;
 62 };
 63 
 64 static int check_comm(struct switch_tracking *switch_tracking,
 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 
115 static int process_sample_event(struct perf_evlist *evlist,
116                                 union perf_event *event,
117                                 struct switch_tracking *switch_tracking)
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,
166                          struct switch_tracking *switch_tracking)
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;
201         union perf_event *event;
202         u64 event_time;
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,
255                           struct switch_tracking *switch_tracking)
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                 }
276                 perf_mmap__read_done(md);
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:
304         free_event_nodes(&events);
305         return ret;
306 }
307 
308 /**
309  * test__switch_tracking - test using sched_switch and tracking events.
310  *
311  * This function implements a test that checks that sched_switch events and
312  * tracking events can be recorded for a workload (current process) using the
313  * evsel->system_wide and evsel->tracking flags (respectively) with other events
314  * sometimes enabled or disabled.
315  */
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 }
581 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp