?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.8-rc7
[cris-mirror.git] / kernel / trace / trace_uprobe.c
blobc86e6d4f67fbfac4a81c6c58d7194afa7603f7e5
1 /*
2 * uprobes-based tracing events
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 *
17 * Copyright (C) IBM Corporation, 2010-2012
18 * Author: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
19 */
20
21 #include <linux/module.h>
22 #include <linux/uaccess.h>
23 #include <linux/uprobes.h>
24 #include <linux/namei.h>
25 #include <linux/string.h>
26
27 #include "trace_probe.h"
28
29 #define UPROBE_EVENT_SYSTEM "uprobes"
30
31 /*
32 * uprobe event core functions
33 */
34 struct trace_uprobe;
35 struct uprobe_trace_consumer {
36 struct uprobe_consumer cons;
37 struct trace_uprobe *tu;
38 };
39
40 struct trace_uprobe {
41 struct list_head list;
42 struct ftrace_event_class class;
43 struct ftrace_event_call call;
44 struct uprobe_trace_consumer *consumer;
45 struct inode *inode;
46 char *filename;
47 unsigned long offset;
48 unsigned long nhit;
49 unsigned int flags; /* For TP_FLAG_* */
50 ssize_t size; /* trace entry size */
51 unsigned int nr_args;
52 struct probe_arg args[];
53 };
54
55 #define SIZEOF_TRACE_UPROBE(n) \
56 (offsetof(struct trace_uprobe, args) + \
57 (sizeof(struct probe_arg) * (n)))
58
59 static int register_uprobe_event(struct trace_uprobe *tu);
60 static void unregister_uprobe_event(struct trace_uprobe *tu);
61
62 static DEFINE_MUTEX(uprobe_lock);
63 static LIST_HEAD(uprobe_list);
64
65 static int uprobe_dispatcher(struct uprobe_consumer *con, struct pt_regs *regs);
66
67 /*
68 * Allocate new trace_uprobe and initialize it (including uprobes).
69 */
70 static struct trace_uprobe *
71 alloc_trace_uprobe(const char *group, const char *event, int nargs)
72 {
73 struct trace_uprobe *tu;
74
75 if (!event || !is_good_name(event))
76 return ERR_PTR(-EINVAL);
77
78 if (!group || !is_good_name(group))
79 return ERR_PTR(-EINVAL);
80
81 tu = kzalloc(SIZEOF_TRACE_UPROBE(nargs), GFP_KERNEL);
82 if (!tu)
83 return ERR_PTR(-ENOMEM);
84
85 tu->call.class = &tu->class;
86 tu->call.name = kstrdup(event, GFP_KERNEL);
87 if (!tu->call.name)
88 goto error;
89
90 tu->class.system = kstrdup(group, GFP_KERNEL);
91 if (!tu->class.system)
92 goto error;
93
94 INIT_LIST_HEAD(&tu->list);
95 return tu;
96
97 error:
98 kfree(tu->call.name);
99 kfree(tu);
100
101 return ERR_PTR(-ENOMEM);
102 }
103
104 static void free_trace_uprobe(struct trace_uprobe *tu)
105 {
106 int i;
107
108 for (i = 0; i < tu->nr_args; i++)
109 traceprobe_free_probe_arg(&tu->args[i]);
110
111 iput(tu->inode);
112 kfree(tu->call.class->system);
113 kfree(tu->call.name);
114 kfree(tu->filename);
115 kfree(tu);
116 }
117
118 static struct trace_uprobe *find_probe_event(const char *event, const char *group)
119 {
120 struct trace_uprobe *tu;
121
122 list_for_each_entry(tu, &uprobe_list, list)
123 if (strcmp(tu->call.name, event) == 0 &&
124 strcmp(tu->call.class->system, group) == 0)
125 return tu;
126
127 return NULL;
128 }
129
130 /* Unregister a trace_uprobe and probe_event: call with locking uprobe_lock */
131 static void unregister_trace_uprobe(struct trace_uprobe *tu)
132 {
133 list_del(&tu->list);
134 unregister_uprobe_event(tu);
135 free_trace_uprobe(tu);
136 }
137
138 /* Register a trace_uprobe and probe_event */
139 static int register_trace_uprobe(struct trace_uprobe *tu)
140 {
141 struct trace_uprobe *old_tp;
142 int ret;
143
144 mutex_lock(&uprobe_lock);
145
146 /* register as an event */
147 old_tp = find_probe_event(tu->call.name, tu->call.class->system);
148 if (old_tp)
149 /* delete old event */
150 unregister_trace_uprobe(old_tp);
151
152 ret = register_uprobe_event(tu);
153 if (ret) {
154 pr_warning("Failed to register probe event(%d)\n", ret);
155 goto end;
156 }
157
158 list_add_tail(&tu->list, &uprobe_list);
159
160 end:
161 mutex_unlock(&uprobe_lock);
162
163 return ret;
164 }
165
166 /*
167 * Argument syntax:
168 * - Add uprobe: p[:[GRP/]EVENT] PATH:SYMBOL[+offs] [FETCHARGS]
169 *
170 * - Remove uprobe: -:[GRP/]EVENT
171 */
172 static int create_trace_uprobe(int argc, char **argv)
173 {
174 struct trace_uprobe *tu;
175 struct inode *inode;
176 char *arg, *event, *group, *filename;
177 char buf[MAX_EVENT_NAME_LEN];
178 struct path path;
179 unsigned long offset;
180 bool is_delete;
181 int i, ret;
182
183 inode = NULL;
184 ret = 0;
185 is_delete = false;
186 event = NULL;
187 group = NULL;
188
189 /* argc must be >= 1 */
190 if (argv[0][0] == '-')
191 is_delete = true;
192 else if (argv[0][0] != 'p') {
193 pr_info("Probe definition must be started with 'p' or '-'.\n");
194 return -EINVAL;
195 }
196
197 if (argv[0][1] == ':') {
198 event = &argv[0][2];
199 arg = strchr(event, '/');
200
201 if (arg) {
202 group = event;
203 event = arg + 1;
204 event[-1] = '\0';
205
206 if (strlen(group) == 0) {
207 pr_info("Group name is not specified\n");
208 return -EINVAL;
209 }
210 }
211 if (strlen(event) == 0) {
212 pr_info("Event name is not specified\n");
213 return -EINVAL;
214 }
215 }
216 if (!group)
217 group = UPROBE_EVENT_SYSTEM;
218
219 if (is_delete) {
220 if (!event) {
221 pr_info("Delete command needs an event name.\n");
222 return -EINVAL;
223 }
224 mutex_lock(&uprobe_lock);
225 tu = find_probe_event(event, group);
226
227 if (!tu) {
228 mutex_unlock(&uprobe_lock);
229 pr_info("Event %s/%s doesn't exist.\n", group, event);
230 return -ENOENT;
231 }
232 /* delete an event */
233 unregister_trace_uprobe(tu);
234 mutex_unlock(&uprobe_lock);
235 return 0;
236 }
237
238 if (argc < 2) {
239 pr_info("Probe point is not specified.\n");
240 return -EINVAL;
241 }
242 if (isdigit(argv[1][0])) {
243 pr_info("probe point must be have a filename.\n");
244 return -EINVAL;
245 }
246 arg = strchr(argv[1], ':');
247 if (!arg)
248 goto fail_address_parse;
249
250 *arg++ = '\0';
251 filename = argv[1];
252 ret = kern_path(filename, LOOKUP_FOLLOW, &path);
253 if (ret)
254 goto fail_address_parse;
255
256 ret = kstrtoul(arg, 0, &offset);
257 if (ret)
258 goto fail_address_parse;
259
260 inode = igrab(path.dentry->d_inode);
261
262 argc -= 2;
263 argv += 2;
264
265 /* setup a probe */
266 if (!event) {
267 char *tail;
268 char *ptr;
269
270 tail = kstrdup(kbasename(filename), GFP_KERNEL);
271 if (!tail) {
272 ret = -ENOMEM;
273 goto fail_address_parse;
274 }
275
276 ptr = strpbrk(tail, ".-_");
277 if (ptr)
278 *ptr = '\0';
279
280 snprintf(buf, MAX_EVENT_NAME_LEN, "%c_%s_0x%lx", 'p', tail, offset);
281 event = buf;
282 kfree(tail);
283 }
284
285 tu = alloc_trace_uprobe(group, event, argc);
286 if (IS_ERR(tu)) {
287 pr_info("Failed to allocate trace_uprobe.(%d)\n", (int)PTR_ERR(tu));
288 ret = PTR_ERR(tu);
289 goto fail_address_parse;
290 }
291 tu->offset = offset;
292 tu->inode = inode;
293 tu->filename = kstrdup(filename, GFP_KERNEL);
294
295 if (!tu->filename) {
296 pr_info("Failed to allocate filename.\n");
297 ret = -ENOMEM;
298 goto error;
299 }
300
301 /* parse arguments */
302 ret = 0;
303 for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) {
304 /* Increment count for freeing args in error case */
305 tu->nr_args++;
306
307 /* Parse argument name */
308 arg = strchr(argv[i], '=');
309 if (arg) {
310 *arg++ = '\0';
311 tu->args[i].name = kstrdup(argv[i], GFP_KERNEL);
312 } else {
313 arg = argv[i];
314 /* If argument name is omitted, set "argN" */
315 snprintf(buf, MAX_EVENT_NAME_LEN, "arg%d", i + 1);
316 tu->args[i].name = kstrdup(buf, GFP_KERNEL);
317 }
318
319 if (!tu->args[i].name) {
320 pr_info("Failed to allocate argument[%d] name.\n", i);
321 ret = -ENOMEM;
322 goto error;
323 }
324
325 if (!is_good_name(tu->args[i].name)) {
326 pr_info("Invalid argument[%d] name: %s\n", i, tu->args[i].name);
327 ret = -EINVAL;
328 goto error;
329 }
330
331 if (traceprobe_conflict_field_name(tu->args[i].name, tu->args, i)) {
332 pr_info("Argument[%d] name '%s' conflicts with "
333 "another field.\n", i, argv[i]);
334 ret = -EINVAL;
335 goto error;
336 }
337
338 /* Parse fetch argument */
339 ret = traceprobe_parse_probe_arg(arg, &tu->size, &tu->args[i], false, false);
340 if (ret) {
341 pr_info("Parse error at argument[%d]. (%d)\n", i, ret);
342 goto error;
343 }
344 }
345
346 ret = register_trace_uprobe(tu);
347 if (ret)
348 goto error;
349 return 0;
350
351 error:
352 free_trace_uprobe(tu);
353 return ret;
354
355 fail_address_parse:
356 if (inode)
357 iput(inode);
358
359 pr_info("Failed to parse address.\n");
360
361 return ret;
362 }
363
364 static void cleanup_all_probes(void)
365 {
366 struct trace_uprobe *tu;
367
368 mutex_lock(&uprobe_lock);
369 while (!list_empty(&uprobe_list)) {
370 tu = list_entry(uprobe_list.next, struct trace_uprobe, list);
371 unregister_trace_uprobe(tu);
372 }
373 mutex_unlock(&uprobe_lock);
374 }
375
376 /* Probes listing interfaces */
377 static void *probes_seq_start(struct seq_file *m, loff_t *pos)
378 {
379 mutex_lock(&uprobe_lock);
380 return seq_list_start(&uprobe_list, *pos);
381 }
382
383 static void *probes_seq_next(struct seq_file *m, void *v, loff_t *pos)
384 {
385 return seq_list_next(v, &uprobe_list, pos);
386 }
387
388 static void probes_seq_stop(struct seq_file *m, void *v)
389 {
390 mutex_unlock(&uprobe_lock);
391 }
392
393 static int probes_seq_show(struct seq_file *m, void *v)
394 {
395 struct trace_uprobe *tu = v;
396 int i;
397
398 seq_printf(m, "p:%s/%s", tu->call.class->system, tu->call.name);
399 seq_printf(m, " %s:0x%p", tu->filename, (void *)tu->offset);
400
401 for (i = 0; i < tu->nr_args; i++)
402 seq_printf(m, " %s=%s", tu->args[i].name, tu->args[i].comm);
403
404 seq_printf(m, "\n");
405 return 0;
406 }
407
408 static const struct seq_operations probes_seq_op = {
409 .start = probes_seq_start,
410 .next = probes_seq_next,
411 .stop = probes_seq_stop,
412 .show = probes_seq_show
413 };
414
415 static int probes_open(struct inode *inode, struct file *file)
416 {
417 if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC))
418 cleanup_all_probes();
419
420 return seq_open(file, &probes_seq_op);
421 }
422
423 static ssize_t probes_write(struct file *file, const char __user *buffer,
424 size_t count, loff_t *ppos)
425 {
426 return traceprobe_probes_write(file, buffer, count, ppos, create_trace_uprobe);
427 }
428
429 static const struct file_operations uprobe_events_ops = {
430 .owner = THIS_MODULE,
431 .open = probes_open,
432 .read = seq_read,
433 .llseek = seq_lseek,
434 .release = seq_release,
435 .write = probes_write,
436 };
437
438 /* Probes profiling interfaces */
439 static int probes_profile_seq_show(struct seq_file *m, void *v)
440 {
441 struct trace_uprobe *tu = v;
442
443 seq_printf(m, " %s %-44s %15lu\n", tu->filename, tu->call.name, tu->nhit);
444 return 0;
445 }
446
447 static const struct seq_operations profile_seq_op = {
448 .start = probes_seq_start,
449 .next = probes_seq_next,
450 .stop = probes_seq_stop,
451 .show = probes_profile_seq_show
452 };
453
454 static int profile_open(struct inode *inode, struct file *file)
455 {
456 return seq_open(file, &profile_seq_op);
457 }
458
459 static const struct file_operations uprobe_profile_ops = {
460 .owner = THIS_MODULE,
461 .open = profile_open,
462 .read = seq_read,
463 .llseek = seq_lseek,
464 .release = seq_release,
465 };
466
467 /* uprobe handler */
468 static void uprobe_trace_func(struct trace_uprobe *tu, struct pt_regs *regs)
469 {
470 struct uprobe_trace_entry_head *entry;
471 struct ring_buffer_event *event;
472 struct ring_buffer *buffer;
473 u8 *data;
474 int size, i, pc;
475 unsigned long irq_flags;
476 struct ftrace_event_call *call = &tu->call;
477
478 tu->nhit++;
479
480 local_save_flags(irq_flags);
481 pc = preempt_count();
482
483 size = sizeof(*entry) + tu->size;
484
485 event = trace_current_buffer_lock_reserve(&buffer, call->event.type,
486 size, irq_flags, pc);
487 if (!event)
488 return;
489
490 entry = ring_buffer_event_data(event);
491 entry->ip = uprobe_get_swbp_addr(task_pt_regs(current));
492 data = (u8 *)&entry[1];
493 for (i = 0; i < tu->nr_args; i++)
494 call_fetch(&tu->args[i].fetch, regs, data + tu->args[i].offset);
495
496 if (!filter_current_check_discard(buffer, call, entry, event))
497 trace_buffer_unlock_commit(buffer, event, irq_flags, pc);
498 }
499
500 /* Event entry printers */
501 static enum print_line_t
502 print_uprobe_event(struct trace_iterator *iter, int flags, struct trace_event *event)
503 {
504 struct uprobe_trace_entry_head *field;
505 struct trace_seq *s = &iter->seq;
506 struct trace_uprobe *tu;
507 u8 *data;
508 int i;
509
510 field = (struct uprobe_trace_entry_head *)iter->ent;
511 tu = container_of(event, struct trace_uprobe, call.event);
512
513 if (!trace_seq_printf(s, "%s: (", tu->call.name))
514 goto partial;
515
516 if (!seq_print_ip_sym(s, field->ip, flags | TRACE_ITER_SYM_OFFSET))
517 goto partial;
518
519 if (!trace_seq_puts(s, ")"))
520 goto partial;
521
522 data = (u8 *)&field[1];
523 for (i = 0; i < tu->nr_args; i++) {
524 if (!tu->args[i].type->print(s, tu->args[i].name,
525 data + tu->args[i].offset, field))
526 goto partial;
527 }
528
529 if (trace_seq_puts(s, "\n"))
530 return TRACE_TYPE_HANDLED;
531
532 partial:
533 return TRACE_TYPE_PARTIAL_LINE;
534 }
535
536 static int probe_event_enable(struct trace_uprobe *tu, int flag)
537 {
538 struct uprobe_trace_consumer *utc;
539 int ret = 0;
540
541 if (!tu->inode || tu->consumer)
542 return -EINTR;
543
544 utc = kzalloc(sizeof(struct uprobe_trace_consumer), GFP_KERNEL);
545 if (!utc)
546 return -EINTR;
547
548 utc->cons.handler = uprobe_dispatcher;
549 utc->cons.filter = NULL;
550 ret = uprobe_register(tu->inode, tu->offset, &utc->cons);
551 if (ret) {
552 kfree(utc);
553 return ret;
554 }
555
556 tu->flags |= flag;
557 utc->tu = tu;
558 tu->consumer = utc;
559
560 return 0;
561 }
562
563 static void probe_event_disable(struct trace_uprobe *tu, int flag)
564 {
565 if (!tu->inode || !tu->consumer)
566 return;
567
568 uprobe_unregister(tu->inode, tu->offset, &tu->consumer->cons);
569 tu->flags &= ~flag;
570 kfree(tu->consumer);
571 tu->consumer = NULL;
572 }
573
574 static int uprobe_event_define_fields(struct ftrace_event_call *event_call)
575 {
576 int ret, i;
577 struct uprobe_trace_entry_head field;
578 struct trace_uprobe *tu = (struct trace_uprobe *)event_call->data;
579
580 DEFINE_FIELD(unsigned long, ip, FIELD_STRING_IP, 0);
581 /* Set argument names as fields */
582 for (i = 0; i < tu->nr_args; i++) {
583 ret = trace_define_field(event_call, tu->args[i].type->fmttype,
584 tu->args[i].name,
585 sizeof(field) + tu->args[i].offset,
586 tu->args[i].type->size,
587 tu->args[i].type->is_signed,
588 FILTER_OTHER);
589
590 if (ret)
591 return ret;
592 }
593 return 0;
594 }
595
596 #define LEN_OR_ZERO (len ? len - pos : 0)
597 static int __set_print_fmt(struct trace_uprobe *tu, char *buf, int len)
598 {
599 const char *fmt, *arg;
600 int i;
601 int pos = 0;
602
603 fmt = "(%lx)";
604 arg = "REC->" FIELD_STRING_IP;
605
606 /* When len=0, we just calculate the needed length */
607
608 pos += snprintf(buf + pos, LEN_OR_ZERO, "\"%s", fmt);
609
610 for (i = 0; i < tu->nr_args; i++) {
611 pos += snprintf(buf + pos, LEN_OR_ZERO, " %s=%s",
612 tu->args[i].name, tu->args[i].type->fmt);
613 }
614
615 pos += snprintf(buf + pos, LEN_OR_ZERO, "\", %s", arg);
616
617 for (i = 0; i < tu->nr_args; i++) {
618 pos += snprintf(buf + pos, LEN_OR_ZERO, ", REC->%s",
619 tu->args[i].name);
620 }
621
622 return pos; /* return the length of print_fmt */
623 }
624 #undef LEN_OR_ZERO
625
626 static int set_print_fmt(struct trace_uprobe *tu)
627 {
628 char *print_fmt;
629 int len;
630
631 /* First: called with 0 length to calculate the needed length */
632 len = __set_print_fmt(tu, NULL, 0);
633 print_fmt = kmalloc(len + 1, GFP_KERNEL);
634 if (!print_fmt)
635 return -ENOMEM;
636
637 /* Second: actually write the @print_fmt */
638 __set_print_fmt(tu, print_fmt, len + 1);
639 tu->call.print_fmt = print_fmt;
640
641 return 0;
642 }
643
644 #ifdef CONFIG_PERF_EVENTS
645 /* uprobe profile handler */
646 static void uprobe_perf_func(struct trace_uprobe *tu, struct pt_regs *regs)
647 {
648 struct ftrace_event_call *call = &tu->call;
649 struct uprobe_trace_entry_head *entry;
650 struct hlist_head *head;
651 u8 *data;
652 int size, __size, i;
653 int rctx;
654
655 __size = sizeof(*entry) + tu->size;
656 size = ALIGN(__size + sizeof(u32), sizeof(u64));
657 size -= sizeof(u32);
658 if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE, "profile buffer not large enough"))
659 return;
660
661 preempt_disable();
662
663 entry = perf_trace_buf_prepare(size, call->event.type, regs, &rctx);
664 if (!entry)
665 goto out;
666
667 entry->ip = uprobe_get_swbp_addr(task_pt_regs(current));
668 data = (u8 *)&entry[1];
669 for (i = 0; i < tu->nr_args; i++)
670 call_fetch(&tu->args[i].fetch, regs, data + tu->args[i].offset);
671
672 head = this_cpu_ptr(call->perf_events);
673 perf_trace_buf_submit(entry, size, rctx, entry->ip, 1, regs, head, NULL);
674
675 out:
676 preempt_enable();
677 }
678 #endif /* CONFIG_PERF_EVENTS */
679
680 static
681 int trace_uprobe_register(struct ftrace_event_call *event, enum trace_reg type, void *data)
682 {
683 struct trace_uprobe *tu = (struct trace_uprobe *)event->data;
684
685 switch (type) {
686 case TRACE_REG_REGISTER:
687 return probe_event_enable(tu, TP_FLAG_TRACE);
688
689 case TRACE_REG_UNREGISTER:
690 probe_event_disable(tu, TP_FLAG_TRACE);
691 return 0;
692
693 #ifdef CONFIG_PERF_EVENTS
694 case TRACE_REG_PERF_REGISTER:
695 return probe_event_enable(tu, TP_FLAG_PROFILE);
696
697 case TRACE_REG_PERF_UNREGISTER:
698 probe_event_disable(tu, TP_FLAG_PROFILE);
699 return 0;
700 #endif
701 default:
702 return 0;
703 }
704 return 0;
705 }
706
707 static int uprobe_dispatcher(struct uprobe_consumer *con, struct pt_regs *regs)
708 {
709 struct uprobe_trace_consumer *utc;
710 struct trace_uprobe *tu;
711
712 utc = container_of(con, struct uprobe_trace_consumer, cons);
713 tu = utc->tu;
714 if (!tu || tu->consumer != utc)
715 return 0;
716
717 if (tu->flags & TP_FLAG_TRACE)
718 uprobe_trace_func(tu, regs);
719
720 #ifdef CONFIG_PERF_EVENTS
721 if (tu->flags & TP_FLAG_PROFILE)
722 uprobe_perf_func(tu, regs);
723 #endif
724 return 0;
725 }
726
727 static struct trace_event_functions uprobe_funcs = {
728 .trace = print_uprobe_event
729 };
730
731 static int register_uprobe_event(struct trace_uprobe *tu)
732 {
733 struct ftrace_event_call *call = &tu->call;
734 int ret;
735
736 /* Initialize ftrace_event_call */
737 INIT_LIST_HEAD(&call->class->fields);
738 call->event.funcs = &uprobe_funcs;
739 call->class->define_fields = uprobe_event_define_fields;
740
741 if (set_print_fmt(tu) < 0)
742 return -ENOMEM;
743
744 ret = register_ftrace_event(&call->event);
745 if (!ret) {
746 kfree(call->print_fmt);
747 return -ENODEV;
748 }
749 call->flags = 0;
750 call->class->reg = trace_uprobe_register;
751 call->data = tu;
752 ret = trace_add_event_call(call);
753
754 if (ret) {
755 pr_info("Failed to register uprobe event: %s\n", call->name);
756 kfree(call->print_fmt);
757 unregister_ftrace_event(&call->event);
758 }
759
760 return ret;
761 }
762
763 static void unregister_uprobe_event(struct trace_uprobe *tu)
764 {
765 /* tu->event is unregistered in trace_remove_event_call() */
766 trace_remove_event_call(&tu->call);
767 kfree(tu->call.print_fmt);
768 tu->call.print_fmt = NULL;
769 }
770
771 /* Make a trace interface for controling probe points */
772 static __init int init_uprobe_trace(void)
773 {
774 struct dentry *d_tracer;
775
776 d_tracer = tracing_init_dentry();
777 if (!d_tracer)
778 return 0;
779
780 trace_create_file("uprobe_events", 0644, d_tracer,
781 NULL, &uprobe_events_ops);
782 /* Profile interface */
783 trace_create_file("uprobe_profile", 0444, d_tracer,
784 NULL, &uprobe_profile_ops);
785 return 0;
786 }
787
788 fs_initcall(init_uprobe_trace);
CRIS linux kernel tree