synth_event_gen_test.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Test module for in-kernel sythetic event creation and generation.
  4. *
  5. * Copyright (C) 2019 Tom Zanussi <zanussi@kernel.org>
  6. */
  7. #include <linux/module.h>
  8. #include <linux/trace_events.h>
  9. /*
  10. * This module is a simple test of basic functionality for in-kernel
  11. * synthetic event creation and generation, the first and second tests
  12. * using synth_event_gen_cmd_start() and synth_event_add_field(), the
  13. * third uses synth_event_create() to do it all at once with a static
  14. * field array.
  15. *
  16. * Following that are a few examples using the created events to test
  17. * various ways of tracing a synthetic event.
  18. *
  19. * To test, select CONFIG_SYNTH_EVENT_GEN_TEST and build the module.
  20. * Then:
  21. *
  22. * # insmod kernel/trace/synth_event_gen_test.ko
  23. * # cat /sys/kernel/debug/tracing/trace
  24. *
  25. * You should see several events in the trace buffer -
  26. * "create_synth_test", "empty_synth_test", and several instances of
  27. * "gen_synth_test".
  28. *
  29. * To remove the events, remove the module:
  30. *
  31. * # rmmod synth_event_gen_test
  32. *
  33. */
  34. static struct trace_event_file *create_synth_test;
  35. static struct trace_event_file *empty_synth_test;
  36. static struct trace_event_file *gen_synth_test;
  37. /*
  38. * Test to make sure we can create a synthetic event, then add more
  39. * fields.
  40. */
  41. static int __init test_gen_synth_cmd(void)
  42. {
  43. struct dynevent_cmd cmd;
  44. u64 vals[7];
  45. char *buf;
  46. int ret;
  47. /* Create a buffer to hold the generated command */
  48. buf = kzalloc(MAX_DYNEVENT_CMD_LEN, GFP_KERNEL);
  49. if (!buf)
  50. return -ENOMEM;
  51. /* Before generating the command, initialize the cmd object */
  52. synth_event_cmd_init(&cmd, buf, MAX_DYNEVENT_CMD_LEN);
  53. /*
  54. * Create the empty gen_synth_test synthetic event with the
  55. * first 4 fields.
  56. */
  57. ret = synth_event_gen_cmd_start(&cmd, "gen_synth_test", THIS_MODULE,
  58. "pid_t", "next_pid_field",
  59. "char[16]", "next_comm_field",
  60. "u64", "ts_ns",
  61. "u64", "ts_ms");
  62. if (ret)
  63. goto free;
  64. /* Use synth_event_add_field to add the rest of the fields */
  65. ret = synth_event_add_field(&cmd, "unsigned int", "cpu");
  66. if (ret)
  67. goto free;
  68. ret = synth_event_add_field(&cmd, "char[64]", "my_string_field");
  69. if (ret)
  70. goto free;
  71. ret = synth_event_add_field(&cmd, "int", "my_int_field");
  72. if (ret)
  73. goto free;
  74. ret = synth_event_gen_cmd_end(&cmd);
  75. if (ret)
  76. goto free;
  77. /*
  78. * Now get the gen_synth_test event file. We need to prevent
  79. * the instance and event from disappearing from underneath
  80. * us, which trace_get_event_file() does (though in this case
  81. * we're using the top-level instance which never goes away).
  82. */
  83. gen_synth_test = trace_get_event_file(NULL, "synthetic",
  84. "gen_synth_test");
  85. if (IS_ERR(gen_synth_test)) {
  86. ret = PTR_ERR(gen_synth_test);
  87. goto delete;
  88. }
  89. /* Enable the event or you won't see anything */
  90. ret = trace_array_set_clr_event(gen_synth_test->tr,
  91. "synthetic", "gen_synth_test", true);
  92. if (ret) {
  93. trace_put_event_file(gen_synth_test);
  94. goto delete;
  95. }
  96. /* Create some bogus values just for testing */
  97. vals[0] = 777; /* next_pid_field */
  98. vals[1] = (u64)(long)"hula hoops"; /* next_comm_field */
  99. vals[2] = 1000000; /* ts_ns */
  100. vals[3] = 1000; /* ts_ms */
  101. vals[4] = raw_smp_processor_id(); /* cpu */
  102. vals[5] = (u64)(long)"thneed"; /* my_string_field */
  103. vals[6] = 598; /* my_int_field */
  104. /* Now generate a gen_synth_test event */
  105. ret = synth_event_trace_array(gen_synth_test, vals, ARRAY_SIZE(vals));
  106. out:
  107. return ret;
  108. delete:
  109. /* We got an error after creating the event, delete it */
  110. synth_event_delete("gen_synth_test");
  111. free:
  112. kfree(buf);
  113. goto out;
  114. }
  115. /*
  116. * Test to make sure we can create an initially empty synthetic event,
  117. * then add all the fields.
  118. */
  119. static int __init test_empty_synth_event(void)
  120. {
  121. struct dynevent_cmd cmd;
  122. u64 vals[7];
  123. char *buf;
  124. int ret;
  125. /* Create a buffer to hold the generated command */
  126. buf = kzalloc(MAX_DYNEVENT_CMD_LEN, GFP_KERNEL);
  127. if (!buf)
  128. return -ENOMEM;
  129. /* Before generating the command, initialize the cmd object */
  130. synth_event_cmd_init(&cmd, buf, MAX_DYNEVENT_CMD_LEN);
  131. /*
  132. * Create the empty_synth_test synthetic event with no fields.
  133. */
  134. ret = synth_event_gen_cmd_start(&cmd, "empty_synth_test", THIS_MODULE);
  135. if (ret)
  136. goto free;
  137. /* Use synth_event_add_field to add all of the fields */
  138. ret = synth_event_add_field(&cmd, "pid_t", "next_pid_field");
  139. if (ret)
  140. goto free;
  141. ret = synth_event_add_field(&cmd, "char[16]", "next_comm_field");
  142. if (ret)
  143. goto free;
  144. ret = synth_event_add_field(&cmd, "u64", "ts_ns");
  145. if (ret)
  146. goto free;
  147. ret = synth_event_add_field(&cmd, "u64", "ts_ms");
  148. if (ret)
  149. goto free;
  150. ret = synth_event_add_field(&cmd, "unsigned int", "cpu");
  151. if (ret)
  152. goto free;
  153. ret = synth_event_add_field(&cmd, "char[64]", "my_string_field");
  154. if (ret)
  155. goto free;
  156. ret = synth_event_add_field(&cmd, "int", "my_int_field");
  157. if (ret)
  158. goto free;
  159. /* All fields have been added, close and register the synth event */
  160. ret = synth_event_gen_cmd_end(&cmd);
  161. if (ret)
  162. goto free;
  163. /*
  164. * Now get the empty_synth_test event file. We need to
  165. * prevent the instance and event from disappearing from
  166. * underneath us, which trace_get_event_file() does (though in
  167. * this case we're using the top-level instance which never
  168. * goes away).
  169. */
  170. empty_synth_test = trace_get_event_file(NULL, "synthetic",
  171. "empty_synth_test");
  172. if (IS_ERR(empty_synth_test)) {
  173. ret = PTR_ERR(empty_synth_test);
  174. goto delete;
  175. }
  176. /* Enable the event or you won't see anything */
  177. ret = trace_array_set_clr_event(empty_synth_test->tr,
  178. "synthetic", "empty_synth_test", true);
  179. if (ret) {
  180. trace_put_event_file(empty_synth_test);
  181. goto delete;
  182. }
  183. /* Create some bogus values just for testing */
  184. vals[0] = 777; /* next_pid_field */
  185. vals[1] = (u64)(long)"tiddlywinks"; /* next_comm_field */
  186. vals[2] = 1000000; /* ts_ns */
  187. vals[3] = 1000; /* ts_ms */
  188. vals[4] = raw_smp_processor_id(); /* cpu */
  189. vals[5] = (u64)(long)"thneed_2.0"; /* my_string_field */
  190. vals[6] = 399; /* my_int_field */
  191. /* Now trace an empty_synth_test event */
  192. ret = synth_event_trace_array(empty_synth_test, vals, ARRAY_SIZE(vals));
  193. out:
  194. return ret;
  195. delete:
  196. /* We got an error after creating the event, delete it */
  197. synth_event_delete("empty_synth_test");
  198. free:
  199. kfree(buf);
  200. goto out;
  201. }
  202. static struct synth_field_desc create_synth_test_fields[] = {
  203. { .type = "pid_t", .name = "next_pid_field" },
  204. { .type = "char[16]", .name = "next_comm_field" },
  205. { .type = "u64", .name = "ts_ns" },
  206. { .type = "char[]", .name = "dynstring_field_1" },
  207. { .type = "u64", .name = "ts_ms" },
  208. { .type = "unsigned int", .name = "cpu" },
  209. { .type = "char[64]", .name = "my_string_field" },
  210. { .type = "char[]", .name = "dynstring_field_2" },
  211. { .type = "int", .name = "my_int_field" },
  212. };
  213. /*
  214. * Test synthetic event creation all at once from array of field
  215. * descriptors.
  216. */
  217. static int __init test_create_synth_event(void)
  218. {
  219. u64 vals[9];
  220. int ret;
  221. /* Create the create_synth_test event with the fields above */
  222. ret = synth_event_create("create_synth_test",
  223. create_synth_test_fields,
  224. ARRAY_SIZE(create_synth_test_fields),
  225. THIS_MODULE);
  226. if (ret)
  227. goto out;
  228. /*
  229. * Now get the create_synth_test event file. We need to
  230. * prevent the instance and event from disappearing from
  231. * underneath us, which trace_get_event_file() does (though in
  232. * this case we're using the top-level instance which never
  233. * goes away).
  234. */
  235. create_synth_test = trace_get_event_file(NULL, "synthetic",
  236. "create_synth_test");
  237. if (IS_ERR(create_synth_test)) {
  238. ret = PTR_ERR(create_synth_test);
  239. goto delete;
  240. }
  241. /* Enable the event or you won't see anything */
  242. ret = trace_array_set_clr_event(create_synth_test->tr,
  243. "synthetic", "create_synth_test", true);
  244. if (ret) {
  245. trace_put_event_file(create_synth_test);
  246. goto delete;
  247. }
  248. /* Create some bogus values just for testing */
  249. vals[0] = 777; /* next_pid_field */
  250. vals[1] = (u64)(long)"tiddlywinks"; /* next_comm_field */
  251. vals[2] = 1000000; /* ts_ns */
  252. vals[3] = (u64)(long)"xrayspecs"; /* dynstring_field_1 */
  253. vals[4] = 1000; /* ts_ms */
  254. vals[5] = raw_smp_processor_id(); /* cpu */
  255. vals[6] = (u64)(long)"thneed"; /* my_string_field */
  256. vals[7] = (u64)(long)"kerplunk"; /* dynstring_field_2 */
  257. vals[8] = 398; /* my_int_field */
  258. /* Now generate a create_synth_test event */
  259. ret = synth_event_trace_array(create_synth_test, vals, ARRAY_SIZE(vals));
  260. out:
  261. return ret;
  262. delete:
  263. /* We got an error after creating the event, delete it */
  264. ret = synth_event_delete("create_synth_test");
  265. goto out;
  266. }
  267. /*
  268. * Test tracing a synthetic event by reserving trace buffer space,
  269. * then filling in fields one after another.
  270. */
  271. static int __init test_add_next_synth_val(void)
  272. {
  273. struct synth_event_trace_state trace_state;
  274. int ret;
  275. /* Start by reserving space in the trace buffer */
  276. ret = synth_event_trace_start(gen_synth_test, &trace_state);
  277. if (ret)
  278. return ret;
  279. /* Write some bogus values into the trace buffer, one after another */
  280. /* next_pid_field */
  281. ret = synth_event_add_next_val(777, &trace_state);
  282. if (ret)
  283. goto out;
  284. /* next_comm_field */
  285. ret = synth_event_add_next_val((u64)(long)"slinky", &trace_state);
  286. if (ret)
  287. goto out;
  288. /* ts_ns */
  289. ret = synth_event_add_next_val(1000000, &trace_state);
  290. if (ret)
  291. goto out;
  292. /* ts_ms */
  293. ret = synth_event_add_next_val(1000, &trace_state);
  294. if (ret)
  295. goto out;
  296. /* cpu */
  297. ret = synth_event_add_next_val(raw_smp_processor_id(), &trace_state);
  298. if (ret)
  299. goto out;
  300. /* my_string_field */
  301. ret = synth_event_add_next_val((u64)(long)"thneed_2.01", &trace_state);
  302. if (ret)
  303. goto out;
  304. /* my_int_field */
  305. ret = synth_event_add_next_val(395, &trace_state);
  306. out:
  307. /* Finally, commit the event */
  308. ret = synth_event_trace_end(&trace_state);
  309. return ret;
  310. }
  311. /*
  312. * Test tracing a synthetic event by reserving trace buffer space,
  313. * then filling in fields using field names, which can be done in any
  314. * order.
  315. */
  316. static int __init test_add_synth_val(void)
  317. {
  318. struct synth_event_trace_state trace_state;
  319. int ret;
  320. /* Start by reserving space in the trace buffer */
  321. ret = synth_event_trace_start(gen_synth_test, &trace_state);
  322. if (ret)
  323. return ret;
  324. /* Write some bogus values into the trace buffer, using field names */
  325. ret = synth_event_add_val("ts_ns", 1000000, &trace_state);
  326. if (ret)
  327. goto out;
  328. ret = synth_event_add_val("ts_ms", 1000, &trace_state);
  329. if (ret)
  330. goto out;
  331. ret = synth_event_add_val("cpu", raw_smp_processor_id(), &trace_state);
  332. if (ret)
  333. goto out;
  334. ret = synth_event_add_val("next_pid_field", 777, &trace_state);
  335. if (ret)
  336. goto out;
  337. ret = synth_event_add_val("next_comm_field", (u64)(long)"silly putty",
  338. &trace_state);
  339. if (ret)
  340. goto out;
  341. ret = synth_event_add_val("my_string_field", (u64)(long)"thneed_9",
  342. &trace_state);
  343. if (ret)
  344. goto out;
  345. ret = synth_event_add_val("my_int_field", 3999, &trace_state);
  346. out:
  347. /* Finally, commit the event */
  348. ret = synth_event_trace_end(&trace_state);
  349. return ret;
  350. }
  351. /*
  352. * Test tracing a synthetic event all at once from array of values.
  353. */
  354. static int __init test_trace_synth_event(void)
  355. {
  356. int ret;
  357. /* Trace some bogus values just for testing */
  358. ret = synth_event_trace(create_synth_test, 9, /* number of values */
  359. (u64)444, /* next_pid_field */
  360. (u64)(long)"clackers", /* next_comm_field */
  361. (u64)1000000, /* ts_ns */
  362. (u64)(long)"viewmaster",/* dynstring_field_1 */
  363. (u64)1000, /* ts_ms */
  364. (u64)raw_smp_processor_id(), /* cpu */
  365. (u64)(long)"Thneed", /* my_string_field */
  366. (u64)(long)"yoyos", /* dynstring_field_2 */
  367. (u64)999); /* my_int_field */
  368. return ret;
  369. }
  370. static int __init synth_event_gen_test_init(void)
  371. {
  372. int ret;
  373. ret = test_gen_synth_cmd();
  374. if (ret)
  375. return ret;
  376. ret = test_empty_synth_event();
  377. if (ret) {
  378. WARN_ON(trace_array_set_clr_event(gen_synth_test->tr,
  379. "synthetic",
  380. "gen_synth_test", false));
  381. trace_put_event_file(gen_synth_test);
  382. WARN_ON(synth_event_delete("gen_synth_test"));
  383. goto out;
  384. }
  385. ret = test_create_synth_event();
  386. if (ret) {
  387. WARN_ON(trace_array_set_clr_event(gen_synth_test->tr,
  388. "synthetic",
  389. "gen_synth_test", false));
  390. trace_put_event_file(gen_synth_test);
  391. WARN_ON(synth_event_delete("gen_synth_test"));
  392. WARN_ON(trace_array_set_clr_event(empty_synth_test->tr,
  393. "synthetic",
  394. "empty_synth_test", false));
  395. trace_put_event_file(empty_synth_test);
  396. WARN_ON(synth_event_delete("empty_synth_test"));
  397. goto out;
  398. }
  399. ret = test_add_next_synth_val();
  400. WARN_ON(ret);
  401. ret = test_add_synth_val();
  402. WARN_ON(ret);
  403. ret = test_trace_synth_event();
  404. WARN_ON(ret);
  405. out:
  406. return ret;
  407. }
  408. static void __exit synth_event_gen_test_exit(void)
  409. {
  410. /* Disable the event or you can't remove it */
  411. WARN_ON(trace_array_set_clr_event(gen_synth_test->tr,
  412. "synthetic",
  413. "gen_synth_test", false));
  414. /* Now give the file and instance back */
  415. trace_put_event_file(gen_synth_test);
  416. /* Now unregister and free the synthetic event */
  417. WARN_ON(synth_event_delete("gen_synth_test"));
  418. /* Disable the event or you can't remove it */
  419. WARN_ON(trace_array_set_clr_event(empty_synth_test->tr,
  420. "synthetic",
  421. "empty_synth_test", false));
  422. /* Now give the file and instance back */
  423. trace_put_event_file(empty_synth_test);
  424. /* Now unregister and free the synthetic event */
  425. WARN_ON(synth_event_delete("empty_synth_test"));
  426. /* Disable the event or you can't remove it */
  427. WARN_ON(trace_array_set_clr_event(create_synth_test->tr,
  428. "synthetic",
  429. "create_synth_test", false));
  430. /* Now give the file and instance back */
  431. trace_put_event_file(create_synth_test);
  432. /* Now unregister and free the synthetic event */
  433. WARN_ON(synth_event_delete("create_synth_test"));
  434. }
  435. module_init(synth_event_gen_test_init)
  436. module_exit(synth_event_gen_test_exit)
  437. MODULE_AUTHOR("Tom Zanussi");
  438. MODULE_DESCRIPTION("synthetic event generation test");
  439. MODULE_LICENSE("GPL v2");