tools/perf/tests/switch-tracking.c

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