samples/fprobe/fprobe_example.c

   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
  23 struct fprobe sample_probe;
  24
  25 static char symbol[MAX_SYMBOL_LEN] = "kernel_clone";
  26 module_param_string(symbol, symbol, sizeof(symbol), 0644);
  27 static char nosymbol[MAX_SYMBOL_LEN] = "";
  28 module_param_string(nosymbol, nosymbol, sizeof(nosymbol), 0644);
  29 static bool stackdump = true;
  30 module_param(stackdump, bool, 0644);
  31
  32 static void show_backtrace(void)
  33 {
  34         unsigned long stacks[BACKTRACE_DEPTH];
  35         unsigned int len;
  36
  37         len = stack_trace_save(stacks, BACKTRACE_DEPTH, 2);
  38         stack_trace_print(stacks, len, 24);
  39 }
  40
  41 static void sample_entry_handler(struct fprobe *fp, unsigned long ip, struct pt_regs *regs)
  42 {
  43         pr_info("Enter <%pS> ip = 0x%p\n", (void *)ip, (void *)ip);
  44         if (stackdump)
  45                 show_backtrace();
  46 }
  47
  48 static void sample_exit_handler(struct fprobe *fp, unsigned long ip, struct pt_regs *regs)
  49 {
  50         unsigned long rip = instruction_pointer(regs);
  51
  52         pr_info("Return from <%pS> ip = 0x%p to rip = 0x%p (%pS)\n",
  53                 (void *)ip, (void *)ip, (void *)rip, (void *)rip);
  54         if (stackdump)
  55                 show_backtrace();
  56 }
  57
  58 static int __init fprobe_init(void)
  59 {
  60         char *p, *symbuf = NULL;
  61         const char **syms;
  62         int ret, count, i;
  63
  64         sample_probe.entry_handler = sample_entry_handler;
  65         sample_probe.exit_handler = sample_exit_handler;
  66
  67         if (strchr(symbol, '*')) {
  68                 /* filter based fprobe */
  69                 ret = register_fprobe(&sample_probe, symbol,
  70                                       nosymbol[0] == '\0' ? NULL : nosymbol);
  71                 goto out;
  72         } else if (!strchr(symbol, ',')) {
  73                 symbuf = symbol;
  74                 ret = register_fprobe_syms(&sample_probe, (const char **)&symbuf, 1);
  75                 goto out;
  76         }
  77
  78         /* Comma separated symbols */
  79         symbuf = kstrdup(symbol, GFP_KERNEL);
  80         if (!symbuf)
  81                 return -ENOMEM;
  82         p = symbuf;
  83         count = 1;
  84         while ((p = strchr(++p, ',')) != NULL)
  85                 count++;
  86
  87         pr_info("%d symbols found\n", count);
  88
  89         syms = kcalloc(count, sizeof(char *), GFP_KERNEL);
  90         if (!syms) {
  91                 kfree(symbuf);
  92                 return -ENOMEM;
  93         }
  94
  95         p = symbuf;
  96         for (i = 0; i < count; i++)
  97                 syms[i] = strsep(&p, ",");
  98
  99         ret = register_fprobe_syms(&sample_probe, syms, count);
 100         kfree(syms);
 101         kfree(symbuf);
 102 out:
 103         if (ret < 0)
 104                 pr_err("register_fprobe failed, returned %d\n", ret);
 105         else
 106                 pr_info("Planted fprobe at %s\n", symbol);
 107
 108         return ret;
 109 }
 110
 111 static void __exit fprobe_exit(void)
 112 {
 113         unregister_fprobe(&sample_probe);
 114
 115         pr_info("fprobe at %s unregistered\n", symbol);
 116 }
 117
 118 module_init(fprobe_init)
 119 module_exit(fprobe_exit)
 120 MODULE_LICENSE("GPL");