mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-10-30 08:02:30 +00:00
cb16330d12
Pass return address as 'ret_ip' to the fprobe entry and return handlers so that the fprobe user handler can get the reutrn address without analyzing arch-dependent pt_regs. Link: https://lore.kernel.org/all/168507467664.913472.11642316698862778600.stgit@mhiramat.roam.corp.google.com/ Signed-off-by: Masami Hiramatsu (Google) <mhiramat@kernel.org>
153 lines
4 KiB
C
153 lines
4 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Here's a sample kernel module showing the use of fprobe to dump a
|
|
* stack trace and selected registers when kernel_clone() is called.
|
|
*
|
|
* For more information on theory of operation of kprobes, see
|
|
* Documentation/trace/kprobes.rst
|
|
*
|
|
* You will see the trace data in /var/log/messages and on the console
|
|
* whenever kernel_clone() is invoked to create a new process.
|
|
*/
|
|
|
|
#define pr_fmt(fmt) "%s: " fmt, __func__
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/fprobe.h>
|
|
#include <linux/sched/debug.h>
|
|
#include <linux/slab.h>
|
|
|
|
#define BACKTRACE_DEPTH 16
|
|
#define MAX_SYMBOL_LEN 4096
|
|
static struct fprobe sample_probe;
|
|
static unsigned long nhit;
|
|
|
|
static char symbol[MAX_SYMBOL_LEN] = "kernel_clone";
|
|
module_param_string(symbol, symbol, sizeof(symbol), 0644);
|
|
MODULE_PARM_DESC(symbol, "Probed symbol(s), given by comma separated symbols or a wildcard pattern.");
|
|
|
|
static char nosymbol[MAX_SYMBOL_LEN] = "";
|
|
module_param_string(nosymbol, nosymbol, sizeof(nosymbol), 0644);
|
|
MODULE_PARM_DESC(nosymbol, "Not-probed symbols, given by a wildcard pattern.");
|
|
|
|
static bool stackdump = true;
|
|
module_param(stackdump, bool, 0644);
|
|
MODULE_PARM_DESC(stackdump, "Enable stackdump.");
|
|
|
|
static bool use_trace = false;
|
|
module_param(use_trace, bool, 0644);
|
|
MODULE_PARM_DESC(use_trace, "Use trace_printk instead of printk. This is only for debugging.");
|
|
|
|
static void show_backtrace(void)
|
|
{
|
|
unsigned long stacks[BACKTRACE_DEPTH];
|
|
unsigned int len;
|
|
|
|
len = stack_trace_save(stacks, BACKTRACE_DEPTH, 2);
|
|
stack_trace_print(stacks, len, 24);
|
|
}
|
|
|
|
static int sample_entry_handler(struct fprobe *fp, unsigned long ip,
|
|
unsigned long ret_ip,
|
|
struct pt_regs *regs, void *data)
|
|
{
|
|
if (use_trace)
|
|
/*
|
|
* This is just an example, no kernel code should call
|
|
* trace_printk() except when actively debugging.
|
|
*/
|
|
trace_printk("Enter <%pS> ip = 0x%p\n", (void *)ip, (void *)ip);
|
|
else
|
|
pr_info("Enter <%pS> ip = 0x%p\n", (void *)ip, (void *)ip);
|
|
nhit++;
|
|
if (stackdump)
|
|
show_backtrace();
|
|
return 0;
|
|
}
|
|
|
|
static void sample_exit_handler(struct fprobe *fp, unsigned long ip,
|
|
unsigned long ret_ip, struct pt_regs *regs,
|
|
void *data)
|
|
{
|
|
unsigned long rip = ret_ip;
|
|
|
|
if (use_trace)
|
|
/*
|
|
* This is just an example, no kernel code should call
|
|
* trace_printk() except when actively debugging.
|
|
*/
|
|
trace_printk("Return from <%pS> ip = 0x%p to rip = 0x%p (%pS)\n",
|
|
(void *)ip, (void *)ip, (void *)rip, (void *)rip);
|
|
else
|
|
pr_info("Return from <%pS> ip = 0x%p to rip = 0x%p (%pS)\n",
|
|
(void *)ip, (void *)ip, (void *)rip, (void *)rip);
|
|
nhit++;
|
|
if (stackdump)
|
|
show_backtrace();
|
|
}
|
|
|
|
static int __init fprobe_init(void)
|
|
{
|
|
char *p, *symbuf = NULL;
|
|
const char **syms;
|
|
int ret, count, i;
|
|
|
|
sample_probe.entry_handler = sample_entry_handler;
|
|
sample_probe.exit_handler = sample_exit_handler;
|
|
|
|
if (strchr(symbol, '*')) {
|
|
/* filter based fprobe */
|
|
ret = register_fprobe(&sample_probe, symbol,
|
|
nosymbol[0] == '\0' ? NULL : nosymbol);
|
|
goto out;
|
|
} else if (!strchr(symbol, ',')) {
|
|
symbuf = symbol;
|
|
ret = register_fprobe_syms(&sample_probe, (const char **)&symbuf, 1);
|
|
goto out;
|
|
}
|
|
|
|
/* Comma separated symbols */
|
|
symbuf = kstrdup(symbol, GFP_KERNEL);
|
|
if (!symbuf)
|
|
return -ENOMEM;
|
|
p = symbuf;
|
|
count = 1;
|
|
while ((p = strchr(++p, ',')) != NULL)
|
|
count++;
|
|
|
|
pr_info("%d symbols found\n", count);
|
|
|
|
syms = kcalloc(count, sizeof(char *), GFP_KERNEL);
|
|
if (!syms) {
|
|
kfree(symbuf);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
p = symbuf;
|
|
for (i = 0; i < count; i++)
|
|
syms[i] = strsep(&p, ",");
|
|
|
|
ret = register_fprobe_syms(&sample_probe, syms, count);
|
|
kfree(syms);
|
|
kfree(symbuf);
|
|
out:
|
|
if (ret < 0)
|
|
pr_err("register_fprobe failed, returned %d\n", ret);
|
|
else
|
|
pr_info("Planted fprobe at %s\n", symbol);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void __exit fprobe_exit(void)
|
|
{
|
|
unregister_fprobe(&sample_probe);
|
|
|
|
pr_info("fprobe at %s unregistered. %ld times hit, %ld times missed\n",
|
|
symbol, nhit, sample_probe.nmissed);
|
|
}
|
|
|
|
module_init(fprobe_init)
|
|
module_exit(fprobe_exit)
|
|
MODULE_LICENSE("GPL");
|