kernel/trace/synth_event_gen_test.c

   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");