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

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

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

~ [ 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