Documentation/tracepoints.txt

   1                      Using the Linux Kernel Tracepoints
   2
   3                             Mathieu Desnoyers
   4
   5
   6 This document introduces Linux Kernel Tracepoints and their use. It provides
   7 examples of how to insert tracepoints in the kernel and connect probe functions
   8 to them and provides some examples of probe functions.
   9
  10
  11 * Purpose of tracepoints
  12
  13 A tracepoint placed in code provides a hook to call a function (probe) that you
  14 can provide at runtime. A tracepoint can be "on" (a probe is connected to it) or
  15 "off" (no probe is attached). When a tracepoint is "off" it has no effect,
  16 except for adding a tiny time penalty (checking a condition for a branch) and
  17 space penalty (adding a few bytes for the function call at the end of the
  18 instrumented function and adds a data structure in a separate section).  When a
  19 tracepoint is "on", the function you provide is called each time the tracepoint
  20 is executed, in the execution context of the caller. When the function provided
  21 ends its execution, it returns to the caller (continuing from the tracepoint
  22 site).
  23
  24 You can put tracepoints at important locations in the code. They are
  25 lightweight hooks that can pass an arbitrary number of parameters,
  26 which prototypes are described in a tracepoint declaration placed in a header
  27 file.
  28
  29 They can be used for tracing and performance accounting.
  30
  31
  32 * Usage
  33
  34 Two elements are required for tracepoints :
  35
  36 - A tracepoint definition, placed in a header file.
  37 - The tracepoint statement, in C code.
  38
  39 In order to use tracepoints, you should include linux/tracepoint.h.
  40
  41 In include/trace/subsys.h :
  42
  43 #include <linux/tracepoint.h>
  44
  45 DECLARE_TRACE(subsys_eventname,
  46         TPPTOTO(int firstarg, struct task_struct *p),
  47         TPARGS(firstarg, p));
  48
  49 In subsys/file.c (where the tracing statement must be added) :
  50
  51 #include <trace/subsys.h>
  52
  53 DEFINE_TRACE(subsys_eventname);
  54
  55 void somefct(void)
  56 {
  57         ...
  58         trace_subsys_eventname(arg, task);
  59         ...
  60 }
  61
  62 Where :
  63 - subsys_eventname is an identifier unique to your event
  64     - subsys is the name of your subsystem.
  65     - eventname is the name of the event to trace.
  66 - TPPTOTO(int firstarg, struct task_struct *p) is the prototype of the function
  67   called by this tracepoint.
  68 - TPARGS(firstarg, p) are the parameters names, same as found in the prototype.
  69
  70 Connecting a function (probe) to a tracepoint is done by providing a probe
  71 (function to call) for the specific tracepoint through
  72 register_trace_subsys_eventname().  Removing a probe is done through
  73 unregister_trace_subsys_eventname(); it will remove the probe.
  74 marker_synchronize_unregister() must be called before the end of the module exit
  75 function to make sure there is no caller left using the probe. This, and the
  76 fact that preemption is disabled around the probe call, make sure that probe
  77 removal and module unload are safe. See the "Probe example" section below for a
  78 sample probe module.
  79
  80 The tracepoint mechanism supports inserting multiple instances of the same
  81 tracepoint, but a single definition must be made of a given tracepoint name over
  82 all the kernel to make sure no type conflict will occur. Name mangling of the
  83 tracepoints is done using the prototypes to make sure typing is correct.
  84 Verification of probe type correctness is done at the registration site by the
  85 compiler. Tracepoints can be put in inline functions, inlined static functions,
  86 and unrolled loops as well as regular functions.
  87
  88 The naming scheme "subsys_event" is suggested here as a convention intended
  89 to limit collisions. Tracepoint names are global to the kernel: they are
  90 considered as being the same whether they are in the core kernel image or in
  91 modules.
  92
  93 If the tracepoint has to be used in kernel modules, an
  94 EXPORT_TRACEPOINT_SYMBOL_GPL() or EXPORT_TRACEPOINT_SYMBOL() can be used to
  95 export the defined tracepoints.
  96
  97 * Probe / tracepoint example
  98
  99 See the example provided in samples/tracepoints/src
 100
 101 Compile them with your kernel.
 102
 103 Run, as root :
 104 modprobe tracepoint-example (insmod order is not important)
 105 modprobe tracepoint-probe-example
 106 cat /proc/tracepoint-example (returns an expected error)
 107 rmmod tracepoint-example tracepoint-probe-example
 108 dmesg