switch-tracking.c 13 KB

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