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 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/debug/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 out: 124 return ret; 125 delete: 126 /* We got an error after creating the event, delete it */ 127 synth_event_delete("gen_synth_test"); 128 free: 129 kfree(buf); 130 131 goto out; 132 } 133 134 /* 135 * Test to make sure we can create an initially empty synthetic event, 136 * then add all the fields. 137 */ 138 static int __init test_empty_synth_event(void) 139 { 140 struct dynevent_cmd cmd; 141 u64 vals[7]; 142 char *buf; 143 int ret; 144 145 /* Create a buffer to hold the generated command */ 146 buf = kzalloc(MAX_DYNEVENT_CMD_LEN, GFP_KERNEL); 147 if (!buf) 148 return -ENOMEM; 149 150 /* Before generating the command, initialize the cmd object */ 151 synth_event_cmd_init(&cmd, buf, MAX_DYNEVENT_CMD_LEN); 152 153 /* 154 * Create the empty_synth_test synthetic event with no fields. 155 */ 156 ret = synth_event_gen_cmd_start(&cmd, "empty_synth_test", THIS_MODULE); 157 if (ret) 158 goto free; 159 160 /* Use synth_event_add_field to add all of the fields */ 161 162 ret = synth_event_add_field(&cmd, "pid_t", "next_pid_field"); 163 if (ret) 164 goto free; 165 166 ret = synth_event_add_field(&cmd, "char[16]", "next_comm_field"); 167 if (ret) 168 goto free; 169 170 ret = synth_event_add_field(&cmd, "u64", "ts_ns"); 171 if (ret) 172 goto free; 173 174 ret = synth_event_add_field(&cmd, "u64", "ts_ms"); 175 if (ret) 176 goto free; 177 178 ret = synth_event_add_field(&cmd, "unsigned int", "cpu"); 179 if (ret) 180 goto free; 181 182 ret = synth_event_add_field(&cmd, "char[64]", "my_string_field"); 183 if (ret) 184 goto free; 185 186 ret = synth_event_add_field(&cmd, "int", "my_int_field"); 187 if (ret) 188 goto free; 189 190 /* All fields have been added, close and register the synth event */ 191 192 ret = synth_event_gen_cmd_end(&cmd); 193 if (ret) 194 goto free; 195 196 /* 197 * Now get the empty_synth_test event file. We need to 198 * prevent the instance and event from disappearing from 199 * underneath us, which trace_get_event_file() does (though in 200 * this case we're using the top-level instance which never 201 * goes away). 202 */ 203 empty_synth_test = trace_get_event_file(NULL, "synthetic", 204 "empty_synth_test"); 205 if (IS_ERR(empty_synth_test)) { 206 ret = PTR_ERR(empty_synth_test); 207 goto delete; 208 } 209 210 /* Enable the event or you won't see anything */ 211 ret = trace_array_set_clr_event(empty_synth_test->tr, 212 "synthetic", "empty_synth_test", true); 213 if (ret) { 214 trace_put_event_file(empty_synth_test); 215 goto delete; 216 } 217 218 /* Create some bogus values just for testing */ 219 220 vals[0] = 777; /* next_pid_field */ 221 vals[1] = (u64)(long)"tiddlywinks"; /* next_comm_field */ 222 vals[2] = 1000000; /* ts_ns */ 223 vals[3] = 1000; /* ts_ms */ 224 vals[4] = raw_smp_processor_id(); /* cpu */ 225 vals[5] = (u64)(long)"thneed_2.0"; /* my_string_field */ 226 vals[6] = 399; /* my_int_field */ 227 228 /* Now trace an empty_synth_test event */ 229 ret = synth_event_trace_array(empty_synth_test, vals, ARRAY_SIZE(vals)); 230 out: 231 return ret; 232 delete: 233 /* We got an error after creating the event, delete it */ 234 synth_event_delete("empty_synth_test"); 235 free: 236 kfree(buf); 237 238 goto out; 239 } 240 241 static struct synth_field_desc create_synth_test_fields[] = { 242 { .type = "pid_t", .name = "next_pid_field" }, 243 { .type = "char[16]", .name = "next_comm_field" }, 244 { .type = "u64", .name = "ts_ns" }, 245 { .type = "u64", .name = "ts_ms" }, 246 { .type = "unsigned int", .name = "cpu" }, 247 { .type = "char[64]", .name = "my_string_field" }, 248 { .type = "int", .name = "my_int_field" }, 249 }; 250 251 /* 252 * Test synthetic event creation all at once from array of field 253 * descriptors. 254 */ 255 static int __init test_create_synth_event(void) 256 { 257 u64 vals[7]; 258 int ret; 259 260 /* Create the create_synth_test event with the fields above */ 261 ret = synth_event_create("create_synth_test", 262 create_synth_test_fields, 263 ARRAY_SIZE(create_synth_test_fields), 264 THIS_MODULE); 265 if (ret) 266 goto out; 267 268 /* 269 * Now get the create_synth_test event file. We need to 270 * prevent the instance and event from disappearing from 271 * underneath us, which trace_get_event_file() does (though in 272 * this case we're using the top-level instance which never 273 * goes away). 274 */ 275 create_synth_test = trace_get_event_file(NULL, "synthetic", 276 "create_synth_test"); 277 if (IS_ERR(create_synth_test)) { 278 ret = PTR_ERR(create_synth_test); 279 goto delete; 280 } 281 282 /* Enable the event or you won't see anything */ 283 ret = trace_array_set_clr_event(create_synth_test->tr, 284 "synthetic", "create_synth_test", true); 285 if (ret) { 286 trace_put_event_file(create_synth_test); 287 goto delete; 288 } 289 290 /* Create some bogus values just for testing */ 291 292 vals[0] = 777; /* next_pid_field */ 293 vals[1] = (u64)(long)"tiddlywinks"; /* next_comm_field */ 294 vals[2] = 1000000; /* ts_ns */ 295 vals[3] = 1000; /* ts_ms */ 296 vals[4] = raw_smp_processor_id(); /* cpu */ 297 vals[5] = (u64)(long)"thneed"; /* my_string_field */ 298 vals[6] = 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 ret = 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, 7, /* number of values */ 426 (u64)444, /* next_pid_field */ 427 (u64)(long)"clackers", /* next_comm_field */ 428 (u64)1000000, /* ts_ns */ 429 (u64)1000, /* ts_ms */ 430 (u64)raw_smp_processor_id(), /* cpu */ 431 (u64)(long)"Thneed", /* my_string_field */ 432 (u64)999); /* my_int_field */ 433 return ret; 434 } 435 436 static int __init synth_event_gen_test_init(void) 437 { 438 int ret; 439 440 ret = test_gen_synth_cmd(); 441 if (ret) 442 return ret; 443 444 ret = test_empty_synth_event(); 445 if (ret) { 446 WARN_ON(trace_array_set_clr_event(gen_synth_test->tr, 447 "synthetic", 448 "gen_synth_test", false)); 449 trace_put_event_file(gen_synth_test); 450 WARN_ON(synth_event_delete("gen_synth_test")); 451 goto out; 452 } 453 454 ret = test_create_synth_event(); 455 if (ret) { 456 WARN_ON(trace_array_set_clr_event(gen_synth_test->tr, 457 "synthetic", 458 "gen_synth_test", false)); 459 trace_put_event_file(gen_synth_test); 460 WARN_ON(synth_event_delete("gen_synth_test")); 461 462 WARN_ON(trace_array_set_clr_event(empty_synth_test->tr, 463 "synthetic", 464 "empty_synth_test", false)); 465 trace_put_event_file(empty_synth_test); 466 WARN_ON(synth_event_delete("empty_synth_test")); 467 goto out; 468 } 469 470 ret = test_add_next_synth_val(); 471 WARN_ON(ret); 472 473 ret = test_add_synth_val(); 474 WARN_ON(ret); 475 476 ret = test_trace_synth_event(); 477 WARN_ON(ret); 478 out: 479 return ret; 480 } 481 482 static void __exit synth_event_gen_test_exit(void) 483 { 484 /* Disable the event or you can't remove it */ 485 WARN_ON(trace_array_set_clr_event(gen_synth_test->tr, 486 "synthetic", 487 "gen_synth_test", false)); 488 489 /* Now give the file and instance back */ 490 trace_put_event_file(gen_synth_test); 491 492 /* Now unregister and free the synthetic event */ 493 WARN_ON(synth_event_delete("gen_synth_test")); 494 495 /* Disable the event or you can't remove it */ 496 WARN_ON(trace_array_set_clr_event(empty_synth_test->tr, 497 "synthetic", 498 "empty_synth_test", false)); 499 500 /* Now give the file and instance back */ 501 trace_put_event_file(empty_synth_test); 502 503 /* Now unregister and free the synthetic event */ 504 WARN_ON(synth_event_delete("empty_synth_test")); 505 506 /* Disable the event or you can't remove it */ 507 WARN_ON(trace_array_set_clr_event(create_synth_test->tr, 508 "synthetic", 509 "create_synth_test", false)); 510 511 /* Now give the file and instance back */ 512 trace_put_event_file(create_synth_test); 513 514 /* Now unregister and free the synthetic event */ 515 WARN_ON(synth_event_delete("create_synth_test")); 516 } 517 518 module_init(synth_event_gen_test_init) 519 module_exit(synth_event_gen_test_exit) 520 521 MODULE_AUTHOR("Tom Zanussi"); 522 MODULE_DESCRIPTION("synthetic event generation test"); 523 MODULE_LICENSE("GPL v2"); 524