ARM kprobes: let's enable it
[linux-2.6.git] / Documentation / kprobes.txt
1 Title   : Kernel Probes (Kprobes)
2 Authors : Jim Keniston <jkenisto@us.ibm.com>
3         : Prasanna S Panchamukhi <prasanna@in.ibm.com>
4
5 CONTENTS
6
7 1. Concepts: Kprobes, Jprobes, Return Probes
8 2. Architectures Supported
9 3. Configuring Kprobes
10 4. API Reference
11 5. Kprobes Features and Limitations
12 6. Probe Overhead
13 7. TODO
14 8. Kprobes Example
15 9. Jprobes Example
16 10. Kretprobes Example
17 Appendix A: The kprobes debugfs interface
18
19 1. Concepts: Kprobes, Jprobes, Return Probes
20
21 Kprobes enables you to dynamically break into any kernel routine and
22 collect debugging and performance information non-disruptively. You
23 can trap at almost any kernel code address, specifying a handler
24 routine to be invoked when the breakpoint is hit.
25
26 There are currently three types of probes: kprobes, jprobes, and
27 kretprobes (also called return probes).  A kprobe can be inserted
28 on virtually any instruction in the kernel.  A jprobe is inserted at
29 the entry to a kernel function, and provides convenient access to the
30 function's arguments.  A return probe fires when a specified function
31 returns.
32
33 In the typical case, Kprobes-based instrumentation is packaged as
34 a kernel module.  The module's init function installs ("registers")
35 one or more probes, and the exit function unregisters them.  A
36 registration function such as register_kprobe() specifies where
37 the probe is to be inserted and what handler is to be called when
38 the probe is hit.
39
40 The next three subsections explain how the different types of
41 probes work.  They explain certain things that you'll need to
42 know in order to make the best use of Kprobes -- e.g., the
43 difference between a pre_handler and a post_handler, and how
44 to use the maxactive and nmissed fields of a kretprobe.  But
45 if you're in a hurry to start using Kprobes, you can skip ahead
46 to section 2.
47
48 1.1 How Does a Kprobe Work?
49
50 When a kprobe is registered, Kprobes makes a copy of the probed
51 instruction and replaces the first byte(s) of the probed instruction
52 with a breakpoint instruction (e.g., int3 on i386 and x86_64).
53
54 When a CPU hits the breakpoint instruction, a trap occurs, the CPU's
55 registers are saved, and control passes to Kprobes via the
56 notifier_call_chain mechanism.  Kprobes executes the "pre_handler"
57 associated with the kprobe, passing the handler the addresses of the
58 kprobe struct and the saved registers.
59
60 Next, Kprobes single-steps its copy of the probed instruction.
61 (It would be simpler to single-step the actual instruction in place,
62 but then Kprobes would have to temporarily remove the breakpoint
63 instruction.  This would open a small time window when another CPU
64 could sail right past the probepoint.)
65
66 After the instruction is single-stepped, Kprobes executes the
67 "post_handler," if any, that is associated with the kprobe.
68 Execution then continues with the instruction following the probepoint.
69
70 1.2 How Does a Jprobe Work?
71
72 A jprobe is implemented using a kprobe that is placed on a function's
73 entry point.  It employs a simple mirroring principle to allow
74 seamless access to the probed function's arguments.  The jprobe
75 handler routine should have the same signature (arg list and return
76 type) as the function being probed, and must always end by calling
77 the Kprobes function jprobe_return().
78
79 Here's how it works.  When the probe is hit, Kprobes makes a copy of
80 the saved registers and a generous portion of the stack (see below).
81 Kprobes then points the saved instruction pointer at the jprobe's
82 handler routine, and returns from the trap.  As a result, control
83 passes to the handler, which is presented with the same register and
84 stack contents as the probed function.  When it is done, the handler
85 calls jprobe_return(), which traps again to restore the original stack
86 contents and processor state and switch to the probed function.
87
88 By convention, the callee owns its arguments, so gcc may produce code
89 that unexpectedly modifies that portion of the stack.  This is why
90 Kprobes saves a copy of the stack and restores it after the jprobe
91 handler has run.  Up to MAX_STACK_SIZE bytes are copied -- e.g.,
92 64 bytes on i386.
93
94 Note that the probed function's args may be passed on the stack
95 or in registers (e.g., for x86_64 or for an i386 fastcall function).
96 The jprobe will work in either case, so long as the handler's
97 prototype matches that of the probed function.
98
99 1.3 How Does a Return Probe Work?
100
101 When you call register_kretprobe(), Kprobes establishes a kprobe at
102 the entry to the function.  When the probed function is called and this
103 probe is hit, Kprobes saves a copy of the return address, and replaces
104 the return address with the address of a "trampoline."  The trampoline
105 is an arbitrary piece of code -- typically just a nop instruction.
106 At boot time, Kprobes registers a kprobe at the trampoline.
107
108 When the probed function executes its return instruction, control
109 passes to the trampoline and that probe is hit.  Kprobes' trampoline
110 handler calls the user-specified handler associated with the kretprobe,
111 then sets the saved instruction pointer to the saved return address,
112 and that's where execution resumes upon return from the trap.
113
114 While the probed function is executing, its return address is
115 stored in an object of type kretprobe_instance.  Before calling
116 register_kretprobe(), the user sets the maxactive field of the
117 kretprobe struct to specify how many instances of the specified
118 function can be probed simultaneously.  register_kretprobe()
119 pre-allocates the indicated number of kretprobe_instance objects.
120
121 For example, if the function is non-recursive and is called with a
122 spinlock held, maxactive = 1 should be enough.  If the function is
123 non-recursive and can never relinquish the CPU (e.g., via a semaphore
124 or preemption), NR_CPUS should be enough.  If maxactive <= 0, it is
125 set to a default value.  If CONFIG_PREEMPT is enabled, the default
126 is max(10, 2*NR_CPUS).  Otherwise, the default is NR_CPUS.
127
128 It's not a disaster if you set maxactive too low; you'll just miss
129 some probes.  In the kretprobe struct, the nmissed field is set to
130 zero when the return probe is registered, and is incremented every
131 time the probed function is entered but there is no kretprobe_instance
132 object available for establishing the return probe.
133
134 2. Architectures Supported
135
136 Kprobes, jprobes, and return probes are implemented on the following
137 architectures:
138
139 - i386
140 - x86_64 (AMD-64, EM64T)
141 - ppc64
142 - ia64 (Does not support probes on instruction slot1.)
143 - sparc64 (Return probes not yet implemented.)
144 - arm
145
146 3. Configuring Kprobes
147
148 When configuring the kernel using make menuconfig/xconfig/oldconfig,
149 ensure that CONFIG_KPROBES is set to "y".  Under "Instrumentation
150 Support", look for "Kprobes".
151
152 So that you can load and unload Kprobes-based instrumentation modules,
153 make sure "Loadable module support" (CONFIG_MODULES) and "Module
154 unloading" (CONFIG_MODULE_UNLOAD) are set to "y".
155
156 Also make sure that CONFIG_KALLSYMS and perhaps even CONFIG_KALLSYMS_ALL
157 are set to "y", since kallsyms_lookup_name() is used by the in-kernel
158 kprobe address resolution code.
159
160 If you need to insert a probe in the middle of a function, you may find
161 it useful to "Compile the kernel with debug info" (CONFIG_DEBUG_INFO),
162 so you can use "objdump -d -l vmlinux" to see the source-to-object
163 code mapping.
164
165 4. API Reference
166
167 The Kprobes API includes a "register" function and an "unregister"
168 function for each type of probe.  Here are terse, mini-man-page
169 specifications for these functions and the associated probe handlers
170 that you'll write.  See the latter half of this document for examples.
171
172 4.1 register_kprobe
173
174 #include <linux/kprobes.h>
175 int register_kprobe(struct kprobe *kp);
176
177 Sets a breakpoint at the address kp->addr.  When the breakpoint is
178 hit, Kprobes calls kp->pre_handler.  After the probed instruction
179 is single-stepped, Kprobe calls kp->post_handler.  If a fault
180 occurs during execution of kp->pre_handler or kp->post_handler,
181 or during single-stepping of the probed instruction, Kprobes calls
182 kp->fault_handler.  Any or all handlers can be NULL.
183
184 NOTE:
185 1. With the introduction of the "symbol_name" field to struct kprobe,
186 the probepoint address resolution will now be taken care of by the kernel.
187 The following will now work:
188
189         kp.symbol_name = "symbol_name";
190
191 (64-bit powerpc intricacies such as function descriptors are handled
192 transparently)
193
194 2. Use the "offset" field of struct kprobe if the offset into the symbol
195 to install a probepoint is known. This field is used to calculate the
196 probepoint.
197
198 3. Specify either the kprobe "symbol_name" OR the "addr". If both are
199 specified, kprobe registration will fail with -EINVAL.
200
201 4. With CISC architectures (such as i386 and x86_64), the kprobes code
202 does not validate if the kprobe.addr is at an instruction boundary.
203 Use "offset" with caution.
204
205 register_kprobe() returns 0 on success, or a negative errno otherwise.
206
207 User's pre-handler (kp->pre_handler):
208 #include <linux/kprobes.h>
209 #include <linux/ptrace.h>
210 int pre_handler(struct kprobe *p, struct pt_regs *regs);
211
212 Called with p pointing to the kprobe associated with the breakpoint,
213 and regs pointing to the struct containing the registers saved when
214 the breakpoint was hit.  Return 0 here unless you're a Kprobes geek.
215
216 User's post-handler (kp->post_handler):
217 #include <linux/kprobes.h>
218 #include <linux/ptrace.h>
219 void post_handler(struct kprobe *p, struct pt_regs *regs,
220         unsigned long flags);
221
222 p and regs are as described for the pre_handler.  flags always seems
223 to be zero.
224
225 User's fault-handler (kp->fault_handler):
226 #include <linux/kprobes.h>
227 #include <linux/ptrace.h>
228 int fault_handler(struct kprobe *p, struct pt_regs *regs, int trapnr);
229
230 p and regs are as described for the pre_handler.  trapnr is the
231 architecture-specific trap number associated with the fault (e.g.,
232 on i386, 13 for a general protection fault or 14 for a page fault).
233 Returns 1 if it successfully handled the exception.
234
235 4.2 register_jprobe
236
237 #include <linux/kprobes.h>
238 int register_jprobe(struct jprobe *jp)
239
240 Sets a breakpoint at the address jp->kp.addr, which must be the address
241 of the first instruction of a function.  When the breakpoint is hit,
242 Kprobes runs the handler whose address is jp->entry.
243
244 The handler should have the same arg list and return type as the probed
245 function; and just before it returns, it must call jprobe_return().
246 (The handler never actually returns, since jprobe_return() returns
247 control to Kprobes.)  If the probed function is declared asmlinkage,
248 fastcall, or anything else that affects how args are passed, the
249 handler's declaration must match.
250
251 register_jprobe() returns 0 on success, or a negative errno otherwise.
252
253 4.3 register_kretprobe
254
255 #include <linux/kprobes.h>
256 int register_kretprobe(struct kretprobe *rp);
257
258 Establishes a return probe for the function whose address is
259 rp->kp.addr.  When that function returns, Kprobes calls rp->handler.
260 You must set rp->maxactive appropriately before you call
261 register_kretprobe(); see "How Does a Return Probe Work?" for details.
262
263 register_kretprobe() returns 0 on success, or a negative errno
264 otherwise.
265
266 User's return-probe handler (rp->handler):
267 #include <linux/kprobes.h>
268 #include <linux/ptrace.h>
269 int kretprobe_handler(struct kretprobe_instance *ri, struct pt_regs *regs);
270
271 regs is as described for kprobe.pre_handler.  ri points to the
272 kretprobe_instance object, of which the following fields may be
273 of interest:
274 - ret_addr: the return address
275 - rp: points to the corresponding kretprobe object
276 - task: points to the corresponding task struct
277
278 The regs_return_value(regs) macro provides a simple abstraction to
279 extract the return value from the appropriate register as defined by
280 the architecture's ABI.
281
282 The handler's return value is currently ignored.
283
284 4.4 unregister_*probe
285
286 #include <linux/kprobes.h>
287 void unregister_kprobe(struct kprobe *kp);
288 void unregister_jprobe(struct jprobe *jp);
289 void unregister_kretprobe(struct kretprobe *rp);
290
291 Removes the specified probe.  The unregister function can be called
292 at any time after the probe has been registered.
293
294 5. Kprobes Features and Limitations
295
296 Kprobes allows multiple probes at the same address.  Currently,
297 however, there cannot be multiple jprobes on the same function at
298 the same time.
299
300 In general, you can install a probe anywhere in the kernel.
301 In particular, you can probe interrupt handlers.  Known exceptions
302 are discussed in this section.
303
304 The register_*probe functions will return -EINVAL if you attempt
305 to install a probe in the code that implements Kprobes (mostly
306 kernel/kprobes.c and arch/*/kernel/kprobes.c, but also functions such
307 as do_page_fault and notifier_call_chain).
308
309 If you install a probe in an inline-able function, Kprobes makes
310 no attempt to chase down all inline instances of the function and
311 install probes there.  gcc may inline a function without being asked,
312 so keep this in mind if you're not seeing the probe hits you expect.
313
314 A probe handler can modify the environment of the probed function
315 -- e.g., by modifying kernel data structures, or by modifying the
316 contents of the pt_regs struct (which are restored to the registers
317 upon return from the breakpoint).  So Kprobes can be used, for example,
318 to install a bug fix or to inject faults for testing.  Kprobes, of
319 course, has no way to distinguish the deliberately injected faults
320 from the accidental ones.  Don't drink and probe.
321
322 Kprobes makes no attempt to prevent probe handlers from stepping on
323 each other -- e.g., probing printk() and then calling printk() from a
324 probe handler.  If a probe handler hits a probe, that second probe's
325 handlers won't be run in that instance, and the kprobe.nmissed member
326 of the second probe will be incremented.
327
328 As of Linux v2.6.15-rc1, multiple handlers (or multiple instances of
329 the same handler) may run concurrently on different CPUs.
330
331 Kprobes does not use mutexes or allocate memory except during
332 registration and unregistration.
333
334 Probe handlers are run with preemption disabled.  Depending on the
335 architecture, handlers may also run with interrupts disabled.  In any
336 case, your handler should not yield the CPU (e.g., by attempting to
337 acquire a semaphore).
338
339 Since a return probe is implemented by replacing the return
340 address with the trampoline's address, stack backtraces and calls
341 to __builtin_return_address() will typically yield the trampoline's
342 address instead of the real return address for kretprobed functions.
343 (As far as we can tell, __builtin_return_address() is used only
344 for instrumentation and error reporting.)
345
346 If the number of times a function is called does not match the number
347 of times it returns, registering a return probe on that function may
348 produce undesirable results. In such a case, a line:
349 kretprobe BUG!: Processing kretprobe d000000000041aa8 @ c00000000004f48c
350 gets printed. With this information, one will be able to correlate the
351 exact instance of the kretprobe that caused the problem. We have the
352 do_exit() case covered. do_execve() and do_fork() are not an issue.
353 We're unaware of other specific cases where this could be a problem.
354
355 If, upon entry to or exit from a function, the CPU is running on
356 a stack other than that of the current task, registering a return
357 probe on that function may produce undesirable results.  For this
358 reason, Kprobes doesn't support return probes (or kprobes or jprobes)
359 on the x86_64 version of __switch_to(); the registration functions
360 return -EINVAL.
361
362 6. Probe Overhead
363
364 On a typical CPU in use in 2005, a kprobe hit takes 0.5 to 1.0
365 microseconds to process.  Specifically, a benchmark that hits the same
366 probepoint repeatedly, firing a simple handler each time, reports 1-2
367 million hits per second, depending on the architecture.  A jprobe or
368 return-probe hit typically takes 50-75% longer than a kprobe hit.
369 When you have a return probe set on a function, adding a kprobe at
370 the entry to that function adds essentially no overhead.
371
372 Here are sample overhead figures (in usec) for different architectures.
373 k = kprobe; j = jprobe; r = return probe; kr = kprobe + return probe
374 on same function; jr = jprobe + return probe on same function
375
376 i386: Intel Pentium M, 1495 MHz, 2957.31 bogomips
377 k = 0.57 usec; j = 1.00; r = 0.92; kr = 0.99; jr = 1.40
378
379 x86_64: AMD Opteron 246, 1994 MHz, 3971.48 bogomips
380 k = 0.49 usec; j = 0.76; r = 0.80; kr = 0.82; jr = 1.07
381
382 ppc64: POWER5 (gr), 1656 MHz (SMT disabled, 1 virtual CPU per physical CPU)
383 k = 0.77 usec; j = 1.31; r = 1.26; kr = 1.45; jr = 1.99
384
385 7. TODO
386
387 a. SystemTap (http://sourceware.org/systemtap): Provides a simplified
388 programming interface for probe-based instrumentation.  Try it out.
389 b. Kernel return probes for sparc64.
390 c. Support for other architectures.
391 d. User-space probes.
392 e. Watchpoint probes (which fire on data references).
393
394 8. Kprobes Example
395
396 Here's a sample kernel module showing the use of kprobes to dump a
397 stack trace and selected i386 registers when do_fork() is called.
398 ----- cut here -----
399 /*kprobe_example.c*/
400 #include <linux/kernel.h>
401 #include <linux/module.h>
402 #include <linux/kprobes.h>
403 #include <linux/sched.h>
404
405 /*For each probe you need to allocate a kprobe structure*/
406 static struct kprobe kp;
407
408 /*kprobe pre_handler: called just before the probed instruction is executed*/
409 int handler_pre(struct kprobe *p, struct pt_regs *regs)
410 {
411         printk("pre_handler: p->addr=0x%p, eip=%lx, eflags=0x%lx\n",
412                 p->addr, regs->eip, regs->eflags);
413         dump_stack();
414         return 0;
415 }
416
417 /*kprobe post_handler: called after the probed instruction is executed*/
418 void handler_post(struct kprobe *p, struct pt_regs *regs, unsigned long flags)
419 {
420         printk("post_handler: p->addr=0x%p, eflags=0x%lx\n",
421                 p->addr, regs->eflags);
422 }
423
424 /* fault_handler: this is called if an exception is generated for any
425  * instruction within the pre- or post-handler, or when Kprobes
426  * single-steps the probed instruction.
427  */
428 int handler_fault(struct kprobe *p, struct pt_regs *regs, int trapnr)
429 {
430         printk("fault_handler: p->addr=0x%p, trap #%dn",
431                 p->addr, trapnr);
432         /* Return 0 because we don't handle the fault. */
433         return 0;
434 }
435
436 static int __init kprobe_init(void)
437 {
438         int ret;
439         kp.pre_handler = handler_pre;
440         kp.post_handler = handler_post;
441         kp.fault_handler = handler_fault;
442         kp.symbol_name = "do_fork";
443
444         ret = register_kprobe(&kp);
445         if (ret < 0) {
446                 printk("register_kprobe failed, returned %d\n", ret);
447                 return ret;
448         }
449         printk("kprobe registered\n");
450         return 0;
451 }
452
453 static void __exit kprobe_exit(void)
454 {
455         unregister_kprobe(&kp);
456         printk("kprobe unregistered\n");
457 }
458
459 module_init(kprobe_init)
460 module_exit(kprobe_exit)
461 MODULE_LICENSE("GPL");
462 ----- cut here -----
463
464 You can build the kernel module, kprobe-example.ko, using the following
465 Makefile:
466 ----- cut here -----
467 obj-m := kprobe-example.o
468 KDIR := /lib/modules/$(shell uname -r)/build
469 PWD := $(shell pwd)
470 default:
471         $(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules
472 clean:
473         rm -f *.mod.c *.ko *.o
474 ----- cut here -----
475
476 $ make
477 $ su -
478 ...
479 # insmod kprobe-example.ko
480
481 You will see the trace data in /var/log/messages and on the console
482 whenever do_fork() is invoked to create a new process.
483
484 9. Jprobes Example
485
486 Here's a sample kernel module showing the use of jprobes to dump
487 the arguments of do_fork().
488 ----- cut here -----
489 /*jprobe-example.c */
490 #include <linux/kernel.h>
491 #include <linux/module.h>
492 #include <linux/fs.h>
493 #include <linux/uio.h>
494 #include <linux/kprobes.h>
495
496 /*
497  * Jumper probe for do_fork.
498  * Mirror principle enables access to arguments of the probed routine
499  * from the probe handler.
500  */
501
502 /* Proxy routine having the same arguments as actual do_fork() routine */
503 long jdo_fork(unsigned long clone_flags, unsigned long stack_start,
504               struct pt_regs *regs, unsigned long stack_size,
505               int __user * parent_tidptr, int __user * child_tidptr)
506 {
507         printk("jprobe: clone_flags=0x%lx, stack_size=0x%lx, regs=0x%p\n",
508                clone_flags, stack_size, regs);
509         /* Always end with a call to jprobe_return(). */
510         jprobe_return();
511         /*NOTREACHED*/
512         return 0;
513 }
514
515 static struct jprobe my_jprobe = {
516         .entry = jdo_fork
517 };
518
519 static int __init jprobe_init(void)
520 {
521         int ret;
522         my_jprobe.kp.symbol_name = "do_fork";
523
524         if ((ret = register_jprobe(&my_jprobe)) <0) {
525                 printk("register_jprobe failed, returned %d\n", ret);
526                 return -1;
527         }
528         printk("Planted jprobe at %p, handler addr %p\n",
529                my_jprobe.kp.addr, my_jprobe.entry);
530         return 0;
531 }
532
533 static void __exit jprobe_exit(void)
534 {
535         unregister_jprobe(&my_jprobe);
536         printk("jprobe unregistered\n");
537 }
538
539 module_init(jprobe_init)
540 module_exit(jprobe_exit)
541 MODULE_LICENSE("GPL");
542 ----- cut here -----
543
544 Build and insert the kernel module as shown in the above kprobe
545 example.  You will see the trace data in /var/log/messages and on
546 the console whenever do_fork() is invoked to create a new process.
547 (Some messages may be suppressed if syslogd is configured to
548 eliminate duplicate messages.)
549
550 10. Kretprobes Example
551
552 Here's a sample kernel module showing the use of return probes to
553 report failed calls to sys_open().
554 ----- cut here -----
555 /*kretprobe-example.c*/
556 #include <linux/kernel.h>
557 #include <linux/module.h>
558 #include <linux/kprobes.h>
559
560 static const char *probed_func = "sys_open";
561
562 /* Return-probe handler: If the probed function fails, log the return value. */
563 static int ret_handler(struct kretprobe_instance *ri, struct pt_regs *regs)
564 {
565         int retval = regs_return_value(regs);
566         if (retval < 0) {
567                 printk("%s returns %d\n", probed_func, retval);
568         }
569         return 0;
570 }
571
572 static struct kretprobe my_kretprobe = {
573         .handler = ret_handler,
574         /* Probe up to 20 instances concurrently. */
575         .maxactive = 20
576 };
577
578 static int __init kretprobe_init(void)
579 {
580         int ret;
581         my_kretprobe.kp.symbol_name = (char *)probed_func;
582
583         if ((ret = register_kretprobe(&my_kretprobe)) < 0) {
584                 printk("register_kretprobe failed, returned %d\n", ret);
585                 return -1;
586         }
587         printk("Planted return probe at %p\n", my_kretprobe.kp.addr);
588         return 0;
589 }
590
591 static void __exit kretprobe_exit(void)
592 {
593         unregister_kretprobe(&my_kretprobe);
594         printk("kretprobe unregistered\n");
595         /* nmissed > 0 suggests that maxactive was set too low. */
596         printk("Missed probing %d instances of %s\n",
597                 my_kretprobe.nmissed, probed_func);
598 }
599
600 module_init(kretprobe_init)
601 module_exit(kretprobe_exit)
602 MODULE_LICENSE("GPL");
603 ----- cut here -----
604
605 Build and insert the kernel module as shown in the above kprobe
606 example.  You will see the trace data in /var/log/messages and on the
607 console whenever sys_open() returns a negative value.  (Some messages
608 may be suppressed if syslogd is configured to eliminate duplicate
609 messages.)
610
611 For additional information on Kprobes, refer to the following URLs:
612 http://www-106.ibm.com/developerworks/library/l-kprobes.html?ca=dgr-lnxw42Kprobe
613 http://www.redhat.com/magazine/005mar05/features/kprobes/
614 http://www-users.cs.umn.edu/~boutcher/kprobes/
615 http://www.linuxsymposium.org/2006/linuxsymposium_procv2.pdf (pages 101-115)
616
617
618 Appendix A: The kprobes debugfs interface
619
620 With recent kernels (> 2.6.20) the list of registered kprobes is visible
621 under the /debug/kprobes/ directory (assuming debugfs is mounted at /debug).
622
623 /debug/kprobes/list: Lists all registered probes on the system
624
625 c015d71a  k  vfs_read+0x0
626 c011a316  j  do_fork+0x0
627 c03dedc5  r  tcp_v4_rcv+0x0
628
629 The first column provides the kernel address where the probe is inserted.
630 The second column identifies the type of probe (k - kprobe, r - kretprobe
631 and j - jprobe), while the third column specifies the symbol+offset of
632 the probe. If the probed function belongs to a module, the module name
633 is also specified.
634
635 /debug/kprobes/enabled: Turn kprobes ON/OFF
636
637 Provides a knob to globally turn registered kprobes ON or OFF. By default,
638 all kprobes are enabled. By echoing "0" to this file, all registered probes
639 will be disarmed, till such time a "1" is echoed to this file.