kernel/trace/synth_event_gen_test.c

   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 = "char[]",             .name = "dynstring_field_1" },
 246         { .type = "u64",                .name = "ts_ms" },
 247         { .type = "unsigned int",       .name = "cpu" },
 248         { .type = "char[64]",           .name = "my_string_field" },
 249         { .type = "char[]",             .name = "dynstring_field_2" },
 250         { .type = "int",                .name = "my_int_field" },
 251 };
 252
 253 /*
 254  * Test synthetic event creation all at once from array of field
 255  * descriptors.
 256  */
 257 static int __init test_create_synth_event(void)
 258 {
 259         u64 vals[9];
 260         int ret;
 261
 262         /* Create the create_synth_test event with the fields above */
 263         ret = synth_event_create("create_synth_test",
 264                                  create_synth_test_fields,
 265                                  ARRAY_SIZE(create_synth_test_fields),
 266                                  THIS_MODULE);
 267         if (ret)
 268                 goto out;
 269
 270         /*
 271          * Now get the create_synth_test event file.  We need to
 272          * prevent the instance and event from disappearing from
 273          * underneath us, which trace_get_event_file() does (though in
 274          * this case we're using the top-level instance which never
 275          * goes away).
 276          */
 277         create_synth_test = trace_get_event_file(NULL, "synthetic",
 278                                                  "create_synth_test");
 279         if (IS_ERR(create_synth_test)) {
 280                 ret = PTR_ERR(create_synth_test);
 281                 goto delete;
 282         }
 283
 284         /* Enable the event or you won't see anything */
 285         ret = trace_array_set_clr_event(create_synth_test->tr,
 286                                         "synthetic", "create_synth_test", true);
 287         if (ret) {
 288                 trace_put_event_file(create_synth_test);
 289                 goto delete;
 290         }
 291
 292         /* Create some bogus values just for testing */
 293
 294         vals[0] = 777;                  /* next_pid_field */
 295         vals[1] = (u64)(long)"tiddlywinks";     /* next_comm_field */
 296         vals[2] = 1000000;              /* ts_ns */
 297         vals[3] = (u64)(long)"xrayspecs";       /* dynstring_field_1 */
 298         vals[4] = 1000;                 /* ts_ms */
 299         vals[5] = raw_smp_processor_id(); /* cpu */
 300         vals[6] = (u64)(long)"thneed";  /* my_string_field */
 301         vals[7] = (u64)(long)"kerplunk";        /* dynstring_field_2 */
 302         vals[8] = 398;                  /* my_int_field */
 303
 304         /* Now generate a create_synth_test event */
 305         ret = synth_event_trace_array(create_synth_test, vals, ARRAY_SIZE(vals));
 306  out:
 307         return ret;
 308  delete:
 309         /* We got an error after creating the event, delete it */
 310         synth_event_delete("create_synth_test");
 311
 312         goto out;
 313 }
 314
 315 /*
 316  * Test tracing a synthetic event by reserving trace buffer space,
 317  * then filling in fields one after another.
 318  */
 319 static int __init test_add_next_synth_val(void)
 320 {
 321         struct synth_event_trace_state trace_state;
 322         int ret;
 323
 324         /* Start by reserving space in the trace buffer */
 325         ret = synth_event_trace_start(gen_synth_test, &trace_state);
 326         if (ret)
 327                 return ret;
 328
 329         /* Write some bogus values into the trace buffer, one after another */
 330
 331         /* next_pid_field */
 332         ret = synth_event_add_next_val(777, &trace_state);
 333         if (ret)
 334                 goto out;
 335
 336         /* next_comm_field */
 337         ret = synth_event_add_next_val((u64)(long)"slinky", &trace_state);
 338         if (ret)
 339                 goto out;
 340
 341         /* ts_ns */
 342         ret = synth_event_add_next_val(1000000, &trace_state);
 343         if (ret)
 344                 goto out;
 345
 346         /* ts_ms */
 347         ret = synth_event_add_next_val(1000, &trace_state);
 348         if (ret)
 349                 goto out;
 350
 351         /* cpu */
 352         ret = synth_event_add_next_val(raw_smp_processor_id(), &trace_state);
 353         if (ret)
 354                 goto out;
 355
 356         /* my_string_field */
 357         ret = synth_event_add_next_val((u64)(long)"thneed_2.01", &trace_state);
 358         if (ret)
 359                 goto out;
 360
 361         /* my_int_field */
 362         ret = synth_event_add_next_val(395, &trace_state);
 363  out:
 364         /* Finally, commit the event */
 365         ret = synth_event_trace_end(&trace_state);
 366
 367         return ret;
 368 }
 369
 370 /*
 371  * Test tracing a synthetic event by reserving trace buffer space,
 372  * then filling in fields using field names, which can be done in any
 373  * order.
 374  */
 375 static int __init test_add_synth_val(void)
 376 {
 377         struct synth_event_trace_state trace_state;
 378         int ret;
 379
 380         /* Start by reserving space in the trace buffer */
 381         ret = synth_event_trace_start(gen_synth_test, &trace_state);
 382         if (ret)
 383                 return ret;
 384
 385         /* Write some bogus values into the trace buffer, using field names */
 386
 387         ret = synth_event_add_val("ts_ns", 1000000, &trace_state);
 388         if (ret)
 389                 goto out;
 390
 391         ret = synth_event_add_val("ts_ms", 1000, &trace_state);
 392         if (ret)
 393                 goto out;
 394
 395         ret = synth_event_add_val("cpu", raw_smp_processor_id(), &trace_state);
 396         if (ret)
 397                 goto out;
 398
 399         ret = synth_event_add_val("next_pid_field", 777, &trace_state);
 400         if (ret)
 401                 goto out;
 402
 403         ret = synth_event_add_val("next_comm_field", (u64)(long)"silly putty",
 404                                   &trace_state);
 405         if (ret)
 406                 goto out;
 407
 408         ret = synth_event_add_val("my_string_field", (u64)(long)"thneed_9",
 409                                   &trace_state);
 410         if (ret)
 411                 goto out;
 412
 413         ret = synth_event_add_val("my_int_field", 3999, &trace_state);
 414  out:
 415         /* Finally, commit the event */
 416         ret = synth_event_trace_end(&trace_state);
 417
 418         return ret;
 419 }
 420
 421 /*
 422  * Test tracing a synthetic event all at once from array of values.
 423  */
 424 static int __init test_trace_synth_event(void)
 425 {
 426         int ret;
 427
 428         /* Trace some bogus values just for testing */
 429         ret = synth_event_trace(create_synth_test, 9,   /* number of values */
 430                                 (u64)444,               /* next_pid_field */
 431                                 (u64)(long)"clackers",  /* next_comm_field */
 432                                 (u64)1000000,           /* ts_ns */
 433                                 (u64)(long)"viewmaster",/* dynstring_field_1 */
 434                                 (u64)1000,              /* ts_ms */
 435                                 (u64)raw_smp_processor_id(), /* cpu */
 436                                 (u64)(long)"Thneed",    /* my_string_field */
 437                                 (u64)(long)"yoyos",     /* dynstring_field_2 */
 438                                 (u64)999);              /* my_int_field */
 439         return ret;
 440 }
 441
 442 static int __init synth_event_gen_test_init(void)
 443 {
 444         int ret;
 445
 446         ret = test_gen_synth_cmd();
 447         if (ret)
 448                 return ret;
 449
 450         ret = test_empty_synth_event();
 451         if (ret) {
 452                 WARN_ON(trace_array_set_clr_event(gen_synth_test->tr,
 453                                                   "synthetic",
 454                                                   "gen_synth_test", false));
 455                 trace_put_event_file(gen_synth_test);
 456                 WARN_ON(synth_event_delete("gen_synth_test"));
 457                 goto out;
 458         }
 459
 460         ret = test_create_synth_event();
 461         if (ret) {
 462                 WARN_ON(trace_array_set_clr_event(gen_synth_test->tr,
 463                                                   "synthetic",
 464                                                   "gen_synth_test", false));
 465                 trace_put_event_file(gen_synth_test);
 466                 WARN_ON(synth_event_delete("gen_synth_test"));
 467
 468                 WARN_ON(trace_array_set_clr_event(empty_synth_test->tr,
 469                                                   "synthetic",
 470                                                   "empty_synth_test", false));
 471                 trace_put_event_file(empty_synth_test);
 472                 WARN_ON(synth_event_delete("empty_synth_test"));
 473                 goto out;
 474         }
 475
 476         ret = test_add_next_synth_val();
 477         WARN_ON(ret);
 478
 479         ret = test_add_synth_val();
 480         WARN_ON(ret);
 481
 482         ret = test_trace_synth_event();
 483         WARN_ON(ret);
 484  out:
 485         return ret;
 486 }
 487
 488 static void __exit synth_event_gen_test_exit(void)
 489 {
 490         /* Disable the event or you can't remove it */
 491         WARN_ON(trace_array_set_clr_event(gen_synth_test->tr,
 492                                           "synthetic",
 493                                           "gen_synth_test", false));
 494
 495         /* Now give the file and instance back */
 496         trace_put_event_file(gen_synth_test);
 497
 498         /* Now unregister and free the synthetic event */
 499         WARN_ON(synth_event_delete("gen_synth_test"));
 500
 501         /* Disable the event or you can't remove it */
 502         WARN_ON(trace_array_set_clr_event(empty_synth_test->tr,
 503                                           "synthetic",
 504                                           "empty_synth_test", false));
 505
 506         /* Now give the file and instance back */
 507         trace_put_event_file(empty_synth_test);
 508
 509         /* Now unregister and free the synthetic event */
 510         WARN_ON(synth_event_delete("empty_synth_test"));
 511
 512         /* Disable the event or you can't remove it */
 513         WARN_ON(trace_array_set_clr_event(create_synth_test->tr,
 514                                           "synthetic",
 515                                           "create_synth_test", false));
 516
 517         /* Now give the file and instance back */
 518         trace_put_event_file(create_synth_test);
 519
 520         /* Now unregister and free the synthetic event */
 521         WARN_ON(synth_event_delete("create_synth_test"));
 522 }
 523
 524 module_init(synth_event_gen_test_init)
 525 module_exit(synth_event_gen_test_exit)
 526
 527 MODULE_AUTHOR("Tom Zanussi");
 528 MODULE_DESCRIPTION("synthetic event generation test");
 529 MODULE_LICENSE("GPL v2");