Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Here's a sample kernel module showing the use of fprobe to dump a
4 * stack trace and selected registers when kernel_clone() is called.
5 *
6 * For more information on theory of operation of kprobes, see
7 * Documentation/trace/kprobes.rst
8 *
9 * You will see the trace data in /var/log/messages and on the console
10 * whenever kernel_clone() is invoked to create a new process.
11 */
12
13#define pr_fmt(fmt) "%s: " fmt, __func__
14
15#include <linux/kernel.h>
16#include <linux/module.h>
17#include <linux/fprobe.h>
18#include <linux/sched/debug.h>
19#include <linux/slab.h>
20
21#define BACKTRACE_DEPTH 16
22#define MAX_SYMBOL_LEN 4096
23static struct fprobe sample_probe;
24static unsigned long nhit;
25
26static char symbol[MAX_SYMBOL_LEN] = "kernel_clone";
27module_param_string(symbol, symbol, sizeof(symbol), 0644);
28MODULE_PARM_DESC(symbol, "Probed symbol(s), given by comma separated symbols or a wildcard pattern.");
29
30static char nosymbol[MAX_SYMBOL_LEN] = "";
31module_param_string(nosymbol, nosymbol, sizeof(nosymbol), 0644);
32MODULE_PARM_DESC(nosymbol, "Not-probed symbols, given by a wildcard pattern.");
33
34static bool stackdump = true;
35module_param(stackdump, bool, 0644);
36MODULE_PARM_DESC(stackdump, "Enable stackdump.");
37
38static bool use_trace = false;
39module_param(use_trace, bool, 0644);
40MODULE_PARM_DESC(use_trace, "Use trace_printk instead of printk. This is only for debugging.");
41
42static void show_backtrace(void)
43{
44 unsigned long stacks[BACKTRACE_DEPTH];
45 unsigned int len;
46
47 len = stack_trace_save(stacks, BACKTRACE_DEPTH, 2);
48 stack_trace_print(stacks, len, 24);
49}
50
51static int sample_entry_handler(struct fprobe *fp, unsigned long ip,
52 unsigned long ret_ip,
53 struct pt_regs *regs, void *data)
54{
55 if (use_trace)
56 /*
57 * This is just an example, no kernel code should call
58 * trace_printk() except when actively debugging.
59 */
60 trace_printk("Enter <%pS> ip = 0x%p\n", (void *)ip, (void *)ip);
61 else
62 pr_info("Enter <%pS> ip = 0x%p\n", (void *)ip, (void *)ip);
63 nhit++;
64 if (stackdump)
65 show_backtrace();
66 return 0;
67}
68
69static void sample_exit_handler(struct fprobe *fp, unsigned long ip,
70 unsigned long ret_ip, struct pt_regs *regs,
71 void *data)
72{
73 unsigned long rip = ret_ip;
74
75 if (use_trace)
76 /*
77 * This is just an example, no kernel code should call
78 * trace_printk() except when actively debugging.
79 */
80 trace_printk("Return from <%pS> ip = 0x%p to rip = 0x%p (%pS)\n",
81 (void *)ip, (void *)ip, (void *)rip, (void *)rip);
82 else
83 pr_info("Return from <%pS> ip = 0x%p to rip = 0x%p (%pS)\n",
84 (void *)ip, (void *)ip, (void *)rip, (void *)rip);
85 nhit++;
86 if (stackdump)
87 show_backtrace();
88}
89
90static int __init fprobe_init(void)
91{
92 char *p, *symbuf = NULL;
93 const char **syms;
94 int ret, count, i;
95
96 sample_probe.entry_handler = sample_entry_handler;
97 sample_probe.exit_handler = sample_exit_handler;
98
99 if (strchr(symbol, '*')) {
100 /* filter based fprobe */
101 ret = register_fprobe(&sample_probe, symbol,
102 nosymbol[0] == '\0' ? NULL : nosymbol);
103 goto out;
104 } else if (!strchr(symbol, ',')) {
105 symbuf = symbol;
106 ret = register_fprobe_syms(&sample_probe, (const char **)&symbuf, 1);
107 goto out;
108 }
109
110 /* Comma separated symbols */
111 symbuf = kstrdup(symbol, GFP_KERNEL);
112 if (!symbuf)
113 return -ENOMEM;
114 p = symbuf;
115 count = 1;
116 while ((p = strchr(++p, ',')) != NULL)
117 count++;
118
119 pr_info("%d symbols found\n", count);
120
121 syms = kcalloc(count, sizeof(char *), GFP_KERNEL);
122 if (!syms) {
123 kfree(symbuf);
124 return -ENOMEM;
125 }
126
127 p = symbuf;
128 for (i = 0; i < count; i++)
129 syms[i] = strsep(&p, ",");
130
131 ret = register_fprobe_syms(&sample_probe, syms, count);
132 kfree(syms);
133 kfree(symbuf);
134out:
135 if (ret < 0)
136 pr_err("register_fprobe failed, returned %d\n", ret);
137 else
138 pr_info("Planted fprobe at %s\n", symbol);
139
140 return ret;
141}
142
143static void __exit fprobe_exit(void)
144{
145 unregister_fprobe(&sample_probe);
146
147 pr_info("fprobe at %s unregistered. %ld times hit, %ld times missed\n",
148 symbol, nhit, sample_probe.nmissed);
149}
150
151module_init(fprobe_init)
152module_exit(fprobe_exit)
153MODULE_LICENSE("GPL");
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Here's a sample kernel module showing the use of fprobe to dump a
4 * stack trace and selected registers when kernel_clone() is called.
5 *
6 * For more information on theory of operation of kprobes, see
7 * Documentation/trace/kprobes.rst
8 *
9 * You will see the trace data in /var/log/messages and on the console
10 * whenever kernel_clone() is invoked to create a new process.
11 */
12
13#define pr_fmt(fmt) "%s: " fmt, __func__
14
15#include <linux/kernel.h>
16#include <linux/module.h>
17#include <linux/fprobe.h>
18#include <linux/sched/debug.h>
19#include <linux/slab.h>
20
21#define BACKTRACE_DEPTH 16
22#define MAX_SYMBOL_LEN 4096
23static struct fprobe sample_probe;
24static unsigned long nhit;
25
26static char symbol[MAX_SYMBOL_LEN] = "kernel_clone";
27module_param_string(symbol, symbol, sizeof(symbol), 0644);
28MODULE_PARM_DESC(symbol, "Probed symbol(s), given by comma separated symbols or a wildcard pattern.");
29
30static char nosymbol[MAX_SYMBOL_LEN] = "";
31module_param_string(nosymbol, nosymbol, sizeof(nosymbol), 0644);
32MODULE_PARM_DESC(nosymbol, "Not-probed symbols, given by a wildcard pattern.");
33
34static bool stackdump = true;
35module_param(stackdump, bool, 0644);
36MODULE_PARM_DESC(stackdump, "Enable stackdump.");
37
38static bool use_trace = false;
39module_param(use_trace, bool, 0644);
40MODULE_PARM_DESC(use_trace, "Use trace_printk instead of printk. This is only for debugging.");
41
42static void show_backtrace(void)
43{
44 unsigned long stacks[BACKTRACE_DEPTH];
45 unsigned int len;
46
47 len = stack_trace_save(stacks, BACKTRACE_DEPTH, 2);
48 stack_trace_print(stacks, len, 24);
49}
50
51static void sample_entry_handler(struct fprobe *fp, unsigned long ip, struct pt_regs *regs)
52{
53 if (use_trace)
54 /*
55 * This is just an example, no kernel code should call
56 * trace_printk() except when actively debugging.
57 */
58 trace_printk("Enter <%pS> ip = 0x%p\n", (void *)ip, (void *)ip);
59 else
60 pr_info("Enter <%pS> ip = 0x%p\n", (void *)ip, (void *)ip);
61 nhit++;
62 if (stackdump)
63 show_backtrace();
64}
65
66static void sample_exit_handler(struct fprobe *fp, unsigned long ip, struct pt_regs *regs)
67{
68 unsigned long rip = instruction_pointer(regs);
69
70 if (use_trace)
71 /*
72 * This is just an example, no kernel code should call
73 * trace_printk() except when actively debugging.
74 */
75 trace_printk("Return from <%pS> ip = 0x%p to rip = 0x%p (%pS)\n",
76 (void *)ip, (void *)ip, (void *)rip, (void *)rip);
77 else
78 pr_info("Return from <%pS> ip = 0x%p to rip = 0x%p (%pS)\n",
79 (void *)ip, (void *)ip, (void *)rip, (void *)rip);
80 nhit++;
81 if (stackdump)
82 show_backtrace();
83}
84
85static int __init fprobe_init(void)
86{
87 char *p, *symbuf = NULL;
88 const char **syms;
89 int ret, count, i;
90
91 sample_probe.entry_handler = sample_entry_handler;
92 sample_probe.exit_handler = sample_exit_handler;
93
94 if (strchr(symbol, '*')) {
95 /* filter based fprobe */
96 ret = register_fprobe(&sample_probe, symbol,
97 nosymbol[0] == '\0' ? NULL : nosymbol);
98 goto out;
99 } else if (!strchr(symbol, ',')) {
100 symbuf = symbol;
101 ret = register_fprobe_syms(&sample_probe, (const char **)&symbuf, 1);
102 goto out;
103 }
104
105 /* Comma separated symbols */
106 symbuf = kstrdup(symbol, GFP_KERNEL);
107 if (!symbuf)
108 return -ENOMEM;
109 p = symbuf;
110 count = 1;
111 while ((p = strchr(++p, ',')) != NULL)
112 count++;
113
114 pr_info("%d symbols found\n", count);
115
116 syms = kcalloc(count, sizeof(char *), GFP_KERNEL);
117 if (!syms) {
118 kfree(symbuf);
119 return -ENOMEM;
120 }
121
122 p = symbuf;
123 for (i = 0; i < count; i++)
124 syms[i] = strsep(&p, ",");
125
126 ret = register_fprobe_syms(&sample_probe, syms, count);
127 kfree(syms);
128 kfree(symbuf);
129out:
130 if (ret < 0)
131 pr_err("register_fprobe failed, returned %d\n", ret);
132 else
133 pr_info("Planted fprobe at %s\n", symbol);
134
135 return ret;
136}
137
138static void __exit fprobe_exit(void)
139{
140 unregister_fprobe(&sample_probe);
141
142 pr_info("fprobe at %s unregistered. %ld times hit, %ld times missed\n",
143 symbol, nhit, sample_probe.nmissed);
144}
145
146module_init(fprobe_init)
147module_exit(fprobe_exit)
148MODULE_LICENSE("GPL");