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