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