perf/tests/switch-tracking.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 #include <sys/time.h>
0003 #include <sys/prctl.h>
0004 #include <errno.h>
0005 #include <limits.h>
0006 #include <time.h>
0007 #include <stdlib.h>
0008 #include <linux/zalloc.h>
0009 #include <perf/cpumap.h>
0010 #include <perf/evlist.h>
0011 #include <perf/mmap.h>
0012
0013 #include "debug.h"
0014 #include "parse-events.h"
0015 #include "evlist.h"
0016 #include "evsel.h"
0017 #include "thread_map.h"
0018 #include "record.h"
0019 #include "tests.h"
0020 #include "util/mmap.h"
0021 #include "pmu.h"
0022
0023 static int spin_sleep(void)
0024 {
0025     struct timeval start, now, diff, maxtime;
0026     struct timespec ts;
0027     int err, i;
0028
0029     maxtime.tv_sec = 0;
0030     maxtime.tv_usec = 50000;
0031
0032     err = gettimeofday(&start, NULL);
0033     if (err)
0034         return err;
0035
0036     /* Spin for 50ms */
0037     while (1) {
0038         for (i = 0; i < 1000; i++)
0039             barrier();
0040
0041         err = gettimeofday(&now, NULL);
0042         if (err)
0043             return err;
0044
0045         timersub(&now, &start, &diff);
0046         if (timercmp(&diff, &maxtime, > /* For checkpatch */))
0047             break;
0048     }
0049
0050     ts.tv_nsec = 50 * 1000 * 1000;
0051     ts.tv_sec = 0;
0052
0053     /* Sleep for 50ms */
0054     err = nanosleep(&ts, NULL);
0055     if (err == EINTR)
0056         err = 0;
0057
0058     return err;
0059 }
0060
0061 struct switch_tracking {
0062     struct evsel *switch_evsel;
0063     struct evsel *cycles_evsel;
0064     pid_t *tids;
0065     int nr_tids;
0066     int comm_seen[4];
0067     int cycles_before_comm_1;
0068     int cycles_between_comm_2_and_comm_3;
0069     int cycles_after_comm_4;
0070 };
0071
0072 static int check_comm(struct switch_tracking *switch_tracking,
0073               union perf_event *event, const char *comm, int nr)
0074 {
0075     if (event->header.type == PERF_RECORD_COMM &&
0076         (pid_t)event->comm.pid == getpid() &&
0077         (pid_t)event->comm.tid == getpid() &&
0078         strcmp(event->comm.comm, comm) == 0) {
0079         if (switch_tracking->comm_seen[nr]) {
0080             pr_debug("Duplicate comm event\n");
0081             return -1;
0082         }
0083         switch_tracking->comm_seen[nr] = 1;
0084         pr_debug3("comm event: %s nr: %d\n", event->comm.comm, nr);
0085         return 1;
0086     }
0087     return 0;
0088 }
0089
0090 static int check_cpu(struct switch_tracking *switch_tracking, int cpu)
0091 {
0092     int i, nr = cpu + 1;
0093
0094     if (cpu < 0)
0095         return -1;
0096
0097     if (!switch_tracking->tids) {
0098         switch_tracking->tids = calloc(nr, sizeof(pid_t));
0099         if (!switch_tracking->tids)
0100             return -1;
0101         for (i = 0; i < nr; i++)
0102             switch_tracking->tids[i] = -1;
0103         switch_tracking->nr_tids = nr;
0104         return 0;
0105     }
0106
0107     if (cpu >= switch_tracking->nr_tids) {
0108         void *addr;
0109
0110         addr = realloc(switch_tracking->tids, nr * sizeof(pid_t));
0111         if (!addr)
0112             return -1;
0113         switch_tracking->tids = addr;
0114         for (i = switch_tracking->nr_tids; i < nr; i++)
0115             switch_tracking->tids[i] = -1;
0116         switch_tracking->nr_tids = nr;
0117         return 0;
0118     }
0119
0120     return 0;
0121 }
0122
0123 static int process_sample_event(struct evlist *evlist,
0124                 union perf_event *event,
0125                 struct switch_tracking *switch_tracking)
0126 {
0127     struct perf_sample sample;
0128     struct evsel *evsel;
0129     pid_t next_tid, prev_tid;
0130     int cpu, err;
0131
0132     if (evlist__parse_sample(evlist, event, &sample)) {
0133         pr_debug("evlist__parse_sample failed\n");
0134         return -1;
0135     }
0136
0137     evsel = evlist__id2evsel(evlist, sample.id);
0138     if (evsel == switch_tracking->switch_evsel) {
0139         next_tid = evsel__intval(evsel, &sample, "next_pid");
0140         prev_tid = evsel__intval(evsel, &sample, "prev_pid");
0141         cpu = sample.cpu;
0142         pr_debug3("sched_switch: cpu: %d prev_tid %d next_tid %d\n",
0143               cpu, prev_tid, next_tid);
0144         err = check_cpu(switch_tracking, cpu);
0145         if (err)
0146             return err;
0147         /*
0148          * Check for no missing sched_switch events i.e. that the
0149          * evsel->core.system_wide flag has worked.
0150          */
0151         if (switch_tracking->tids[cpu] != -1 &&
0152             switch_tracking->tids[cpu] != prev_tid) {
0153             pr_debug("Missing sched_switch events\n");
0154             return -1;
0155         }
0156         switch_tracking->tids[cpu] = next_tid;
0157     }
0158
0159     if (evsel == switch_tracking->cycles_evsel) {
0160         pr_debug3("cycles event\n");
0161         if (!switch_tracking->comm_seen[0])
0162             switch_tracking->cycles_before_comm_1 = 1;
0163         if (switch_tracking->comm_seen[1] &&
0164             !switch_tracking->comm_seen[2])
0165             switch_tracking->cycles_between_comm_2_and_comm_3 = 1;
0166         if (switch_tracking->comm_seen[3])
0167             switch_tracking->cycles_after_comm_4 = 1;
0168     }
0169
0170     return 0;
0171 }
0172
0173 static int process_event(struct evlist *evlist, union perf_event *event,
0174              struct switch_tracking *switch_tracking)
0175 {
0176     if (event->header.type == PERF_RECORD_SAMPLE)
0177         return process_sample_event(evlist, event, switch_tracking);
0178
0179     if (event->header.type == PERF_RECORD_COMM) {
0180         int err, done = 0;
0181
0182         err = check_comm(switch_tracking, event, "Test COMM 1", 0);
0183         if (err < 0)
0184             return -1;
0185         done += err;
0186         err = check_comm(switch_tracking, event, "Test COMM 2", 1);
0187         if (err < 0)
0188             return -1;
0189         done += err;
0190         err = check_comm(switch_tracking, event, "Test COMM 3", 2);
0191         if (err < 0)
0192             return -1;
0193         done += err;
0194         err = check_comm(switch_tracking, event, "Test COMM 4", 3);
0195         if (err < 0)
0196             return -1;
0197         done += err;
0198         if (done != 1) {
0199             pr_debug("Unexpected comm event\n");
0200             return -1;
0201         }
0202     }
0203
0204     return 0;
0205 }
0206
0207 struct event_node {
0208     struct list_head list;
0209     union perf_event *event;
0210     u64 event_time;
0211 };
0212
0213 static int add_event(struct evlist *evlist, struct list_head *events,
0214              union perf_event *event)
0215 {
0216     struct perf_sample sample;
0217     struct event_node *node;
0218
0219     node = malloc(sizeof(struct event_node));
0220     if (!node) {
0221         pr_debug("malloc failed\n");
0222         return -1;
0223     }
0224     node->event = event;
0225     list_add(&node->list, events);
0226
0227     if (evlist__parse_sample(evlist, event, &sample)) {
0228         pr_debug("evlist__parse_sample failed\n");
0229         return -1;
0230     }
0231
0232     if (!sample.time) {
0233         pr_debug("event with no time\n");
0234         return -1;
0235     }
0236
0237     node->event_time = sample.time;
0238
0239     return 0;
0240 }
0241
0242 static void free_event_nodes(struct list_head *events)
0243 {
0244     struct event_node *node;
0245
0246     while (!list_empty(events)) {
0247         node = list_entry(events->next, struct event_node, list);
0248         list_del_init(&node->list);
0249         free(node);
0250     }
0251 }
0252
0253 static int compar(const void *a, const void *b)
0254 {
0255     const struct event_node *nodea = a;
0256     const struct event_node *nodeb = b;
0257     s64 cmp = nodea->event_time - nodeb->event_time;
0258
0259     return cmp;
0260 }
0261
0262 static int process_events(struct evlist *evlist,
0263               struct switch_tracking *switch_tracking)
0264 {
0265     union perf_event *event;
0266     unsigned pos, cnt = 0;
0267     LIST_HEAD(events);
0268     struct event_node *events_array, *node;
0269     struct mmap *md;
0270     int i, ret;
0271
0272     for (i = 0; i < evlist->core.nr_mmaps; i++) {
0273         md = &evlist->mmap[i];
0274         if (perf_mmap__read_init(&md->core) < 0)
0275             continue;
0276
0277         while ((event = perf_mmap__read_event(&md->core)) != NULL) {
0278             cnt += 1;
0279             ret = add_event(evlist, &events, event);
0280              perf_mmap__consume(&md->core);
0281             if (ret < 0)
0282                 goto out_free_nodes;
0283         }
0284         perf_mmap__read_done(&md->core);
0285     }
0286
0287     events_array = calloc(cnt, sizeof(struct event_node));
0288     if (!events_array) {
0289         pr_debug("calloc failed\n");
0290         ret = -1;
0291         goto out_free_nodes;
0292     }
0293
0294     pos = 0;
0295     list_for_each_entry(node, &events, list)
0296         events_array[pos++] = *node;
0297
0298     qsort(events_array, cnt, sizeof(struct event_node), compar);
0299
0300     for (pos = 0; pos < cnt; pos++) {
0301         ret = process_event(evlist, events_array[pos].event,
0302                     switch_tracking);
0303         if (ret < 0)
0304             goto out_free;
0305     }
0306
0307     ret = 0;
0308 out_free:
0309     pr_debug("%u events recorded\n", cnt);
0310     free(events_array);
0311 out_free_nodes:
0312     free_event_nodes(&events);
0313     return ret;
0314 }
0315
0316 /**
0317  * test__switch_tracking - test using sched_switch and tracking events.
0318  *
0319  * This function implements a test that checks that sched_switch events and
0320  * tracking events can be recorded for a workload (current process) using the
0321  * evsel->core.system_wide and evsel->tracking flags (respectively) with other events
0322  * sometimes enabled or disabled.
0323  */
0324 static int test__switch_tracking(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
0325 {
0326     const char *sched_switch = "sched:sched_switch";
0327     const char *cycles = "cycles:u";
0328     struct switch_tracking switch_tracking = { .tids = NULL, };
0329     struct record_opts opts = {
0330         .mmap_pages      = UINT_MAX,
0331         .user_freq       = UINT_MAX,
0332         .user_interval       = ULLONG_MAX,
0333         .freq            = 4000,
0334         .target          = {
0335             .uses_mmap   = true,
0336         },
0337     };
0338     struct perf_thread_map *threads = NULL;
0339     struct perf_cpu_map *cpus = NULL;
0340     struct evlist *evlist = NULL;
0341     struct evsel *evsel, *cpu_clocks_evsel, *cycles_evsel;
0342     struct evsel *switch_evsel, *tracking_evsel;
0343     const char *comm;
0344     int err = -1;
0345
0346     threads = thread_map__new(-1, getpid(), UINT_MAX);
0347     if (!threads) {
0348         pr_debug("thread_map__new failed!\n");
0349         goto out_err;
0350     }
0351
0352     cpus = perf_cpu_map__new(NULL);
0353     if (!cpus) {
0354         pr_debug("perf_cpu_map__new failed!\n");
0355         goto out_err;
0356     }
0357
0358     evlist = evlist__new();
0359     if (!evlist) {
0360         pr_debug("evlist__new failed!\n");
0361         goto out_err;
0362     }
0363
0364     perf_evlist__set_maps(&evlist->core, cpus, threads);
0365
0366     /* First event */
0367     err = parse_event(evlist, "cpu-clock:u");
0368     if (err) {
0369         pr_debug("Failed to parse event dummy:u\n");
0370         goto out_err;
0371     }
0372
0373     cpu_clocks_evsel = evlist__last(evlist);
0374
0375     /* Second event */
0376     if (perf_pmu__has_hybrid()) {
0377         cycles = "cpu_core/cycles/u";
0378         err = parse_event(evlist, cycles);
0379         if (err) {
0380             cycles = "cpu_atom/cycles/u";
0381             pr_debug("Trying %s\n", cycles);
0382             err = parse_event(evlist, cycles);
0383         }
0384     } else {
0385         err = parse_event(evlist, cycles);
0386     }
0387     if (err) {
0388         pr_debug("Failed to parse event %s\n", cycles);
0389         goto out_err;
0390     }
0391
0392     cycles_evsel = evlist__last(evlist);
0393
0394     /* Third event */
0395     if (!evlist__can_select_event(evlist, sched_switch)) {
0396         pr_debug("No sched_switch\n");
0397         err = 0;
0398         goto out;
0399     }
0400
0401     err = parse_event(evlist, sched_switch);
0402     if (err) {
0403         pr_debug("Failed to parse event %s\n", sched_switch);
0404         goto out_err;
0405     }
0406
0407     switch_evsel = evlist__last(evlist);
0408
0409     evsel__set_sample_bit(switch_evsel, CPU);
0410     evsel__set_sample_bit(switch_evsel, TIME);
0411
0412     switch_evsel->core.system_wide = true;
0413     switch_evsel->no_aux_samples = true;
0414     switch_evsel->immediate = true;
0415
0416     /* Test moving an event to the front */
0417     if (cycles_evsel == evlist__first(evlist)) {
0418         pr_debug("cycles event already at front");
0419         goto out_err;
0420     }
0421     evlist__to_front(evlist, cycles_evsel);
0422     if (cycles_evsel != evlist__first(evlist)) {
0423         pr_debug("Failed to move cycles event to front");
0424         goto out_err;
0425     }
0426
0427     evsel__set_sample_bit(cycles_evsel, CPU);
0428     evsel__set_sample_bit(cycles_evsel, TIME);
0429
0430     /* Fourth event */
0431     err = parse_event(evlist, "dummy:u");
0432     if (err) {
0433         pr_debug("Failed to parse event dummy:u\n");
0434         goto out_err;
0435     }
0436
0437     tracking_evsel = evlist__last(evlist);
0438
0439     evlist__set_tracking_event(evlist, tracking_evsel);
0440
0441     tracking_evsel->core.attr.freq = 0;
0442     tracking_evsel->core.attr.sample_period = 1;
0443
0444     evsel__set_sample_bit(tracking_evsel, TIME);
0445
0446     /* Config events */
0447     evlist__config(evlist, &opts, NULL);
0448
0449     /* Check moved event is still at the front */
0450     if (cycles_evsel != evlist__first(evlist)) {
0451         pr_debug("Front event no longer at front");
0452         goto out_err;
0453     }
0454
0455     /* Check tracking event is tracking */
0456     if (!tracking_evsel->core.attr.mmap || !tracking_evsel->core.attr.comm) {
0457         pr_debug("Tracking event not tracking\n");
0458         goto out_err;
0459     }
0460
0461     /* Check non-tracking events are not tracking */
0462     evlist__for_each_entry(evlist, evsel) {
0463         if (evsel != tracking_evsel) {
0464             if (evsel->core.attr.mmap || evsel->core.attr.comm) {
0465                 pr_debug("Non-tracking event is tracking\n");
0466                 goto out_err;
0467             }
0468         }
0469     }
0470
0471     if (evlist__open(evlist) < 0) {
0472         pr_debug("Not supported\n");
0473         err = 0;
0474         goto out;
0475     }
0476
0477     err = evlist__mmap(evlist, UINT_MAX);
0478     if (err) {
0479         pr_debug("evlist__mmap failed!\n");
0480         goto out_err;
0481     }
0482
0483     evlist__enable(evlist);
0484
0485     err = evsel__disable(cpu_clocks_evsel);
0486     if (err) {
0487         pr_debug("perf_evlist__disable_event failed!\n");
0488         goto out_err;
0489     }
0490
0491     err = spin_sleep();
0492     if (err) {
0493         pr_debug("spin_sleep failed!\n");
0494         goto out_err;
0495     }
0496
0497     comm = "Test COMM 1";
0498     err = prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0);
0499     if (err) {
0500         pr_debug("PR_SET_NAME failed!\n");
0501         goto out_err;
0502     }
0503
0504     err = evsel__disable(cycles_evsel);
0505     if (err) {
0506         pr_debug("perf_evlist__disable_event failed!\n");
0507         goto out_err;
0508     }
0509
0510     comm = "Test COMM 2";
0511     err = prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0);
0512     if (err) {
0513         pr_debug("PR_SET_NAME failed!\n");
0514         goto out_err;
0515     }
0516
0517     err = spin_sleep();
0518     if (err) {
0519         pr_debug("spin_sleep failed!\n");
0520         goto out_err;
0521     }
0522
0523     comm = "Test COMM 3";
0524     err = prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0);
0525     if (err) {
0526         pr_debug("PR_SET_NAME failed!\n");
0527         goto out_err;
0528     }
0529
0530     err = evsel__enable(cycles_evsel);
0531     if (err) {
0532         pr_debug("perf_evlist__disable_event failed!\n");
0533         goto out_err;
0534     }
0535
0536     comm = "Test COMM 4";
0537     err = prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0);
0538     if (err) {
0539         pr_debug("PR_SET_NAME failed!\n");
0540         goto out_err;
0541     }
0542
0543     err = spin_sleep();
0544     if (err) {
0545         pr_debug("spin_sleep failed!\n");
0546         goto out_err;
0547     }
0548
0549     evlist__disable(evlist);
0550
0551     switch_tracking.switch_evsel = switch_evsel;
0552     switch_tracking.cycles_evsel = cycles_evsel;
0553
0554     err = process_events(evlist, &switch_tracking);
0555
0556     zfree(&switch_tracking.tids);
0557
0558     if (err)
0559         goto out_err;
0560
0561     /* Check all 4 comm events were seen i.e. that evsel->tracking works */
0562     if (!switch_tracking.comm_seen[0] || !switch_tracking.comm_seen[1] ||
0563         !switch_tracking.comm_seen[2] || !switch_tracking.comm_seen[3]) {
0564         pr_debug("Missing comm events\n");
0565         goto out_err;
0566     }
0567
0568     /* Check cycles event got enabled */
0569     if (!switch_tracking.cycles_before_comm_1) {
0570         pr_debug("Missing cycles events\n");
0571         goto out_err;
0572     }
0573
0574     /* Check cycles event got disabled */
0575     if (switch_tracking.cycles_between_comm_2_and_comm_3) {
0576         pr_debug("cycles events even though event was disabled\n");
0577         goto out_err;
0578     }
0579
0580     /* Check cycles event got enabled again */
0581     if (!switch_tracking.cycles_after_comm_4) {
0582         pr_debug("Missing cycles events\n");
0583         goto out_err;
0584     }
0585 out:
0586     if (evlist) {
0587         evlist__disable(evlist);
0588         evlist__delete(evlist);
0589     }
0590     perf_cpu_map__put(cpus);
0591     perf_thread_map__put(threads);
0592
0593     return err;
0594
0595 out_err:
0596     err = -1;
0597     goto out;
0598 }
0599
0600 DEFINE_SUITE("Track with sched_switch", switch_tracking);