kernel/trace/kprobe_event_gen_test.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Test module for in-kernel kprobe event creation and generation.
0004  *
0005  * Copyright (C) 2019 Tom Zanussi <zanussi@kernel.org>
0006  */
0007
0008 #include <linux/module.h>
0009 #include <linux/trace_events.h>
0010
0011 /*
0012  * This module is a simple test of basic functionality for in-kernel
0013  * kprobe/kretprobe event creation.  The first test uses
0014  * kprobe_event_gen_cmd_start(), kprobe_event_add_fields() and
0015  * kprobe_event_gen_cmd_end() to create a kprobe event, which is then
0016  * enabled in order to generate trace output.  The second creates a
0017  * kretprobe event using kretprobe_event_gen_cmd_start() and
0018  * kretprobe_event_gen_cmd_end(), and is also then enabled.
0019  *
0020  * To test, select CONFIG_KPROBE_EVENT_GEN_TEST and build the module.
0021  * Then:
0022  *
0023  * # insmod kernel/trace/kprobe_event_gen_test.ko
0024  * # cat /sys/kernel/debug/tracing/trace
0025  *
0026  * You should see many instances of the "gen_kprobe_test" and
0027  * "gen_kretprobe_test" events in the trace buffer.
0028  *
0029  * To remove the events, remove the module:
0030  *
0031  * # rmmod kprobe_event_gen_test
0032  *
0033  */
0034
0035 static struct trace_event_file *gen_kprobe_test;
0036 static struct trace_event_file *gen_kretprobe_test;
0037
0038 /*
0039  * Test to make sure we can create a kprobe event, then add more
0040  * fields.
0041  */
0042 static int __init test_gen_kprobe_cmd(void)
0043 {
0044     struct dynevent_cmd cmd;
0045     char *buf;
0046     int ret;
0047
0048     /* Create a buffer to hold the generated command */
0049     buf = kzalloc(MAX_DYNEVENT_CMD_LEN, GFP_KERNEL);
0050     if (!buf)
0051         return -ENOMEM;
0052
0053     /* Before generating the command, initialize the cmd object */
0054     kprobe_event_cmd_init(&cmd, buf, MAX_DYNEVENT_CMD_LEN);
0055
0056     /*
0057      * Define the gen_kprobe_test event with the first 2 kprobe
0058      * fields.
0059      */
0060     ret = kprobe_event_gen_cmd_start(&cmd, "gen_kprobe_test",
0061                      "do_sys_open",
0062                      "dfd=%ax", "filename=%dx");
0063     if (ret)
0064         goto free;
0065
0066     /* Use kprobe_event_add_fields to add the rest of the fields */
0067
0068     ret = kprobe_event_add_fields(&cmd, "flags=%cx", "mode=+4($stack)");
0069     if (ret)
0070         goto free;
0071
0072     /*
0073      * This actually creates the event.
0074      */
0075     ret = kprobe_event_gen_cmd_end(&cmd);
0076     if (ret)
0077         goto free;
0078
0079     /*
0080      * Now get the gen_kprobe_test event file.  We need to prevent
0081      * the instance and event from disappearing from underneath
0082      * us, which trace_get_event_file() does (though in this case
0083      * we're using the top-level instance which never goes away).
0084      */
0085     gen_kprobe_test = trace_get_event_file(NULL, "kprobes",
0086                            "gen_kprobe_test");
0087     if (IS_ERR(gen_kprobe_test)) {
0088         ret = PTR_ERR(gen_kprobe_test);
0089         goto delete;
0090     }
0091
0092     /* Enable the event or you won't see anything */
0093     ret = trace_array_set_clr_event(gen_kprobe_test->tr,
0094                     "kprobes", "gen_kprobe_test", true);
0095     if (ret) {
0096         trace_put_event_file(gen_kprobe_test);
0097         goto delete;
0098     }
0099  out:
0100     return ret;
0101  delete:
0102     /* We got an error after creating the event, delete it */
0103     ret = kprobe_event_delete("gen_kprobe_test");
0104  free:
0105     kfree(buf);
0106
0107     goto out;
0108 }
0109
0110 /*
0111  * Test to make sure we can create a kretprobe event.
0112  */
0113 static int __init test_gen_kretprobe_cmd(void)
0114 {
0115     struct dynevent_cmd cmd;
0116     char *buf;
0117     int ret;
0118
0119     /* Create a buffer to hold the generated command */
0120     buf = kzalloc(MAX_DYNEVENT_CMD_LEN, GFP_KERNEL);
0121     if (!buf)
0122         return -ENOMEM;
0123
0124     /* Before generating the command, initialize the cmd object */
0125     kprobe_event_cmd_init(&cmd, buf, MAX_DYNEVENT_CMD_LEN);
0126
0127     /*
0128      * Define the kretprobe event.
0129      */
0130     ret = kretprobe_event_gen_cmd_start(&cmd, "gen_kretprobe_test",
0131                         "do_sys_open",
0132                         "$retval");
0133     if (ret)
0134         goto free;
0135
0136     /*
0137      * This actually creates the event.
0138      */
0139     ret = kretprobe_event_gen_cmd_end(&cmd);
0140     if (ret)
0141         goto free;
0142
0143     /*
0144      * Now get the gen_kretprobe_test event file.  We need to
0145      * prevent the instance and event from disappearing from
0146      * underneath us, which trace_get_event_file() does (though in
0147      * this case we're using the top-level instance which never
0148      * goes away).
0149      */
0150     gen_kretprobe_test = trace_get_event_file(NULL, "kprobes",
0151                           "gen_kretprobe_test");
0152     if (IS_ERR(gen_kretprobe_test)) {
0153         ret = PTR_ERR(gen_kretprobe_test);
0154         goto delete;
0155     }
0156
0157     /* Enable the event or you won't see anything */
0158     ret = trace_array_set_clr_event(gen_kretprobe_test->tr,
0159                     "kprobes", "gen_kretprobe_test", true);
0160     if (ret) {
0161         trace_put_event_file(gen_kretprobe_test);
0162         goto delete;
0163     }
0164  out:
0165     return ret;
0166  delete:
0167     /* We got an error after creating the event, delete it */
0168     ret = kprobe_event_delete("gen_kretprobe_test");
0169  free:
0170     kfree(buf);
0171
0172     goto out;
0173 }
0174
0175 static int __init kprobe_event_gen_test_init(void)
0176 {
0177     int ret;
0178
0179     ret = test_gen_kprobe_cmd();
0180     if (ret)
0181         return ret;
0182
0183     ret = test_gen_kretprobe_cmd();
0184     if (ret) {
0185         WARN_ON(trace_array_set_clr_event(gen_kretprobe_test->tr,
0186                           "kprobes",
0187                           "gen_kretprobe_test", false));
0188         trace_put_event_file(gen_kretprobe_test);
0189         WARN_ON(kprobe_event_delete("gen_kretprobe_test"));
0190     }
0191
0192     return ret;
0193 }
0194
0195 static void __exit kprobe_event_gen_test_exit(void)
0196 {
0197     /* Disable the event or you can't remove it */
0198     WARN_ON(trace_array_set_clr_event(gen_kprobe_test->tr,
0199                       "kprobes",
0200                       "gen_kprobe_test", false));
0201
0202     /* Now give the file and instance back */
0203     trace_put_event_file(gen_kprobe_test);
0204
0205     /* Now unregister and free the event */
0206     WARN_ON(kprobe_event_delete("gen_kprobe_test"));
0207
0208     /* Disable the event or you can't remove it */
0209     WARN_ON(trace_array_set_clr_event(gen_kprobe_test->tr,
0210                       "kprobes",
0211                       "gen_kretprobe_test", false));
0212
0213     /* Now give the file and instance back */
0214     trace_put_event_file(gen_kretprobe_test);
0215
0216     /* Now unregister and free the event */
0217     WARN_ON(kprobe_event_delete("gen_kretprobe_test"));
0218 }
0219
0220 module_init(kprobe_event_gen_test_init)
0221 module_exit(kprobe_event_gen_test_exit)
0222
0223 MODULE_AUTHOR("Tom Zanussi");
0224 MODULE_DESCRIPTION("kprobe event generation test");
0225 MODULE_LICENSE("GPL v2");