Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * Kprobes-based tracing events
4 : : *
5 : : * Created by Masami Hiramatsu <mhiramat@redhat.com>
6 : : *
7 : : */
8 : : #define pr_fmt(fmt) "trace_kprobe: " fmt
9 : :
10 : : #include <linux/security.h>
11 : : #include <linux/module.h>
12 : : #include <linux/uaccess.h>
13 : : #include <linux/rculist.h>
14 : : #include <linux/error-injection.h>
15 : :
16 : : #include <asm/setup.h> /* for COMMAND_LINE_SIZE */
17 : :
18 : : #include "trace_dynevent.h"
19 : : #include "trace_kprobe_selftest.h"
20 : : #include "trace_probe.h"
21 : : #include "trace_probe_tmpl.h"
22 : :
23 : : #define KPROBE_EVENT_SYSTEM "kprobes"
24 : : #define KRETPROBE_MAXACTIVE_MAX 4096
25 : :
26 : : /* Kprobe early definition from command line */
27 : : static char kprobe_boot_events_buf[COMMAND_LINE_SIZE] __initdata;
28 : : static bool kprobe_boot_events_enabled __initdata;
29 : :
30 : 0 : static int __init set_kprobe_boot_events(char *str)
31 : : {
32 : 0 : strlcpy(kprobe_boot_events_buf, str, COMMAND_LINE_SIZE);
33 : 0 : return 0;
34 : : }
35 : : __setup("kprobe_event=", set_kprobe_boot_events);
36 : :
37 : : static int trace_kprobe_create(int argc, const char **argv);
38 : : static int trace_kprobe_show(struct seq_file *m, struct dyn_event *ev);
39 : : static int trace_kprobe_release(struct dyn_event *ev);
40 : : static bool trace_kprobe_is_busy(struct dyn_event *ev);
41 : : static bool trace_kprobe_match(const char *system, const char *event,
42 : : int argc, const char **argv, struct dyn_event *ev);
43 : :
44 : : static struct dyn_event_operations trace_kprobe_ops = {
45 : : .create = trace_kprobe_create,
46 : : .show = trace_kprobe_show,
47 : : .is_busy = trace_kprobe_is_busy,
48 : : .free = trace_kprobe_release,
49 : : .match = trace_kprobe_match,
50 : : };
51 : :
52 : : /*
53 : : * Kprobe event core functions
54 : : */
55 : : struct trace_kprobe {
56 : : struct dyn_event devent;
57 : : struct kretprobe rp; /* Use rp.kp for kprobe use */
58 : : unsigned long __percpu *nhit;
59 : : const char *symbol; /* symbol name */
60 : : struct trace_probe tp;
61 : : };
62 : :
63 : 0 : static bool is_trace_kprobe(struct dyn_event *ev)
64 : : {
65 : 0 : return ev->ops == &trace_kprobe_ops;
66 : : }
67 : :
68 : 0 : static struct trace_kprobe *to_trace_kprobe(struct dyn_event *ev)
69 : : {
70 : 0 : return container_of(ev, struct trace_kprobe, devent);
71 : : }
72 : :
73 : : /**
74 : : * for_each_trace_kprobe - iterate over the trace_kprobe list
75 : : * @pos: the struct trace_kprobe * for each entry
76 : : * @dpos: the struct dyn_event * to use as a loop cursor
77 : : */
78 : : #define for_each_trace_kprobe(pos, dpos) \
79 : : for_each_dyn_event(dpos) \
80 : : if (is_trace_kprobe(dpos) && (pos = to_trace_kprobe(dpos)))
81 : :
82 : : #define SIZEOF_TRACE_KPROBE(n) \
83 : : (offsetof(struct trace_kprobe, tp.args) + \
84 : : (sizeof(struct probe_arg) * (n)))
85 : :
86 : 0 : static nokprobe_inline bool trace_kprobe_is_return(struct trace_kprobe *tk)
87 : : {
88 : 0 : return tk->rp.handler != NULL;
89 : : }
90 : :
91 : 0 : static nokprobe_inline const char *trace_kprobe_symbol(struct trace_kprobe *tk)
92 : : {
93 [ # # ]: 0 : return tk->symbol ? tk->symbol : "unknown";
94 : : }
95 : :
96 : 0 : static nokprobe_inline unsigned long trace_kprobe_offset(struct trace_kprobe *tk)
97 : : {
98 : 0 : return tk->rp.kp.offset;
99 : : }
100 : :
101 : 0 : static nokprobe_inline bool trace_kprobe_has_gone(struct trace_kprobe *tk)
102 : : {
103 [ # # ]: 0 : return !!(kprobe_gone(&tk->rp.kp));
104 : : }
105 : :
106 : 0 : static nokprobe_inline bool trace_kprobe_within_module(struct trace_kprobe *tk,
107 : : struct module *mod)
108 : : {
109 : 0 : int len = strlen(mod->name);
110 : 0 : const char *name = trace_kprobe_symbol(tk);
111 [ # # # # ]: 0 : return strncmp(mod->name, name, len) == 0 && name[len] == ':';
112 : : }
113 : :
114 : 0 : static nokprobe_inline bool trace_kprobe_module_exist(struct trace_kprobe *tk)
115 : : {
116 : 0 : char *p;
117 : 0 : bool ret;
118 : :
119 [ # # # # ]: 0 : if (!tk->symbol)
120 : : return false;
121 : 0 : p = strchr(tk->symbol, ':');
122 [ # # # # ]: 0 : if (!p)
123 : : return true;
124 : 0 : *p = '\0';
125 : 0 : mutex_lock(&module_mutex);
126 : 0 : ret = !!find_module(tk->symbol);
127 : 0 : mutex_unlock(&module_mutex);
128 : 0 : *p = ':';
129 : :
130 : 0 : return ret;
131 : : }
132 : :
133 : 0 : static bool trace_kprobe_is_busy(struct dyn_event *ev)
134 : : {
135 : 0 : struct trace_kprobe *tk = to_trace_kprobe(ev);
136 : :
137 : 0 : return trace_probe_is_enabled(&tk->tp);
138 : : }
139 : :
140 : 0 : static bool trace_kprobe_match_command_head(struct trace_kprobe *tk,
141 : : int argc, const char **argv)
142 : : {
143 : 0 : char buf[MAX_ARGSTR_LEN + 1];
144 : :
145 [ # # ]: 0 : if (!argc)
146 : : return true;
147 : :
148 [ # # ]: 0 : if (!tk->symbol)
149 : 0 : snprintf(buf, sizeof(buf), "0x%p", tk->rp.kp.addr);
150 [ # # ]: 0 : else if (tk->rp.kp.offset)
151 : 0 : snprintf(buf, sizeof(buf), "%s+%u",
152 : : trace_kprobe_symbol(tk), tk->rp.kp.offset);
153 : : else
154 : 0 : snprintf(buf, sizeof(buf), "%s", trace_kprobe_symbol(tk));
155 [ # # ]: 0 : if (strcmp(buf, argv[0]))
156 : : return false;
157 : 0 : argc--; argv++;
158 : :
159 : 0 : return trace_probe_match_command_args(&tk->tp, argc, argv);
160 : : }
161 : :
162 : 0 : static bool trace_kprobe_match(const char *system, const char *event,
163 : : int argc, const char **argv, struct dyn_event *ev)
164 : : {
165 : 0 : struct trace_kprobe *tk = to_trace_kprobe(ev);
166 : :
167 [ # # # # ]: 0 : return strcmp(trace_probe_name(&tk->tp), event) == 0 &&
168 [ # # # # : 0 : (!system || strcmp(trace_probe_group_name(&tk->tp), system) == 0) &&
# # ]
169 : 0 : trace_kprobe_match_command_head(tk, argc, argv);
170 : : }
171 : :
172 : 0 : static nokprobe_inline unsigned long trace_kprobe_nhit(struct trace_kprobe *tk)
173 : : {
174 : : unsigned long nhit = 0;
175 : : int cpu;
176 : :
177 [ # # ]: 0 : for_each_possible_cpu(cpu)
178 : 0 : nhit += *per_cpu_ptr(tk->nhit, cpu);
179 : :
180 [ # # ]: 0 : return nhit;
181 : : }
182 : :
183 : 0 : static nokprobe_inline bool trace_kprobe_is_registered(struct trace_kprobe *tk)
184 : : {
185 [ # # # # : 0 : return !(list_empty(&tk->rp.kp.list) &&
# # # # ]
186 [ # # # # : 0 : hlist_unhashed(&tk->rp.kp.hlist));
# # # # ]
187 : : }
188 : :
189 : : /* Return 0 if it fails to find the symbol address */
190 : : static nokprobe_inline
191 : 0 : unsigned long trace_kprobe_address(struct trace_kprobe *tk)
192 : : {
193 : 0 : unsigned long addr;
194 : :
195 [ # # ]: 0 : if (tk->symbol) {
196 : 0 : addr = (unsigned long)
197 : : kallsyms_lookup_name(trace_kprobe_symbol(tk));
198 [ # # ]: 0 : if (addr)
199 : 0 : addr += tk->rp.kp.offset;
200 : : } else {
201 : 0 : addr = (unsigned long)tk->rp.kp.addr;
202 : : }
203 : 0 : return addr;
204 : : }
205 : :
206 : : static nokprobe_inline struct trace_kprobe *
207 : 0 : trace_kprobe_primary_from_call(struct trace_event_call *call)
208 : : {
209 : 0 : struct trace_probe *tp;
210 : :
211 : 0 : tp = trace_probe_primary_from_call(call);
212 [ # # # # : 0 : if (WARN_ON_ONCE(!tp))
# # # # #
# # # ]
213 : : return NULL;
214 : :
215 : 0 : return container_of(tp, struct trace_kprobe, tp);
216 : : }
217 : :
218 : 0 : bool trace_kprobe_on_func_entry(struct trace_event_call *call)
219 : : {
220 [ # # ]: 0 : struct trace_kprobe *tk = trace_kprobe_primary_from_call(call);
221 : :
222 [ # # ]: 0 : return tk ? kprobe_on_func_entry(tk->rp.kp.addr,
223 : : tk->rp.kp.addr ? NULL : tk->rp.kp.symbol_name,
224 [ # # # # : 0 : tk->rp.kp.addr ? 0 : tk->rp.kp.offset) : false;
# # ]
225 : : }
226 : :
227 : 0 : bool trace_kprobe_error_injectable(struct trace_event_call *call)
228 : : {
229 [ # # ]: 0 : struct trace_kprobe *tk = trace_kprobe_primary_from_call(call);
230 : :
231 [ # # # # ]: 0 : return tk ? within_error_injection_list(trace_kprobe_address(tk)) :
232 : : false;
233 : : }
234 : :
235 : : static int register_kprobe_event(struct trace_kprobe *tk);
236 : : static int unregister_kprobe_event(struct trace_kprobe *tk);
237 : :
238 : : static int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs);
239 : : static int kretprobe_dispatcher(struct kretprobe_instance *ri,
240 : : struct pt_regs *regs);
241 : :
242 : 0 : static void free_trace_kprobe(struct trace_kprobe *tk)
243 : : {
244 [ # # ]: 0 : if (tk) {
245 : 0 : trace_probe_cleanup(&tk->tp);
246 : 0 : kfree(tk->symbol);
247 : 0 : free_percpu(tk->nhit);
248 : 0 : kfree(tk);
249 : : }
250 : 0 : }
251 : :
252 : : /*
253 : : * Allocate new trace_probe and initialize it (including kprobes).
254 : : */
255 : 0 : static struct trace_kprobe *alloc_trace_kprobe(const char *group,
256 : : const char *event,
257 : : void *addr,
258 : : const char *symbol,
259 : : unsigned long offs,
260 : : int maxactive,
261 : : int nargs, bool is_return)
262 : : {
263 : 0 : struct trace_kprobe *tk;
264 : 0 : int ret = -ENOMEM;
265 : :
266 : 0 : tk = kzalloc(SIZEOF_TRACE_KPROBE(nargs), GFP_KERNEL);
267 [ # # ]: 0 : if (!tk)
268 : : return ERR_PTR(ret);
269 : :
270 : 0 : tk->nhit = alloc_percpu(unsigned long);
271 [ # # ]: 0 : if (!tk->nhit)
272 : 0 : goto error;
273 : :
274 [ # # ]: 0 : if (symbol) {
275 : 0 : tk->symbol = kstrdup(symbol, GFP_KERNEL);
276 [ # # ]: 0 : if (!tk->symbol)
277 : 0 : goto error;
278 : 0 : tk->rp.kp.symbol_name = tk->symbol;
279 : 0 : tk->rp.kp.offset = offs;
280 : : } else
281 : 0 : tk->rp.kp.addr = addr;
282 : :
283 [ # # ]: 0 : if (is_return)
284 : 0 : tk->rp.handler = kretprobe_dispatcher;
285 : : else
286 : 0 : tk->rp.kp.pre_handler = kprobe_dispatcher;
287 : :
288 : 0 : tk->rp.maxactive = maxactive;
289 : 0 : INIT_HLIST_NODE(&tk->rp.kp.hlist);
290 : 0 : INIT_LIST_HEAD(&tk->rp.kp.list);
291 : :
292 : 0 : ret = trace_probe_init(&tk->tp, event, group, false);
293 [ # # ]: 0 : if (ret < 0)
294 : 0 : goto error;
295 : :
296 : 0 : dyn_event_init(&tk->devent, &trace_kprobe_ops);
297 : 0 : return tk;
298 : 0 : error:
299 : 0 : free_trace_kprobe(tk);
300 : 0 : return ERR_PTR(ret);
301 : : }
302 : :
303 : 0 : static struct trace_kprobe *find_trace_kprobe(const char *event,
304 : : const char *group)
305 : : {
306 : 0 : struct dyn_event *pos;
307 : 0 : struct trace_kprobe *tk;
308 : :
309 [ # # # # : 0 : for_each_trace_kprobe(tk, pos)
# # ]
310 [ # # # # ]: 0 : if (strcmp(trace_probe_name(&tk->tp), event) == 0 &&
311 [ # # ]: 0 : strcmp(trace_probe_group_name(&tk->tp), group) == 0)
312 : 0 : return tk;
313 : : return NULL;
314 : : }
315 : :
316 : 0 : static inline int __enable_trace_kprobe(struct trace_kprobe *tk)
317 : : {
318 : 0 : int ret = 0;
319 : :
320 [ # # # # : 0 : if (trace_kprobe_is_registered(tk) && !trace_kprobe_has_gone(tk)) {
# # ]
321 [ # # ]: 0 : if (trace_kprobe_is_return(tk))
322 : 0 : ret = enable_kretprobe(&tk->rp);
323 : : else
324 : 0 : ret = enable_kprobe(&tk->rp.kp);
325 : : }
326 : :
327 : 0 : return ret;
328 : : }
329 : :
330 : 0 : static void __disable_trace_kprobe(struct trace_probe *tp)
331 : : {
332 : 0 : struct trace_probe *pos;
333 : 0 : struct trace_kprobe *tk;
334 : :
335 [ # # ]: 0 : list_for_each_entry(pos, trace_probe_probe_list(tp), list) {
336 : 0 : tk = container_of(pos, struct trace_kprobe, tp);
337 [ # # # # ]: 0 : if (!trace_kprobe_is_registered(tk))
338 : 0 : continue;
339 [ # # ]: 0 : if (trace_kprobe_is_return(tk))
340 : 0 : disable_kretprobe(&tk->rp);
341 : : else
342 : 0 : disable_kprobe(&tk->rp.kp);
343 : : }
344 : 0 : }
345 : :
346 : : /*
347 : : * Enable trace_probe
348 : : * if the file is NULL, enable "perf" handler, or enable "trace" handler.
349 : : */
350 : 0 : static int enable_trace_kprobe(struct trace_event_call *call,
351 : : struct trace_event_file *file)
352 : : {
353 : 0 : struct trace_probe *pos, *tp;
354 : 0 : struct trace_kprobe *tk;
355 : 0 : bool enabled;
356 : 0 : int ret = 0;
357 : :
358 [ # # ]: 0 : tp = trace_probe_primary_from_call(call);
359 [ # # # # ]: 0 : if (WARN_ON_ONCE(!tp))
360 : : return -ENODEV;
361 [ # # ]: 0 : enabled = trace_probe_is_enabled(tp);
362 : :
363 : : /* This also changes "enabled" state */
364 [ # # ]: 0 : if (file) {
365 : 0 : ret = trace_probe_add_file(tp, file);
366 [ # # ]: 0 : if (ret)
367 : : return ret;
368 : : } else
369 : 0 : trace_probe_set_flag(tp, TP_FLAG_PROFILE);
370 : :
371 [ # # ]: 0 : if (enabled)
372 : : return 0;
373 : :
374 [ # # ]: 0 : list_for_each_entry(pos, trace_probe_probe_list(tp), list) {
375 : 0 : tk = container_of(pos, struct trace_kprobe, tp);
376 [ # # ]: 0 : if (trace_kprobe_has_gone(tk))
377 : 0 : continue;
378 : 0 : ret = __enable_trace_kprobe(tk);
379 [ # # ]: 0 : if (ret)
380 : : break;
381 : : enabled = true;
382 : : }
383 : :
384 [ # # ]: 0 : if (ret) {
385 : : /* Failed to enable one of them. Roll back all */
386 [ # # ]: 0 : if (enabled)
387 : 0 : __disable_trace_kprobe(tp);
388 [ # # ]: 0 : if (file)
389 : 0 : trace_probe_remove_file(tp, file);
390 : : else
391 : 0 : trace_probe_clear_flag(tp, TP_FLAG_PROFILE);
392 : : }
393 : :
394 : : return ret;
395 : : }
396 : :
397 : : /*
398 : : * Disable trace_probe
399 : : * if the file is NULL, disable "perf" handler, or disable "trace" handler.
400 : : */
401 : 0 : static int disable_trace_kprobe(struct trace_event_call *call,
402 : : struct trace_event_file *file)
403 : : {
404 : 0 : struct trace_probe *tp;
405 : :
406 [ # # ]: 0 : tp = trace_probe_primary_from_call(call);
407 [ # # # # ]: 0 : if (WARN_ON_ONCE(!tp))
408 : : return -ENODEV;
409 : :
410 [ # # ]: 0 : if (file) {
411 [ # # ]: 0 : if (!trace_probe_get_file_link(tp, file))
412 : : return -ENOENT;
413 [ # # # # ]: 0 : if (!trace_probe_has_single_file(tp))
414 : 0 : goto out;
415 : 0 : trace_probe_clear_flag(tp, TP_FLAG_TRACE);
416 : : } else
417 : 0 : trace_probe_clear_flag(tp, TP_FLAG_PROFILE);
418 : :
419 [ # # ]: 0 : if (!trace_probe_is_enabled(tp))
420 : 0 : __disable_trace_kprobe(tp);
421 : :
422 : 0 : out:
423 [ # # ]: 0 : if (file)
424 : : /*
425 : : * Synchronization is done in below function. For perf event,
426 : : * file == NULL and perf_trace_event_unreg() calls
427 : : * tracepoint_synchronize_unregister() to ensure synchronize
428 : : * event. We don't need to care about it.
429 : : */
430 : 0 : trace_probe_remove_file(tp, file);
431 : :
432 : : return 0;
433 : : }
434 : :
435 : : #if defined(CONFIG_KPROBES_ON_FTRACE) && \
436 : : !defined(CONFIG_KPROBE_EVENTS_ON_NOTRACE)
437 : : static bool __within_notrace_func(unsigned long addr)
438 : : {
439 : : unsigned long offset, size;
440 : :
441 : : if (!addr || !kallsyms_lookup_size_offset(addr, &size, &offset))
442 : : return false;
443 : :
444 : : /* Get the entry address of the target function */
445 : : addr -= offset;
446 : :
447 : : /*
448 : : * Since ftrace_location_range() does inclusive range check, we need
449 : : * to subtract 1 byte from the end address.
450 : : */
451 : : return !ftrace_location_range(addr, addr + size - 1);
452 : : }
453 : :
454 : : static bool within_notrace_func(struct trace_kprobe *tk)
455 : : {
456 : : unsigned long addr = addr = trace_kprobe_address(tk);
457 : : char symname[KSYM_NAME_LEN], *p;
458 : :
459 : : if (!__within_notrace_func(addr))
460 : : return false;
461 : :
462 : : /* Check if the address is on a suffixed-symbol */
463 : : if (!lookup_symbol_name(addr, symname)) {
464 : : p = strchr(symname, '.');
465 : : if (!p)
466 : : return true;
467 : : *p = '\0';
468 : : addr = (unsigned long)kprobe_lookup_name(symname, 0);
469 : : if (addr)
470 : : return __within_notrace_func(addr);
471 : : }
472 : :
473 : : return true;
474 : : }
475 : : #else
476 : : #define within_notrace_func(tk) (false)
477 : : #endif
478 : :
479 : : /* Internal register function - just handle k*probes and flags */
480 : 0 : static int __register_trace_kprobe(struct trace_kprobe *tk)
481 : : {
482 : 0 : int i, ret;
483 : :
484 : 0 : ret = security_locked_down(LOCKDOWN_KPROBES);
485 [ # # ]: 0 : if (ret)
486 : : return ret;
487 : :
488 [ # # # # ]: 0 : if (trace_kprobe_is_registered(tk))
489 : : return -EINVAL;
490 : :
491 : : if (within_notrace_func(tk)) {
492 : : pr_warn("Could not probe notrace function %s\n",
493 : : trace_kprobe_symbol(tk));
494 : : return -EINVAL;
495 : : }
496 : :
497 [ # # ]: 0 : for (i = 0; i < tk->tp.nr_args; i++) {
498 : 0 : ret = traceprobe_update_arg(&tk->tp.args[i]);
499 [ # # ]: 0 : if (ret)
500 : 0 : return ret;
501 : : }
502 : :
503 : : /* Set/clear disabled flag according to tp->flag */
504 [ # # ]: 0 : if (trace_probe_is_enabled(&tk->tp))
505 : 0 : tk->rp.kp.flags &= ~KPROBE_FLAG_DISABLED;
506 : : else
507 : 0 : tk->rp.kp.flags |= KPROBE_FLAG_DISABLED;
508 : :
509 [ # # ]: 0 : if (trace_kprobe_is_return(tk))
510 : 0 : ret = register_kretprobe(&tk->rp);
511 : : else
512 : 0 : ret = register_kprobe(&tk->rp.kp);
513 : :
514 : : return ret;
515 : : }
516 : :
517 : : /* Internal unregister function - just handle k*probes and flags */
518 : 0 : static void __unregister_trace_kprobe(struct trace_kprobe *tk)
519 : : {
520 [ # # # # ]: 0 : if (trace_kprobe_is_registered(tk)) {
521 [ # # ]: 0 : if (trace_kprobe_is_return(tk))
522 : 0 : unregister_kretprobe(&tk->rp);
523 : : else
524 : 0 : unregister_kprobe(&tk->rp.kp);
525 : : /* Cleanup kprobe for reuse and mark it unregistered */
526 [ # # ]: 0 : INIT_HLIST_NODE(&tk->rp.kp.hlist);
527 [ # # ]: 0 : INIT_LIST_HEAD(&tk->rp.kp.list);
528 [ # # ]: 0 : if (tk->rp.kp.symbol_name)
529 : 0 : tk->rp.kp.addr = NULL;
530 : : }
531 : 0 : }
532 : :
533 : : /* Unregister a trace_probe and probe_event */
534 : 0 : static int unregister_trace_kprobe(struct trace_kprobe *tk)
535 : : {
536 : : /* If other probes are on the event, just unregister kprobe */
537 [ # # # # ]: 0 : if (trace_probe_has_sibling(&tk->tp))
538 : 0 : goto unreg;
539 : :
540 : : /* Enabled event can not be unregistered */
541 [ # # ]: 0 : if (trace_probe_is_enabled(&tk->tp))
542 : : return -EBUSY;
543 : :
544 : : /* Will fail if probe is being used by ftrace or perf */
545 [ # # ]: 0 : if (unregister_kprobe_event(tk))
546 : : return -EBUSY;
547 : :
548 : 0 : unreg:
549 : 0 : __unregister_trace_kprobe(tk);
550 : 0 : dyn_event_remove(&tk->devent);
551 : 0 : trace_probe_unlink(&tk->tp);
552 : :
553 : 0 : return 0;
554 : : }
555 : :
556 : 0 : static bool trace_kprobe_has_same_kprobe(struct trace_kprobe *orig,
557 : : struct trace_kprobe *comp)
558 : : {
559 : 0 : struct trace_probe_event *tpe = orig->tp.event;
560 : 0 : struct trace_probe *pos;
561 : 0 : int i;
562 : :
563 [ # # ]: 0 : list_for_each_entry(pos, &tpe->probes, list) {
564 : 0 : orig = container_of(pos, struct trace_kprobe, tp);
565 [ # # # # ]: 0 : if (strcmp(trace_kprobe_symbol(orig),
566 [ # # ]: 0 : trace_kprobe_symbol(comp)) ||
567 : : trace_kprobe_offset(orig) != trace_kprobe_offset(comp))
568 : 0 : continue;
569 : :
570 : : /*
571 : : * trace_probe_compare_arg_type() ensured that nr_args and
572 : : * each argument name and type are same. Let's compare comm.
573 : : */
574 [ # # ]: 0 : for (i = 0; i < orig->tp.nr_args; i++) {
575 [ # # ]: 0 : if (strcmp(orig->tp.args[i].comm,
576 : : comp->tp.args[i].comm))
577 : : break;
578 : : }
579 : :
580 [ # # ]: 0 : if (i == orig->tp.nr_args)
581 : : return true;
582 : : }
583 : :
584 : : return false;
585 : : }
586 : :
587 : 0 : static int append_trace_kprobe(struct trace_kprobe *tk, struct trace_kprobe *to)
588 : : {
589 : 0 : int ret;
590 : :
591 : 0 : ret = trace_probe_compare_arg_type(&tk->tp, &to->tp);
592 [ # # ]: 0 : if (ret) {
593 : : /* Note that argument starts index = 2 */
594 : 0 : trace_probe_log_set_index(ret + 1);
595 : 0 : trace_probe_log_err(0, DIFF_ARG_TYPE);
596 : 0 : return -EEXIST;
597 : : }
598 [ # # ]: 0 : if (trace_kprobe_has_same_kprobe(to, tk)) {
599 : 0 : trace_probe_log_set_index(0);
600 : 0 : trace_probe_log_err(0, SAME_PROBE);
601 : 0 : return -EEXIST;
602 : : }
603 : :
604 : : /* Append to existing event */
605 : 0 : ret = trace_probe_append(&tk->tp, &to->tp);
606 [ # # ]: 0 : if (ret)
607 : : return ret;
608 : :
609 : : /* Register k*probe */
610 : 0 : ret = __register_trace_kprobe(tk);
611 [ # # # # ]: 0 : if (ret == -ENOENT && !trace_kprobe_module_exist(tk)) {
612 : 0 : pr_warn("This probe might be able to register after target module is loaded. Continue.\n");
613 : 0 : ret = 0;
614 : : }
615 : :
616 [ # # ]: 0 : if (ret)
617 : 0 : trace_probe_unlink(&tk->tp);
618 : : else
619 [ # # ]: 0 : dyn_event_add(&tk->devent);
620 : :
621 : : return ret;
622 : : }
623 : :
624 : : /* Register a trace_probe and probe_event */
625 : 0 : static int register_trace_kprobe(struct trace_kprobe *tk)
626 : : {
627 : 0 : struct trace_kprobe *old_tk;
628 : 0 : int ret;
629 : :
630 : 0 : mutex_lock(&event_mutex);
631 : :
632 [ # # ]: 0 : old_tk = find_trace_kprobe(trace_probe_name(&tk->tp),
633 : : trace_probe_group_name(&tk->tp));
634 [ # # ]: 0 : if (old_tk) {
635 [ # # ]: 0 : if (trace_kprobe_is_return(tk) != trace_kprobe_is_return(old_tk)) {
636 : 0 : trace_probe_log_set_index(0);
637 : 0 : trace_probe_log_err(0, DIFF_PROBE_TYPE);
638 : 0 : ret = -EEXIST;
639 : : } else {
640 : 0 : ret = append_trace_kprobe(tk, old_tk);
641 : : }
642 : 0 : goto end;
643 : : }
644 : :
645 : : /* Register new event */
646 : 0 : ret = register_kprobe_event(tk);
647 [ # # ]: 0 : if (ret) {
648 : 0 : pr_warn("Failed to register probe event(%d)\n", ret);
649 : 0 : goto end;
650 : : }
651 : :
652 : : /* Register k*probe */
653 : 0 : ret = __register_trace_kprobe(tk);
654 [ # # # # ]: 0 : if (ret == -ENOENT && !trace_kprobe_module_exist(tk)) {
655 : 0 : pr_warn("This probe might be able to register after target module is loaded. Continue.\n");
656 : 0 : ret = 0;
657 : : }
658 : :
659 [ # # ]: 0 : if (ret < 0)
660 : 0 : unregister_kprobe_event(tk);
661 : : else
662 [ # # ]: 0 : dyn_event_add(&tk->devent);
663 : :
664 : 0 : end:
665 : 0 : mutex_unlock(&event_mutex);
666 : 0 : return ret;
667 : : }
668 : :
669 : : /* Module notifier call back, checking event on the module */
670 : 18 : static int trace_kprobe_module_callback(struct notifier_block *nb,
671 : : unsigned long val, void *data)
672 : : {
673 : 18 : struct module *mod = data;
674 : 18 : struct dyn_event *pos;
675 : 18 : struct trace_kprobe *tk;
676 : 18 : int ret;
677 : :
678 [ + + ]: 18 : if (val != MODULE_STATE_COMING)
679 : : return NOTIFY_DONE;
680 : :
681 : : /* Update probes on coming module */
682 : 9 : mutex_lock(&event_mutex);
683 [ - - - - : 9 : for_each_trace_kprobe(tk, pos) {
- + ]
684 [ # # # # ]: 0 : if (trace_kprobe_within_module(tk, mod)) {
685 : : /* Don't need to check busy - this should have gone. */
686 : 0 : __unregister_trace_kprobe(tk);
687 : 0 : ret = __register_trace_kprobe(tk);
688 [ # # ]: 0 : if (ret)
689 [ # # ]: 0 : pr_warn("Failed to re-register probe %s on %s: %d\n",
690 : : trace_probe_name(&tk->tp),
691 : : mod->name, ret);
692 : : }
693 : : }
694 : 9 : mutex_unlock(&event_mutex);
695 : :
696 : 9 : return NOTIFY_DONE;
697 : : }
698 : :
699 : : static struct notifier_block trace_kprobe_module_nb = {
700 : : .notifier_call = trace_kprobe_module_callback,
701 : : .priority = 1 /* Invoked after kprobe module callback */
702 : : };
703 : :
704 : : /* Convert certain expected symbols into '_' when generating event names */
705 : : static inline void sanitize_event_name(char *name)
706 : : {
707 [ # # ]: 0 : while (*name++ != '\0')
708 [ # # ]: 0 : if (*name == ':' || *name == '.')
709 : 0 : *name = '_';
710 : : }
711 : :
712 : 0 : static int trace_kprobe_create(int argc, const char *argv[])
713 : : {
714 : : /*
715 : : * Argument syntax:
716 : : * - Add kprobe:
717 : : * p[:[GRP/]EVENT] [MOD:]KSYM[+OFFS]|KADDR [FETCHARGS]
718 : : * - Add kretprobe:
719 : : * r[MAXACTIVE][:[GRP/]EVENT] [MOD:]KSYM[+0] [FETCHARGS]
720 : : * Fetch args:
721 : : * $retval : fetch return value
722 : : * $stack : fetch stack address
723 : : * $stackN : fetch Nth of stack (N:0-)
724 : : * $comm : fetch current task comm
725 : : * @ADDR : fetch memory at ADDR (ADDR should be in kernel)
726 : : * @SYM[+|-offs] : fetch memory at SYM +|- offs (SYM is a data symbol)
727 : : * %REG : fetch register REG
728 : : * Dereferencing memory fetch:
729 : : * +|-offs(ARG) : fetch memory at ARG +|- offs address.
730 : : * Alias name of args:
731 : : * NAME=FETCHARG : set NAME as alias of FETCHARG.
732 : : * Type of args:
733 : : * FETCHARG:TYPE : use TYPE instead of unsigned long.
734 : : */
735 : 0 : struct trace_kprobe *tk = NULL;
736 : 0 : int i, len, ret = 0;
737 : 0 : bool is_return = false;
738 : 0 : char *symbol = NULL, *tmp = NULL;
739 : 0 : const char *event = NULL, *group = KPROBE_EVENT_SYSTEM;
740 : 0 : int maxactive = 0;
741 : 0 : long offset = 0;
742 : 0 : void *addr = NULL;
743 : 0 : char buf[MAX_EVENT_NAME_LEN];
744 : 0 : unsigned int flags = TPARG_FL_KERNEL;
745 : :
746 [ # # # ]: 0 : switch (argv[0][0]) {
747 : 0 : case 'r':
748 : 0 : is_return = true;
749 : 0 : flags |= TPARG_FL_RETURN;
750 : 0 : break;
751 : : case 'p':
752 : : break;
753 : : default:
754 : : return -ECANCELED;
755 : : }
756 [ # # ]: 0 : if (argc < 2)
757 : : return -ECANCELED;
758 : :
759 : 0 : trace_probe_log_init("trace_kprobe", argc, argv);
760 : :
761 : 0 : event = strchr(&argv[0][1], ':');
762 [ # # ]: 0 : if (event)
763 : 0 : event++;
764 : :
765 [ # # ]: 0 : if (isdigit(argv[0][1])) {
766 [ # # ]: 0 : if (!is_return) {
767 : 0 : trace_probe_log_err(1, MAXACT_NO_KPROBE);
768 : 0 : goto parse_error;
769 : : }
770 [ # # ]: 0 : if (event)
771 : 0 : len = event - &argv[0][1] - 1;
772 : : else
773 : 0 : len = strlen(&argv[0][1]);
774 [ # # ]: 0 : if (len > MAX_EVENT_NAME_LEN - 1) {
775 : 0 : trace_probe_log_err(1, BAD_MAXACT);
776 : 0 : goto parse_error;
777 : : }
778 : 0 : memcpy(buf, &argv[0][1], len);
779 : 0 : buf[len] = '\0';
780 : 0 : ret = kstrtouint(buf, 0, &maxactive);
781 [ # # # # ]: 0 : if (ret || !maxactive) {
782 : 0 : trace_probe_log_err(1, BAD_MAXACT);
783 : 0 : goto parse_error;
784 : : }
785 : : /* kretprobes instances are iterated over via a list. The
786 : : * maximum should stay reasonable.
787 : : */
788 [ # # ]: 0 : if (maxactive > KRETPROBE_MAXACTIVE_MAX) {
789 : 0 : trace_probe_log_err(1, MAXACT_TOO_BIG);
790 : 0 : goto parse_error;
791 : : }
792 : : }
793 : :
794 : : /* try to parse an address. if that fails, try to read the
795 : : * input as a symbol. */
796 [ # # ]: 0 : if (kstrtoul(argv[1], 0, (unsigned long *)&addr)) {
797 : 0 : trace_probe_log_set_index(1);
798 : : /* Check whether uprobe event specified */
799 [ # # # # ]: 0 : if (strchr(argv[1], '/') && strchr(argv[1], ':')) {
800 : 0 : ret = -ECANCELED;
801 : 0 : goto error;
802 : : }
803 : : /* a symbol specified */
804 : 0 : symbol = kstrdup(argv[1], GFP_KERNEL);
805 [ # # ]: 0 : if (!symbol)
806 : : return -ENOMEM;
807 : : /* TODO: support .init module functions */
808 : 0 : ret = traceprobe_split_symbol_offset(symbol, &offset);
809 [ # # # # : 0 : if (ret || offset < 0 || offset > UINT_MAX) {
# # ]
810 : 0 : trace_probe_log_err(0, BAD_PROBE_ADDR);
811 : 0 : goto parse_error;
812 : : }
813 [ # # ]: 0 : if (kprobe_on_func_entry(NULL, symbol, offset))
814 : 0 : flags |= TPARG_FL_FENTRY;
815 [ # # # # : 0 : if (offset && is_return && !(flags & TPARG_FL_FENTRY)) {
# # ]
816 : 0 : trace_probe_log_err(0, BAD_RETPROBE);
817 : 0 : goto parse_error;
818 : : }
819 : : }
820 : :
821 : 0 : trace_probe_log_set_index(0);
822 [ # # ]: 0 : if (event) {
823 : 0 : ret = traceprobe_parse_event_name(&event, &group, buf,
824 : 0 : event - argv[0]);
825 [ # # ]: 0 : if (ret)
826 : 0 : goto parse_error;
827 : : } else {
828 : : /* Make a new event name */
829 [ # # ]: 0 : if (symbol)
830 [ # # ]: 0 : snprintf(buf, MAX_EVENT_NAME_LEN, "%c_%s_%ld",
831 : : is_return ? 'r' : 'p', symbol, offset);
832 : : else
833 [ # # ]: 0 : snprintf(buf, MAX_EVENT_NAME_LEN, "%c_0x%p",
834 : : is_return ? 'r' : 'p', addr);
835 : : sanitize_event_name(buf);
836 : 0 : event = buf;
837 : : }
838 : :
839 : : /* setup a probe */
840 : 0 : tk = alloc_trace_kprobe(group, event, addr, symbol, offset, maxactive,
841 : : argc - 2, is_return);
842 [ # # ]: 0 : if (IS_ERR(tk)) {
843 [ # # ]: 0 : ret = PTR_ERR(tk);
844 : : /* This must return -ENOMEM, else there is a bug */
845 [ # # ]: 0 : WARN_ON_ONCE(ret != -ENOMEM);
846 : 0 : goto out; /* We know tk is not allocated */
847 : : }
848 : : argc -= 2; argv += 2;
849 : :
850 : : /* parse arguments */
851 [ # # ]: 0 : for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) {
852 : 0 : tmp = kstrdup(argv[i], GFP_KERNEL);
853 [ # # ]: 0 : if (!tmp) {
854 : 0 : ret = -ENOMEM;
855 : 0 : goto error;
856 : : }
857 : :
858 : 0 : trace_probe_log_set_index(i + 2);
859 : 0 : ret = traceprobe_parse_probe_arg(&tk->tp, i, tmp, flags);
860 : 0 : kfree(tmp);
861 [ # # ]: 0 : if (ret)
862 : 0 : goto error; /* This can be -ENOMEM */
863 : : }
864 : :
865 : 0 : ret = traceprobe_set_print_fmt(&tk->tp, is_return);
866 [ # # ]: 0 : if (ret < 0)
867 : 0 : goto error;
868 : :
869 : 0 : ret = register_trace_kprobe(tk);
870 [ # # ]: 0 : if (ret) {
871 : 0 : trace_probe_log_set_index(1);
872 [ # # ]: 0 : if (ret == -EILSEQ)
873 : 0 : trace_probe_log_err(0, BAD_INSN_BNDRY);
874 [ # # ]: 0 : else if (ret == -ENOENT)
875 : 0 : trace_probe_log_err(0, BAD_PROBE_ADDR);
876 [ # # ]: 0 : else if (ret != -ENOMEM && ret != -EEXIST)
877 : 0 : trace_probe_log_err(0, FAIL_REG_PROBE);
878 : 0 : goto error;
879 : : }
880 : :
881 : 0 : out:
882 : 0 : trace_probe_log_clear();
883 : 0 : kfree(symbol);
884 : 0 : return ret;
885 : :
886 : : parse_error:
887 : : ret = -EINVAL;
888 : 0 : error:
889 : 0 : free_trace_kprobe(tk);
890 : 0 : goto out;
891 : : }
892 : :
893 : 0 : static int create_or_delete_trace_kprobe(int argc, char **argv)
894 : : {
895 : 0 : int ret;
896 : :
897 [ # # ]: 0 : if (argv[0][0] == '-')
898 : 0 : return dyn_event_release(argc, argv, &trace_kprobe_ops);
899 : :
900 : 0 : ret = trace_kprobe_create(argc, (const char **)argv);
901 [ # # ]: 0 : return ret == -ECANCELED ? -EINVAL : ret;
902 : : }
903 : :
904 : 0 : static int trace_kprobe_run_command(struct dynevent_cmd *cmd)
905 : : {
906 : 0 : return trace_run_command(cmd->seq.buffer, create_or_delete_trace_kprobe);
907 : : }
908 : :
909 : : /**
910 : : * kprobe_event_cmd_init - Initialize a kprobe event command object
911 : : * @cmd: A pointer to the dynevent_cmd struct representing the new event
912 : : * @buf: A pointer to the buffer used to build the command
913 : : * @maxlen: The length of the buffer passed in @buf
914 : : *
915 : : * Initialize a synthetic event command object. Use this before
916 : : * calling any of the other kprobe_event functions.
917 : : */
918 : 0 : void kprobe_event_cmd_init(struct dynevent_cmd *cmd, char *buf, int maxlen)
919 : : {
920 : 0 : dynevent_cmd_init(cmd, buf, maxlen, DYNEVENT_TYPE_KPROBE,
921 : : trace_kprobe_run_command);
922 : 0 : }
923 : : EXPORT_SYMBOL_GPL(kprobe_event_cmd_init);
924 : :
925 : : /**
926 : : * __kprobe_event_gen_cmd_start - Generate a kprobe event command from arg list
927 : : * @cmd: A pointer to the dynevent_cmd struct representing the new event
928 : : * @name: The name of the kprobe event
929 : : * @loc: The location of the kprobe event
930 : : * @kretprobe: Is this a return probe?
931 : : * @args: Variable number of arg (pairs), one pair for each field
932 : : *
933 : : * NOTE: Users normally won't want to call this function directly, but
934 : : * rather use the kprobe_event_gen_cmd_start() wrapper, which automatically
935 : : * adds a NULL to the end of the arg list. If this function is used
936 : : * directly, make sure the last arg in the variable arg list is NULL.
937 : : *
938 : : * Generate a kprobe event command to be executed by
939 : : * kprobe_event_gen_cmd_end(). This function can be used to generate the
940 : : * complete command or only the first part of it; in the latter case,
941 : : * kprobe_event_add_fields() can be used to add more fields following this.
942 : : *
943 : : * Return: 0 if successful, error otherwise.
944 : : */
945 : 0 : int __kprobe_event_gen_cmd_start(struct dynevent_cmd *cmd, bool kretprobe,
946 : : const char *name, const char *loc, ...)
947 : : {
948 : 0 : char buf[MAX_EVENT_NAME_LEN];
949 : 0 : struct dynevent_arg arg;
950 : 0 : va_list args;
951 : 0 : int ret;
952 : :
953 [ # # ]: 0 : if (cmd->type != DYNEVENT_TYPE_KPROBE)
954 : : return -EINVAL;
955 : :
956 [ # # ]: 0 : if (kretprobe)
957 : 0 : snprintf(buf, MAX_EVENT_NAME_LEN, "r:kprobes/%s", name);
958 : : else
959 : 0 : snprintf(buf, MAX_EVENT_NAME_LEN, "p:kprobes/%s", name);
960 : :
961 : 0 : ret = dynevent_str_add(cmd, buf);
962 [ # # ]: 0 : if (ret)
963 : : return ret;
964 : :
965 : 0 : dynevent_arg_init(&arg, 0);
966 : 0 : arg.str = loc;
967 : 0 : ret = dynevent_arg_add(cmd, &arg, NULL);
968 [ # # ]: 0 : if (ret)
969 : : return ret;
970 : :
971 : 0 : va_start(args, loc);
972 : 0 : for (;;) {
973 : 0 : const char *field;
974 : :
975 : 0 : field = va_arg(args, const char *);
976 [ # # ]: 0 : if (!field)
977 : : break;
978 : :
979 [ # # ]: 0 : if (++cmd->n_fields > MAX_TRACE_ARGS) {
980 : : ret = -EINVAL;
981 : : break;
982 : : }
983 : :
984 : 0 : arg.str = field;
985 : 0 : ret = dynevent_arg_add(cmd, &arg, NULL);
986 [ # # ]: 0 : if (ret)
987 : : break;
988 : : }
989 : 0 : va_end(args);
990 : :
991 : 0 : return ret;
992 : : }
993 : : EXPORT_SYMBOL_GPL(__kprobe_event_gen_cmd_start);
994 : :
995 : : /**
996 : : * __kprobe_event_add_fields - Add probe fields to a kprobe command from arg list
997 : : * @cmd: A pointer to the dynevent_cmd struct representing the new event
998 : : * @args: Variable number of arg (pairs), one pair for each field
999 : : *
1000 : : * NOTE: Users normally won't want to call this function directly, but
1001 : : * rather use the kprobe_event_add_fields() wrapper, which
1002 : : * automatically adds a NULL to the end of the arg list. If this
1003 : : * function is used directly, make sure the last arg in the variable
1004 : : * arg list is NULL.
1005 : : *
1006 : : * Add probe fields to an existing kprobe command using a variable
1007 : : * list of args. Fields are added in the same order they're listed.
1008 : : *
1009 : : * Return: 0 if successful, error otherwise.
1010 : : */
1011 : 0 : int __kprobe_event_add_fields(struct dynevent_cmd *cmd, ...)
1012 : : {
1013 : 0 : struct dynevent_arg arg;
1014 : 0 : va_list args;
1015 : 0 : int ret = 0;
1016 : :
1017 [ # # ]: 0 : if (cmd->type != DYNEVENT_TYPE_KPROBE)
1018 : : return -EINVAL;
1019 : :
1020 : 0 : dynevent_arg_init(&arg, 0);
1021 : :
1022 : 0 : va_start(args, cmd);
1023 : 0 : for (;;) {
1024 : 0 : const char *field;
1025 : :
1026 : 0 : field = va_arg(args, const char *);
1027 [ # # ]: 0 : if (!field)
1028 : : break;
1029 : :
1030 [ # # ]: 0 : if (++cmd->n_fields > MAX_TRACE_ARGS) {
1031 : : ret = -EINVAL;
1032 : : break;
1033 : : }
1034 : :
1035 : 0 : arg.str = field;
1036 : 0 : ret = dynevent_arg_add(cmd, &arg, NULL);
1037 [ # # ]: 0 : if (ret)
1038 : : break;
1039 : : }
1040 : 0 : va_end(args);
1041 : :
1042 : 0 : return ret;
1043 : : }
1044 : : EXPORT_SYMBOL_GPL(__kprobe_event_add_fields);
1045 : :
1046 : : /**
1047 : : * kprobe_event_delete - Delete a kprobe event
1048 : : * @name: The name of the kprobe event to delete
1049 : : *
1050 : : * Delete a kprobe event with the give @name from kernel code rather
1051 : : * than directly from the command line.
1052 : : *
1053 : : * Return: 0 if successful, error otherwise.
1054 : : */
1055 : 0 : int kprobe_event_delete(const char *name)
1056 : : {
1057 : 0 : char buf[MAX_EVENT_NAME_LEN];
1058 : :
1059 : 0 : snprintf(buf, MAX_EVENT_NAME_LEN, "-:%s", name);
1060 : :
1061 : 0 : return trace_run_command(buf, create_or_delete_trace_kprobe);
1062 : : }
1063 : : EXPORT_SYMBOL_GPL(kprobe_event_delete);
1064 : :
1065 : 0 : static int trace_kprobe_release(struct dyn_event *ev)
1066 : : {
1067 : 0 : struct trace_kprobe *tk = to_trace_kprobe(ev);
1068 : 0 : int ret = unregister_trace_kprobe(tk);
1069 : :
1070 [ # # ]: 0 : if (!ret)
1071 : 0 : free_trace_kprobe(tk);
1072 : 0 : return ret;
1073 : : }
1074 : :
1075 : 0 : static int trace_kprobe_show(struct seq_file *m, struct dyn_event *ev)
1076 : : {
1077 : 0 : struct trace_kprobe *tk = to_trace_kprobe(ev);
1078 : 0 : int i;
1079 : :
1080 [ # # ]: 0 : seq_putc(m, trace_kprobe_is_return(tk) ? 'r' : 'p');
1081 [ # # ]: 0 : seq_printf(m, ":%s/%s", trace_probe_group_name(&tk->tp),
1082 : : trace_probe_name(&tk->tp));
1083 : :
1084 [ # # ]: 0 : if (!tk->symbol)
1085 : 0 : seq_printf(m, " 0x%p", tk->rp.kp.addr);
1086 [ # # ]: 0 : else if (tk->rp.kp.offset)
1087 : 0 : seq_printf(m, " %s+%u", trace_kprobe_symbol(tk),
1088 : : tk->rp.kp.offset);
1089 : : else
1090 : 0 : seq_printf(m, " %s", trace_kprobe_symbol(tk));
1091 : :
1092 [ # # ]: 0 : for (i = 0; i < tk->tp.nr_args; i++)
1093 : 0 : seq_printf(m, " %s=%s", tk->tp.args[i].name, tk->tp.args[i].comm);
1094 : 0 : seq_putc(m, '\n');
1095 : :
1096 : 0 : return 0;
1097 : : }
1098 : :
1099 : 0 : static int probes_seq_show(struct seq_file *m, void *v)
1100 : : {
1101 : 0 : struct dyn_event *ev = v;
1102 : :
1103 [ # # ]: 0 : if (!is_trace_kprobe(ev))
1104 : : return 0;
1105 : :
1106 : 0 : return trace_kprobe_show(m, ev);
1107 : : }
1108 : :
1109 : : static const struct seq_operations probes_seq_op = {
1110 : : .start = dyn_event_seq_start,
1111 : : .next = dyn_event_seq_next,
1112 : : .stop = dyn_event_seq_stop,
1113 : : .show = probes_seq_show
1114 : : };
1115 : :
1116 : 0 : static int probes_open(struct inode *inode, struct file *file)
1117 : : {
1118 : 0 : int ret;
1119 : :
1120 : 0 : ret = security_locked_down(LOCKDOWN_TRACEFS);
1121 [ # # ]: 0 : if (ret)
1122 : : return ret;
1123 : :
1124 [ # # ]: 0 : if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
1125 : 0 : ret = dyn_events_release_all(&trace_kprobe_ops);
1126 [ # # ]: 0 : if (ret < 0)
1127 : : return ret;
1128 : : }
1129 : :
1130 : 0 : return seq_open(file, &probes_seq_op);
1131 : : }
1132 : :
1133 : 0 : static ssize_t probes_write(struct file *file, const char __user *buffer,
1134 : : size_t count, loff_t *ppos)
1135 : : {
1136 : 0 : return trace_parse_run_command(file, buffer, count, ppos,
1137 : : create_or_delete_trace_kprobe);
1138 : : }
1139 : :
1140 : : static const struct file_operations kprobe_events_ops = {
1141 : : .owner = THIS_MODULE,
1142 : : .open = probes_open,
1143 : : .read = seq_read,
1144 : : .llseek = seq_lseek,
1145 : : .release = seq_release,
1146 : : .write = probes_write,
1147 : : };
1148 : :
1149 : : /* Probes profiling interfaces */
1150 : 0 : static int probes_profile_seq_show(struct seq_file *m, void *v)
1151 : : {
1152 : 0 : struct dyn_event *ev = v;
1153 : 0 : struct trace_kprobe *tk;
1154 : :
1155 [ # # ]: 0 : if (!is_trace_kprobe(ev))
1156 : : return 0;
1157 : :
1158 : 0 : tk = to_trace_kprobe(ev);
1159 : 0 : seq_printf(m, " %-44s %15lu %15lu\n",
1160 : : trace_probe_name(&tk->tp),
1161 : : trace_kprobe_nhit(tk),
1162 : : tk->rp.kp.nmissed);
1163 : :
1164 : 0 : return 0;
1165 : : }
1166 : :
1167 : : static const struct seq_operations profile_seq_op = {
1168 : : .start = dyn_event_seq_start,
1169 : : .next = dyn_event_seq_next,
1170 : : .stop = dyn_event_seq_stop,
1171 : : .show = probes_profile_seq_show
1172 : : };
1173 : :
1174 : 0 : static int profile_open(struct inode *inode, struct file *file)
1175 : : {
1176 : 0 : int ret;
1177 : :
1178 : 0 : ret = security_locked_down(LOCKDOWN_TRACEFS);
1179 [ # # ]: 0 : if (ret)
1180 : : return ret;
1181 : :
1182 : 0 : return seq_open(file, &profile_seq_op);
1183 : : }
1184 : :
1185 : : static const struct file_operations kprobe_profile_ops = {
1186 : : .owner = THIS_MODULE,
1187 : : .open = profile_open,
1188 : : .read = seq_read,
1189 : : .llseek = seq_lseek,
1190 : : .release = seq_release,
1191 : : };
1192 : :
1193 : : /* Kprobe specific fetch functions */
1194 : :
1195 : : /* Return the length of string -- including null terminal byte */
1196 : : static nokprobe_inline int
1197 : 0 : fetch_store_strlen(unsigned long addr)
1198 : : {
1199 : 0 : int ret, len = 0;
1200 : 0 : u8 c;
1201 : :
1202 : 0 : do {
1203 : 0 : ret = probe_kernel_read(&c, (u8 *)addr + len, 1);
1204 : 0 : len++;
1205 [ # # # # ]: 0 : } while (c && ret == 0 && len < MAX_STRING_SIZE);
1206 : :
1207 [ # # ]: 0 : return (ret < 0) ? ret : len;
1208 : : }
1209 : :
1210 : : /* Return the length of string -- including null terminal byte */
1211 : : static nokprobe_inline int
1212 : 0 : fetch_store_strlen_user(unsigned long addr)
1213 : : {
1214 : 0 : const void __user *uaddr = (__force const void __user *)addr;
1215 : :
1216 : 0 : return strnlen_unsafe_user(uaddr, MAX_STRING_SIZE);
1217 : : }
1218 : :
1219 : : /*
1220 : : * Fetch a null-terminated string. Caller MUST set *(u32 *)buf with max
1221 : : * length and relative data location.
1222 : : */
1223 : : static nokprobe_inline int
1224 : 0 : fetch_store_string(unsigned long addr, void *dest, void *base)
1225 : : {
1226 : 0 : int maxlen = get_loc_len(*(u32 *)dest);
1227 : 0 : void *__dest;
1228 : 0 : long ret;
1229 : :
1230 [ # # ]: 0 : if (unlikely(!maxlen))
1231 : : return -ENOMEM;
1232 : :
1233 : 0 : __dest = get_loc_data(dest, base);
1234 : :
1235 : : /*
1236 : : * Try to get string again, since the string can be changed while
1237 : : * probing.
1238 : : */
1239 : 0 : ret = strncpy_from_unsafe(__dest, (void *)addr, maxlen);
1240 [ # # ]: 0 : if (ret >= 0)
1241 : 0 : *(u32 *)dest = make_data_loc(ret, __dest - base);
1242 : :
1243 : 0 : return ret;
1244 : : }
1245 : :
1246 : : /*
1247 : : * Fetch a null-terminated string from user. Caller MUST set *(u32 *)buf
1248 : : * with max length and relative data location.
1249 : : */
1250 : : static nokprobe_inline int
1251 : 0 : fetch_store_string_user(unsigned long addr, void *dest, void *base)
1252 : : {
1253 : 0 : const void __user *uaddr = (__force const void __user *)addr;
1254 : 0 : int maxlen = get_loc_len(*(u32 *)dest);
1255 : 0 : void *__dest;
1256 : 0 : long ret;
1257 : :
1258 [ # # ]: 0 : if (unlikely(!maxlen))
1259 : : return -ENOMEM;
1260 : :
1261 : 0 : __dest = get_loc_data(dest, base);
1262 : :
1263 : 0 : ret = strncpy_from_unsafe_user(__dest, uaddr, maxlen);
1264 [ # # ]: 0 : if (ret >= 0)
1265 : 0 : *(u32 *)dest = make_data_loc(ret, __dest - base);
1266 : :
1267 : 0 : return ret;
1268 : : }
1269 : :
1270 : : static nokprobe_inline int
1271 : 0 : probe_mem_read(void *dest, void *src, size_t size)
1272 : : {
1273 : 0 : return probe_kernel_read(dest, src, size);
1274 : : }
1275 : :
1276 : : static nokprobe_inline int
1277 : 0 : probe_mem_read_user(void *dest, void *src, size_t size)
1278 : : {
1279 : 0 : const void __user *uaddr = (__force const void __user *)src;
1280 : :
1281 : 0 : return probe_user_read(dest, uaddr, size);
1282 : : }
1283 : :
1284 : : /* Note that we don't verify it, since the code does not come from user space */
1285 : : static int
1286 : 0 : process_fetch_insn(struct fetch_insn *code, struct pt_regs *regs, void *dest,
1287 : : void *base)
1288 : : {
1289 : 0 : unsigned long val;
1290 : :
1291 : 0 : retry:
1292 : : /* 1st stage: get value from context */
1293 [ # # # # : 0 : switch (code->op) {
# # # # #
# ]
1294 : 0 : case FETCH_OP_REG:
1295 [ # # ]: 0 : val = regs_get_register(regs, code->param);
1296 : : break;
1297 : 0 : case FETCH_OP_STACK:
1298 : 0 : val = regs_get_kernel_stack_nth(regs, code->param);
1299 : 0 : break;
1300 : 0 : case FETCH_OP_STACKP:
1301 : 0 : val = kernel_stack_pointer(regs);
1302 : 0 : break;
1303 : 0 : case FETCH_OP_RETVAL:
1304 : 0 : val = regs_return_value(regs);
1305 : 0 : break;
1306 : 0 : case FETCH_OP_IMM:
1307 : 0 : val = code->immediate;
1308 : 0 : break;
1309 : : case FETCH_OP_COMM:
1310 : 0 : val = (unsigned long)current->comm;
1311 : 0 : break;
1312 : 0 : case FETCH_OP_DATA:
1313 : 0 : val = (unsigned long)code->data;
1314 : 0 : break;
1315 : : #ifdef CONFIG_HAVE_FUNCTION_ARG_ACCESS_API
1316 : 0 : case FETCH_OP_ARG:
1317 : 0 : val = regs_get_kernel_argument(regs, code->param);
1318 : 0 : break;
1319 : : #endif
1320 : 0 : case FETCH_NOP_SYMBOL: /* Ignore a place holder */
1321 : 0 : code++;
1322 : 0 : goto retry;
1323 : : default:
1324 : : return -EILSEQ;
1325 : : }
1326 : 0 : code++;
1327 : :
1328 : 0 : return process_fetch_insn_bottom(code, val, dest, base);
1329 : : }
1330 : : NOKPROBE_SYMBOL(process_fetch_insn)
1331 : :
1332 : : /* Kprobe handler */
1333 : : static nokprobe_inline void
1334 : 0 : __kprobe_trace_func(struct trace_kprobe *tk, struct pt_regs *regs,
1335 : : struct trace_event_file *trace_file)
1336 : : {
1337 : 0 : struct kprobe_trace_entry_head *entry;
1338 : 0 : struct trace_event_call *call = trace_probe_event_call(&tk->tp);
1339 : 0 : struct trace_event_buffer fbuffer;
1340 : 0 : int dsize;
1341 : :
1342 [ # # ]: 0 : WARN_ON(call != trace_file->event_call);
1343 : :
1344 [ # # ]: 0 : if (trace_trigger_soft_disabled(trace_file))
1345 : 0 : return;
1346 : :
1347 : 0 : local_save_flags(fbuffer.flags);
1348 : 0 : fbuffer.pc = preempt_count();
1349 : 0 : fbuffer.trace_file = trace_file;
1350 : :
1351 : 0 : dsize = __get_data_size(&tk->tp, regs);
1352 : :
1353 : 0 : fbuffer.event =
1354 : 0 : trace_event_buffer_lock_reserve(&fbuffer.buffer, trace_file,
1355 : : call->event.type,
1356 : 0 : sizeof(*entry) + tk->tp.size + dsize,
1357 : : fbuffer.flags, fbuffer.pc);
1358 [ # # ]: 0 : if (!fbuffer.event)
1359 : : return;
1360 : :
1361 : 0 : fbuffer.regs = regs;
1362 : 0 : entry = fbuffer.entry = ring_buffer_event_data(fbuffer.event);
1363 : 0 : entry->ip = (unsigned long)tk->rp.kp.addr;
1364 : 0 : store_trace_args(&entry[1], &tk->tp, regs, sizeof(*entry), dsize);
1365 : :
1366 : 0 : trace_event_buffer_commit(&fbuffer);
1367 : : }
1368 : :
1369 : : static void
1370 : 0 : kprobe_trace_func(struct trace_kprobe *tk, struct pt_regs *regs)
1371 : : {
1372 : 0 : struct event_file_link *link;
1373 : :
1374 [ # # ]: 0 : trace_probe_for_each_link_rcu(link, &tk->tp)
1375 [ # # ]: 0 : __kprobe_trace_func(tk, regs, link->file);
1376 : 0 : }
1377 : : NOKPROBE_SYMBOL(kprobe_trace_func);
1378 : :
1379 : : /* Kretprobe handler */
1380 : : static nokprobe_inline void
1381 : 0 : __kretprobe_trace_func(struct trace_kprobe *tk, struct kretprobe_instance *ri,
1382 : : struct pt_regs *regs,
1383 : : struct trace_event_file *trace_file)
1384 : : {
1385 : 0 : struct kretprobe_trace_entry_head *entry;
1386 : 0 : struct trace_event_buffer fbuffer;
1387 : 0 : struct trace_event_call *call = trace_probe_event_call(&tk->tp);
1388 : 0 : int dsize;
1389 : :
1390 [ # # ]: 0 : WARN_ON(call != trace_file->event_call);
1391 : :
1392 [ # # ]: 0 : if (trace_trigger_soft_disabled(trace_file))
1393 : 0 : return;
1394 : :
1395 : 0 : local_save_flags(fbuffer.flags);
1396 : 0 : fbuffer.pc = preempt_count();
1397 : 0 : fbuffer.trace_file = trace_file;
1398 : :
1399 : 0 : dsize = __get_data_size(&tk->tp, regs);
1400 : 0 : fbuffer.event =
1401 : 0 : trace_event_buffer_lock_reserve(&fbuffer.buffer, trace_file,
1402 : : call->event.type,
1403 : 0 : sizeof(*entry) + tk->tp.size + dsize,
1404 : : fbuffer.flags, fbuffer.pc);
1405 [ # # ]: 0 : if (!fbuffer.event)
1406 : : return;
1407 : :
1408 : 0 : fbuffer.regs = regs;
1409 : 0 : entry = fbuffer.entry = ring_buffer_event_data(fbuffer.event);
1410 : 0 : entry->func = (unsigned long)tk->rp.kp.addr;
1411 : 0 : entry->ret_ip = (unsigned long)ri->ret_addr;
1412 : 0 : store_trace_args(&entry[1], &tk->tp, regs, sizeof(*entry), dsize);
1413 : :
1414 : 0 : trace_event_buffer_commit(&fbuffer);
1415 : : }
1416 : :
1417 : : static void
1418 : 0 : kretprobe_trace_func(struct trace_kprobe *tk, struct kretprobe_instance *ri,
1419 : : struct pt_regs *regs)
1420 : : {
1421 : 0 : struct event_file_link *link;
1422 : :
1423 [ # # ]: 0 : trace_probe_for_each_link_rcu(link, &tk->tp)
1424 [ # # ]: 0 : __kretprobe_trace_func(tk, ri, regs, link->file);
1425 : 0 : }
1426 : : NOKPROBE_SYMBOL(kretprobe_trace_func);
1427 : :
1428 : : /* Event entry printers */
1429 : : static enum print_line_t
1430 : 0 : print_kprobe_event(struct trace_iterator *iter, int flags,
1431 : : struct trace_event *event)
1432 : : {
1433 : 0 : struct kprobe_trace_entry_head *field;
1434 : 0 : struct trace_seq *s = &iter->seq;
1435 : 0 : struct trace_probe *tp;
1436 : :
1437 : 0 : field = (struct kprobe_trace_entry_head *)iter->ent;
1438 : 0 : tp = trace_probe_primary_from_call(
1439 [ # # ]: 0 : container_of(event, struct trace_event_call, event));
1440 [ # # # # ]: 0 : if (WARN_ON_ONCE(!tp))
1441 : 0 : goto out;
1442 : :
1443 [ # # ]: 0 : trace_seq_printf(s, "%s: (", trace_probe_name(tp));
1444 : :
1445 [ # # ]: 0 : if (!seq_print_ip_sym(s, field->ip, flags | TRACE_ITER_SYM_OFFSET))
1446 : 0 : goto out;
1447 : :
1448 : 0 : trace_seq_putc(s, ')');
1449 : :
1450 [ # # ]: 0 : if (print_probe_args(s, tp->args, tp->nr_args,
1451 : 0 : (u8 *)&field[1], field) < 0)
1452 : 0 : goto out;
1453 : :
1454 : 0 : trace_seq_putc(s, '\n');
1455 : 0 : out:
1456 : 0 : return trace_handle_return(s);
1457 : : }
1458 : :
1459 : : static enum print_line_t
1460 : 0 : print_kretprobe_event(struct trace_iterator *iter, int flags,
1461 : : struct trace_event *event)
1462 : : {
1463 : 0 : struct kretprobe_trace_entry_head *field;
1464 : 0 : struct trace_seq *s = &iter->seq;
1465 : 0 : struct trace_probe *tp;
1466 : :
1467 : 0 : field = (struct kretprobe_trace_entry_head *)iter->ent;
1468 : 0 : tp = trace_probe_primary_from_call(
1469 [ # # ]: 0 : container_of(event, struct trace_event_call, event));
1470 [ # # # # ]: 0 : if (WARN_ON_ONCE(!tp))
1471 : 0 : goto out;
1472 : :
1473 [ # # ]: 0 : trace_seq_printf(s, "%s: (", trace_probe_name(tp));
1474 : :
1475 [ # # ]: 0 : if (!seq_print_ip_sym(s, field->ret_ip, flags | TRACE_ITER_SYM_OFFSET))
1476 : 0 : goto out;
1477 : :
1478 : 0 : trace_seq_puts(s, " <- ");
1479 : :
1480 [ # # ]: 0 : if (!seq_print_ip_sym(s, field->func, flags & ~TRACE_ITER_SYM_OFFSET))
1481 : 0 : goto out;
1482 : :
1483 : 0 : trace_seq_putc(s, ')');
1484 : :
1485 [ # # ]: 0 : if (print_probe_args(s, tp->args, tp->nr_args,
1486 : 0 : (u8 *)&field[1], field) < 0)
1487 : 0 : goto out;
1488 : :
1489 : 0 : trace_seq_putc(s, '\n');
1490 : :
1491 : 0 : out:
1492 : 0 : return trace_handle_return(s);
1493 : : }
1494 : :
1495 : :
1496 : 0 : static int kprobe_event_define_fields(struct trace_event_call *event_call)
1497 : : {
1498 : 0 : int ret;
1499 : 0 : struct kprobe_trace_entry_head field;
1500 : 0 : struct trace_probe *tp;
1501 : :
1502 [ # # ]: 0 : tp = trace_probe_primary_from_call(event_call);
1503 [ # # # # ]: 0 : if (WARN_ON_ONCE(!tp))
1504 : : return -ENOENT;
1505 : :
1506 [ # # ]: 0 : DEFINE_FIELD(unsigned long, ip, FIELD_STRING_IP, 0);
1507 : :
1508 : 0 : return traceprobe_define_arg_fields(event_call, sizeof(field), tp);
1509 : : }
1510 : :
1511 : 0 : static int kretprobe_event_define_fields(struct trace_event_call *event_call)
1512 : : {
1513 : 0 : int ret;
1514 : 0 : struct kretprobe_trace_entry_head field;
1515 : 0 : struct trace_probe *tp;
1516 : :
1517 [ # # ]: 0 : tp = trace_probe_primary_from_call(event_call);
1518 [ # # # # ]: 0 : if (WARN_ON_ONCE(!tp))
1519 : : return -ENOENT;
1520 : :
1521 [ # # ]: 0 : DEFINE_FIELD(unsigned long, func, FIELD_STRING_FUNC, 0);
1522 [ # # ]: 0 : DEFINE_FIELD(unsigned long, ret_ip, FIELD_STRING_RETIP, 0);
1523 : :
1524 : 0 : return traceprobe_define_arg_fields(event_call, sizeof(field), tp);
1525 : : }
1526 : :
1527 : : #ifdef CONFIG_PERF_EVENTS
1528 : :
1529 : : /* Kprobe profile handler */
1530 : : static int
1531 : 0 : kprobe_perf_func(struct trace_kprobe *tk, struct pt_regs *regs)
1532 : : {
1533 : 0 : struct trace_event_call *call = trace_probe_event_call(&tk->tp);
1534 : 0 : struct kprobe_trace_entry_head *entry;
1535 : 0 : struct hlist_head *head;
1536 : 0 : int size, __size, dsize;
1537 : 0 : int rctx;
1538 : :
1539 : 0 : if (bpf_prog_array_valid(call)) {
1540 : : unsigned long orig_ip = instruction_pointer(regs);
1541 : : int ret;
1542 : :
1543 : : ret = trace_call_bpf(call, regs);
1544 : :
1545 : : /*
1546 : : * We need to check and see if we modified the pc of the
1547 : : * pt_regs, and if so return 1 so that we don't do the
1548 : : * single stepping.
1549 : : */
1550 : : if (orig_ip != instruction_pointer(regs))
1551 : : return 1;
1552 : : if (!ret)
1553 : : return 0;
1554 : : }
1555 : :
1556 : 0 : head = this_cpu_ptr(call->perf_events);
1557 [ # # ]: 0 : if (hlist_empty(head))
1558 : : return 0;
1559 : :
1560 : : dsize = __get_data_size(&tk->tp, regs);
1561 : 0 : __size = sizeof(*entry) + tk->tp.size + dsize;
1562 : 0 : size = ALIGN(__size + sizeof(u32), sizeof(u64));
1563 : 0 : size -= sizeof(u32);
1564 : :
1565 : 0 : entry = perf_trace_buf_alloc(size, NULL, &rctx);
1566 [ # # ]: 0 : if (!entry)
1567 : : return 0;
1568 : :
1569 : 0 : entry->ip = (unsigned long)tk->rp.kp.addr;
1570 : 0 : memset(&entry[1], 0, dsize);
1571 : 0 : store_trace_args(&entry[1], &tk->tp, regs, sizeof(*entry), dsize);
1572 : 0 : perf_trace_buf_submit(entry, size, rctx, call->event.type, 1, regs,
1573 : : head, NULL);
1574 : 0 : return 0;
1575 : : }
1576 : : NOKPROBE_SYMBOL(kprobe_perf_func);
1577 : :
1578 : : /* Kretprobe profile handler */
1579 : : static void
1580 : 0 : kretprobe_perf_func(struct trace_kprobe *tk, struct kretprobe_instance *ri,
1581 : : struct pt_regs *regs)
1582 : : {
1583 : 0 : struct trace_event_call *call = trace_probe_event_call(&tk->tp);
1584 : 0 : struct kretprobe_trace_entry_head *entry;
1585 : 0 : struct hlist_head *head;
1586 : 0 : int size, __size, dsize;
1587 : 0 : int rctx;
1588 : :
1589 : 0 : if (bpf_prog_array_valid(call) && !trace_call_bpf(call, regs))
1590 : 0 : return;
1591 : :
1592 : 0 : head = this_cpu_ptr(call->perf_events);
1593 [ # # ]: 0 : if (hlist_empty(head))
1594 : : return;
1595 : :
1596 : : dsize = __get_data_size(&tk->tp, regs);
1597 : 0 : __size = sizeof(*entry) + tk->tp.size + dsize;
1598 : 0 : size = ALIGN(__size + sizeof(u32), sizeof(u64));
1599 : 0 : size -= sizeof(u32);
1600 : :
1601 : 0 : entry = perf_trace_buf_alloc(size, NULL, &rctx);
1602 [ # # ]: 0 : if (!entry)
1603 : : return;
1604 : :
1605 : 0 : entry->func = (unsigned long)tk->rp.kp.addr;
1606 : 0 : entry->ret_ip = (unsigned long)ri->ret_addr;
1607 : 0 : store_trace_args(&entry[1], &tk->tp, regs, sizeof(*entry), dsize);
1608 : 0 : perf_trace_buf_submit(entry, size, rctx, call->event.type, 1, regs,
1609 : : head, NULL);
1610 : : }
1611 : : NOKPROBE_SYMBOL(kretprobe_perf_func);
1612 : :
1613 : 0 : int bpf_get_kprobe_info(const struct perf_event *event, u32 *fd_type,
1614 : : const char **symbol, u64 *probe_offset,
1615 : : u64 *probe_addr, bool perf_type_tracepoint)
1616 : : {
1617 [ # # ]: 0 : const char *pevent = trace_event_name(event->tp_event);
1618 : 0 : const char *group = event->tp_event->class->system;
1619 : 0 : struct trace_kprobe *tk;
1620 : :
1621 [ # # ]: 0 : if (perf_type_tracepoint)
1622 : 0 : tk = find_trace_kprobe(pevent, group);
1623 : : else
1624 : 0 : tk = event->tp_event->data;
1625 [ # # ]: 0 : if (!tk)
1626 : : return -EINVAL;
1627 : :
1628 : 0 : *fd_type = trace_kprobe_is_return(tk) ? BPF_FD_TYPE_KRETPROBE
1629 [ # # ]: 0 : : BPF_FD_TYPE_KPROBE;
1630 [ # # ]: 0 : if (tk->symbol) {
1631 : 0 : *symbol = tk->symbol;
1632 : 0 : *probe_offset = tk->rp.kp.offset;
1633 : 0 : *probe_addr = 0;
1634 : : } else {
1635 : 0 : *symbol = NULL;
1636 : 0 : *probe_offset = 0;
1637 : 0 : *probe_addr = (unsigned long)tk->rp.kp.addr;
1638 : : }
1639 : : return 0;
1640 : : }
1641 : : #endif /* CONFIG_PERF_EVENTS */
1642 : :
1643 : : /*
1644 : : * called by perf_trace_init() or __ftrace_set_clr_event() under event_mutex.
1645 : : *
1646 : : * kprobe_trace_self_tests_init() does enable_trace_probe/disable_trace_probe
1647 : : * lockless, but we can't race with this __init function.
1648 : : */
1649 : 0 : static int kprobe_register(struct trace_event_call *event,
1650 : : enum trace_reg type, void *data)
1651 : : {
1652 : 0 : struct trace_event_file *file = data;
1653 : :
1654 [ # # # # : 0 : switch (type) {
# ]
1655 : 0 : case TRACE_REG_REGISTER:
1656 : 0 : return enable_trace_kprobe(event, file);
1657 : 0 : case TRACE_REG_UNREGISTER:
1658 : 0 : return disable_trace_kprobe(event, file);
1659 : :
1660 : : #ifdef CONFIG_PERF_EVENTS
1661 : 0 : case TRACE_REG_PERF_REGISTER:
1662 : 0 : return enable_trace_kprobe(event, NULL);
1663 : 0 : case TRACE_REG_PERF_UNREGISTER:
1664 : 0 : return disable_trace_kprobe(event, NULL);
1665 : : case TRACE_REG_PERF_OPEN:
1666 : : case TRACE_REG_PERF_CLOSE:
1667 : : case TRACE_REG_PERF_ADD:
1668 : : case TRACE_REG_PERF_DEL:
1669 : : return 0;
1670 : : #endif
1671 : : }
1672 : : return 0;
1673 : : }
1674 : :
1675 : 0 : static int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs)
1676 : : {
1677 : 0 : struct trace_kprobe *tk = container_of(kp, struct trace_kprobe, rp.kp);
1678 : 0 : int ret = 0;
1679 : :
1680 : 0 : raw_cpu_inc(*tk->nhit);
1681 : :
1682 [ # # ]: 0 : if (trace_probe_test_flag(&tk->tp, TP_FLAG_TRACE))
1683 : 0 : kprobe_trace_func(tk, regs);
1684 : : #ifdef CONFIG_PERF_EVENTS
1685 [ # # ]: 0 : if (trace_probe_test_flag(&tk->tp, TP_FLAG_PROFILE))
1686 : 0 : ret = kprobe_perf_func(tk, regs);
1687 : : #endif
1688 : 0 : return ret;
1689 : : }
1690 : : NOKPROBE_SYMBOL(kprobe_dispatcher);
1691 : :
1692 : : static int
1693 : 0 : kretprobe_dispatcher(struct kretprobe_instance *ri, struct pt_regs *regs)
1694 : : {
1695 : 0 : struct trace_kprobe *tk = container_of(ri->rp, struct trace_kprobe, rp);
1696 : :
1697 : 0 : raw_cpu_inc(*tk->nhit);
1698 : :
1699 [ # # ]: 0 : if (trace_probe_test_flag(&tk->tp, TP_FLAG_TRACE))
1700 : 0 : kretprobe_trace_func(tk, ri, regs);
1701 : : #ifdef CONFIG_PERF_EVENTS
1702 [ # # ]: 0 : if (trace_probe_test_flag(&tk->tp, TP_FLAG_PROFILE))
1703 : 0 : kretprobe_perf_func(tk, ri, regs);
1704 : : #endif
1705 : 0 : return 0; /* We don't tweek kernel, so just return 0 */
1706 : : }
1707 : : NOKPROBE_SYMBOL(kretprobe_dispatcher);
1708 : :
1709 : : static struct trace_event_functions kretprobe_funcs = {
1710 : : .trace = print_kretprobe_event
1711 : : };
1712 : :
1713 : : static struct trace_event_functions kprobe_funcs = {
1714 : : .trace = print_kprobe_event
1715 : : };
1716 : :
1717 : : static struct trace_event_fields kretprobe_fields_array[] = {
1718 : : { .type = TRACE_FUNCTION_TYPE,
1719 : : .define_fields = kretprobe_event_define_fields },
1720 : : {}
1721 : : };
1722 : :
1723 : : static struct trace_event_fields kprobe_fields_array[] = {
1724 : : { .type = TRACE_FUNCTION_TYPE,
1725 : : .define_fields = kprobe_event_define_fields },
1726 : : {}
1727 : : };
1728 : :
1729 : 0 : static inline void init_trace_event_call(struct trace_kprobe *tk)
1730 : : {
1731 : 0 : struct trace_event_call *call = trace_probe_event_call(&tk->tp);
1732 : :
1733 [ # # # # ]: 0 : if (trace_kprobe_is_return(tk)) {
1734 : 0 : call->event.funcs = &kretprobe_funcs;
1735 : 0 : call->class->fields_array = kretprobe_fields_array;
1736 : : } else {
1737 : 0 : call->event.funcs = &kprobe_funcs;
1738 : 0 : call->class->fields_array = kprobe_fields_array;
1739 : : }
1740 : :
1741 : 0 : call->flags = TRACE_EVENT_FL_KPROBE;
1742 : 0 : call->class->reg = kprobe_register;
1743 : : }
1744 : :
1745 : 0 : static int register_kprobe_event(struct trace_kprobe *tk)
1746 : : {
1747 [ # # ]: 0 : init_trace_event_call(tk);
1748 : :
1749 : 0 : return trace_probe_register_event_call(&tk->tp);
1750 : : }
1751 : :
1752 : 0 : static int unregister_kprobe_event(struct trace_kprobe *tk)
1753 : : {
1754 : 0 : return trace_probe_unregister_event_call(&tk->tp);
1755 : : }
1756 : :
1757 : : #ifdef CONFIG_PERF_EVENTS
1758 : : /* create a trace_kprobe, but don't add it to global lists */
1759 : : struct trace_event_call *
1760 : 0 : create_local_trace_kprobe(char *func, void *addr, unsigned long offs,
1761 : : bool is_return)
1762 : : {
1763 : 0 : struct trace_kprobe *tk;
1764 : 0 : int ret;
1765 : 0 : char *event;
1766 : :
1767 : : /*
1768 : : * local trace_kprobes are not added to dyn_event, so they are never
1769 : : * searched in find_trace_kprobe(). Therefore, there is no concern of
1770 : : * duplicated name here.
1771 : : */
1772 [ # # ]: 0 : event = func ? func : "DUMMY_EVENT";
1773 : :
1774 : 0 : tk = alloc_trace_kprobe(KPROBE_EVENT_SYSTEM, event, (void *)addr, func,
1775 : : offs, 0 /* maxactive */, 0 /* nargs */,
1776 : : is_return);
1777 : :
1778 [ # # ]: 0 : if (IS_ERR(tk)) {
1779 : 0 : pr_info("Failed to allocate trace_probe.(%d)\n",
1780 : : (int)PTR_ERR(tk));
1781 : 0 : return ERR_CAST(tk);
1782 : : }
1783 : :
1784 [ # # ]: 0 : init_trace_event_call(tk);
1785 : :
1786 [ # # ]: 0 : if (traceprobe_set_print_fmt(&tk->tp, trace_kprobe_is_return(tk)) < 0) {
1787 : 0 : ret = -ENOMEM;
1788 : 0 : goto error;
1789 : : }
1790 : :
1791 : 0 : ret = __register_trace_kprobe(tk);
1792 [ # # ]: 0 : if (ret < 0)
1793 : 0 : goto error;
1794 : :
1795 : 0 : return trace_probe_event_call(&tk->tp);
1796 : 0 : error:
1797 : 0 : free_trace_kprobe(tk);
1798 : 0 : return ERR_PTR(ret);
1799 : : }
1800 : :
1801 : 0 : void destroy_local_trace_kprobe(struct trace_event_call *event_call)
1802 : : {
1803 : 0 : struct trace_kprobe *tk;
1804 : :
1805 [ # # ]: 0 : tk = trace_kprobe_primary_from_call(event_call);
1806 [ # # ]: 0 : if (unlikely(!tk))
1807 : : return;
1808 : :
1809 [ # # ]: 0 : if (trace_probe_is_enabled(&tk->tp)) {
1810 : 0 : WARN_ON(1);
1811 : 0 : return;
1812 : : }
1813 : :
1814 : 0 : __unregister_trace_kprobe(tk);
1815 : :
1816 : 0 : free_trace_kprobe(tk);
1817 : : }
1818 : : #endif /* CONFIG_PERF_EVENTS */
1819 : :
1820 : 3 : static __init void enable_boot_kprobe_events(void)
1821 : : {
1822 [ + - ]: 3 : struct trace_array *tr = top_trace_array();
1823 : 3 : struct trace_event_file *file;
1824 : 3 : struct trace_kprobe *tk;
1825 : 3 : struct dyn_event *pos;
1826 : :
1827 : 3 : mutex_lock(&event_mutex);
1828 [ - - - - : 3 : for_each_trace_kprobe(tk, pos) {
- + ]
1829 [ # # ]: 0 : list_for_each_entry(file, &tr->events, list)
1830 [ # # ]: 0 : if (file->event_call == trace_probe_event_call(&tk->tp))
1831 : 0 : trace_event_enable_disable(file, 1, 0);
1832 : : }
1833 : 3 : mutex_unlock(&event_mutex);
1834 : 3 : }
1835 : :
1836 : 3 : static __init void setup_boot_kprobe_events(void)
1837 : : {
1838 : 3 : char *p, *cmd = kprobe_boot_events_buf;
1839 : 3 : int ret;
1840 : :
1841 : 3 : strreplace(kprobe_boot_events_buf, ',', ' ');
1842 : :
1843 [ + - - + ]: 3 : while (cmd && *cmd != '\0') {
1844 : 0 : p = strchr(cmd, ';');
1845 [ # # ]: 0 : if (p)
1846 : 0 : *p++ = '\0';
1847 : :
1848 : 0 : ret = trace_run_command(cmd, create_or_delete_trace_kprobe);
1849 [ # # ]: 0 : if (ret)
1850 : 0 : pr_warn("Failed to add event(%d): %s\n", ret, cmd);
1851 : : else
1852 : 0 : kprobe_boot_events_enabled = true;
1853 : :
1854 : : cmd = p;
1855 : : }
1856 : :
1857 : 3 : enable_boot_kprobe_events();
1858 : 3 : }
1859 : :
1860 : : /*
1861 : : * Register dynevent at subsys_initcall. This allows kernel to setup kprobe
1862 : : * events in fs_initcall without tracefs.
1863 : : */
1864 : 3 : static __init int init_kprobe_trace_early(void)
1865 : : {
1866 : 3 : int ret;
1867 : :
1868 : 3 : ret = dyn_event_register(&trace_kprobe_ops);
1869 [ + - ]: 3 : if (ret)
1870 : : return ret;
1871 : :
1872 [ - + ]: 3 : if (register_module_notifier(&trace_kprobe_module_nb))
1873 : 0 : return -EINVAL;
1874 : :
1875 : : return 0;
1876 : : }
1877 : : subsys_initcall(init_kprobe_trace_early);
1878 : :
1879 : : /* Make a tracefs interface for controlling probe points */
1880 : 3 : static __init int init_kprobe_trace(void)
1881 : : {
1882 : 3 : struct dentry *d_tracer;
1883 : 3 : struct dentry *entry;
1884 : :
1885 : 3 : d_tracer = tracing_init_dentry();
1886 [ + - ]: 3 : if (IS_ERR(d_tracer))
1887 : : return 0;
1888 : :
1889 : 3 : entry = tracefs_create_file("kprobe_events", 0644, d_tracer,
1890 : : NULL, &kprobe_events_ops);
1891 : :
1892 : : /* Event list interface */
1893 [ - + ]: 3 : if (!entry)
1894 : 0 : pr_warn("Could not create tracefs 'kprobe_events' entry\n");
1895 : :
1896 : : /* Profile interface */
1897 : 3 : entry = tracefs_create_file("kprobe_profile", 0444, d_tracer,
1898 : : NULL, &kprobe_profile_ops);
1899 : :
1900 [ - + ]: 3 : if (!entry)
1901 : 0 : pr_warn("Could not create tracefs 'kprobe_profile' entry\n");
1902 : :
1903 : 3 : setup_boot_kprobe_events();
1904 : :
1905 : 3 : return 0;
1906 : : }
1907 : : fs_initcall(init_kprobe_trace);
1908 : :
1909 : :
1910 : : #ifdef CONFIG_FTRACE_STARTUP_TEST
1911 : : static __init struct trace_event_file *
1912 : : find_trace_probe_file(struct trace_kprobe *tk, struct trace_array *tr)
1913 : : {
1914 : : struct trace_event_file *file;
1915 : :
1916 : : list_for_each_entry(file, &tr->events, list)
1917 : : if (file->event_call == trace_probe_event_call(&tk->tp))
1918 : : return file;
1919 : :
1920 : : return NULL;
1921 : : }
1922 : :
1923 : : /*
1924 : : * Nobody but us can call enable_trace_kprobe/disable_trace_kprobe at this
1925 : : * stage, we can do this lockless.
1926 : : */
1927 : : static __init int kprobe_trace_self_tests_init(void)
1928 : : {
1929 : : int ret, warn = 0;
1930 : : int (*target)(int, int, int, int, int, int);
1931 : : struct trace_kprobe *tk;
1932 : : struct trace_event_file *file;
1933 : :
1934 : : if (tracing_is_disabled())
1935 : : return -ENODEV;
1936 : :
1937 : : if (kprobe_boot_events_enabled) {
1938 : : pr_info("Skipping kprobe tests due to kprobe_event on cmdline\n");
1939 : : return 0;
1940 : : }
1941 : :
1942 : : target = kprobe_trace_selftest_target;
1943 : :
1944 : : pr_info("Testing kprobe tracing: ");
1945 : :
1946 : : ret = trace_run_command("p:testprobe kprobe_trace_selftest_target $stack $stack0 +0($stack)",
1947 : : create_or_delete_trace_kprobe);
1948 : : if (WARN_ON_ONCE(ret)) {
1949 : : pr_warn("error on probing function entry.\n");
1950 : : warn++;
1951 : : } else {
1952 : : /* Enable trace point */
1953 : : tk = find_trace_kprobe("testprobe", KPROBE_EVENT_SYSTEM);
1954 : : if (WARN_ON_ONCE(tk == NULL)) {
1955 : : pr_warn("error on getting new probe.\n");
1956 : : warn++;
1957 : : } else {
1958 : : file = find_trace_probe_file(tk, top_trace_array());
1959 : : if (WARN_ON_ONCE(file == NULL)) {
1960 : : pr_warn("error on getting probe file.\n");
1961 : : warn++;
1962 : : } else
1963 : : enable_trace_kprobe(
1964 : : trace_probe_event_call(&tk->tp), file);
1965 : : }
1966 : : }
1967 : :
1968 : : ret = trace_run_command("r:testprobe2 kprobe_trace_selftest_target $retval",
1969 : : create_or_delete_trace_kprobe);
1970 : : if (WARN_ON_ONCE(ret)) {
1971 : : pr_warn("error on probing function return.\n");
1972 : : warn++;
1973 : : } else {
1974 : : /* Enable trace point */
1975 : : tk = find_trace_kprobe("testprobe2", KPROBE_EVENT_SYSTEM);
1976 : : if (WARN_ON_ONCE(tk == NULL)) {
1977 : : pr_warn("error on getting 2nd new probe.\n");
1978 : : warn++;
1979 : : } else {
1980 : : file = find_trace_probe_file(tk, top_trace_array());
1981 : : if (WARN_ON_ONCE(file == NULL)) {
1982 : : pr_warn("error on getting probe file.\n");
1983 : : warn++;
1984 : : } else
1985 : : enable_trace_kprobe(
1986 : : trace_probe_event_call(&tk->tp), file);
1987 : : }
1988 : : }
1989 : :
1990 : : if (warn)
1991 : : goto end;
1992 : :
1993 : : ret = target(1, 2, 3, 4, 5, 6);
1994 : :
1995 : : /*
1996 : : * Not expecting an error here, the check is only to prevent the
1997 : : * optimizer from removing the call to target() as otherwise there
1998 : : * are no side-effects and the call is never performed.
1999 : : */
2000 : : if (ret != 21)
2001 : : warn++;
2002 : :
2003 : : /* Disable trace points before removing it */
2004 : : tk = find_trace_kprobe("testprobe", KPROBE_EVENT_SYSTEM);
2005 : : if (WARN_ON_ONCE(tk == NULL)) {
2006 : : pr_warn("error on getting test probe.\n");
2007 : : warn++;
2008 : : } else {
2009 : : if (trace_kprobe_nhit(tk) != 1) {
2010 : : pr_warn("incorrect number of testprobe hits\n");
2011 : : warn++;
2012 : : }
2013 : :
2014 : : file = find_trace_probe_file(tk, top_trace_array());
2015 : : if (WARN_ON_ONCE(file == NULL)) {
2016 : : pr_warn("error on getting probe file.\n");
2017 : : warn++;
2018 : : } else
2019 : : disable_trace_kprobe(
2020 : : trace_probe_event_call(&tk->tp), file);
2021 : : }
2022 : :
2023 : : tk = find_trace_kprobe("testprobe2", KPROBE_EVENT_SYSTEM);
2024 : : if (WARN_ON_ONCE(tk == NULL)) {
2025 : : pr_warn("error on getting 2nd test probe.\n");
2026 : : warn++;
2027 : : } else {
2028 : : if (trace_kprobe_nhit(tk) != 1) {
2029 : : pr_warn("incorrect number of testprobe2 hits\n");
2030 : : warn++;
2031 : : }
2032 : :
2033 : : file = find_trace_probe_file(tk, top_trace_array());
2034 : : if (WARN_ON_ONCE(file == NULL)) {
2035 : : pr_warn("error on getting probe file.\n");
2036 : : warn++;
2037 : : } else
2038 : : disable_trace_kprobe(
2039 : : trace_probe_event_call(&tk->tp), file);
2040 : : }
2041 : :
2042 : : ret = trace_run_command("-:testprobe", create_or_delete_trace_kprobe);
2043 : : if (WARN_ON_ONCE(ret)) {
2044 : : pr_warn("error on deleting a probe.\n");
2045 : : warn++;
2046 : : }
2047 : :
2048 : : ret = trace_run_command("-:testprobe2", create_or_delete_trace_kprobe);
2049 : : if (WARN_ON_ONCE(ret)) {
2050 : : pr_warn("error on deleting a probe.\n");
2051 : : warn++;
2052 : : }
2053 : :
2054 : : end:
2055 : : ret = dyn_events_release_all(&trace_kprobe_ops);
2056 : : if (WARN_ON_ONCE(ret)) {
2057 : : pr_warn("error on cleaning up probes.\n");
2058 : : warn++;
2059 : : }
2060 : : /*
2061 : : * Wait for the optimizer work to finish. Otherwise it might fiddle
2062 : : * with probes in already freed __init text.
2063 : : */
2064 : : wait_for_kprobe_optimizer();
2065 : : if (warn)
2066 : : pr_cont("NG: Some tests are failed. Please check them.\n");
2067 : : else
2068 : : pr_cont("OK\n");
2069 : : return 0;
2070 : : }
2071 : :
2072 : : late_initcall(kprobe_trace_self_tests_init);
2073 : :
2074 : : #endif
|
