probes/lttng-kprobes.c

   1 /*
   2  * (C) Copyright        2009-2011 -
   3  *              Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  *
   5  * LTTng kprobes integration module.
   6  *
   7  * Dual LGPL v2.1/GPL v2 license.
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/kprobes.h>
  12 #include <linux/slab.h>
  13 #include "../ltt-events.h"
  14 #include "../wrapper/ringbuffer/frontend_types.h"
  15 #include "../ltt-tracer.h"
  16
  17 static
  18 int lttng_kprobes_handler_pre(struct kprobe *p, struct pt_regs *regs)
  19 {
  20         struct ltt_event *event =
  21                 container_of(p, struct ltt_event, u.kprobe.kp);
  22         struct ltt_channel *chan = event->chan;
  23         struct lib_ring_buffer_ctx ctx;
  24         int ret;
  25         unsigned long data = (unsigned long) p->addr;
  26
  27         if (!ACCESS_ONCE(chan->session->active))
  28                 return 0;
  29         lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, sizeof(data),
  30                                  ltt_alignof(data), -1);
  31         ret = chan->ops->event_reserve(&ctx);
  32         if (ret < 0)
  33                 return 0;
  34         lib_ring_buffer_align_ctx(&ctx, ltt_alignof(data));
  35         chan->ops->event_write(&ctx, &data, sizeof(data));
  36         chan->ops->event_commit(&ctx);
  37         return 0;
  38 }
  39
  40 /*
  41  * Create event description
  42  */
  43 static
  44 int lttng_create_kprobe_event(const char *name, struct ltt_event *event)
  45 {
  46         struct lttng_event_field *field;
  47         int ret;
  48
  49         event->desc = kzalloc(sizeof(*event->desc), GFP_KERNEL);
  50         if (!event->desc)
  51                 return -ENOMEM;
  52         event->desc->name = kstrdup(name, GFP_KERNEL);
  53         if (!event->desc->name) {
  54                 ret = -ENOMEM;
  55                 goto error_str;
  56         }
  57         event->desc->nr_fields = 1;
  58         event->desc->fields = field =
  59                 kzalloc(1 * sizeof(struct lttng_event_field), GFP_KERNEL);
  60         field->name = "ip";
  61         field->type.atype = atype_integer;
  62         field->type.u.basic.integer.size = sizeof(unsigned long);
  63         field->type.u.basic.integer.alignment = ltt_alignof(unsigned long);
  64         field->type.u.basic.integer.signedness = 0;
  65         field->type.u.basic.integer.reverse_byte_order = 0;
  66
  67         return 0;
  68
  69 error_str:
  70         kfree(event->desc);
  71         return ret;
  72 }
  73
  74 int lttng_kprobes_register(const char *name,
  75                            const char *symbol_name,
  76                            uint64_t offset,
  77                            uint64_t addr,
  78                            struct ltt_event *event)
  79 {
  80         int ret;
  81
  82         ret = lttng_create_kprobe_event(name, event);
  83         if (ret)
  84                 goto error;
  85         memset(&event->u.kprobe.kp, 0, sizeof(event->u.kprobe.kp));
  86         event->u.kprobe.kp.pre_handler = lttng_kprobes_handler_pre;
  87         event->u.kprobe.symbol_name =
  88                 kzalloc(LTTNG_KPROBE_SYM_NAME_LEN * sizeof(char),
  89                         GFP_KERNEL);
  90         if (!event->u.kprobe.symbol_name) {
  91                 ret = -ENOMEM;
  92                 goto name_error;
  93         }
  94         memcpy(event->u.kprobe.symbol_name, symbol_name,
  95                LTTNG_KPROBE_SYM_NAME_LEN * sizeof(char));
  96         event->u.kprobe.kp.symbol_name =
  97                 event->u.kprobe.symbol_name;
  98         event->u.kprobe.kp.offset = offset;
  99         event->u.kprobe.kp.addr = (void *) addr;
 100         ret = register_kprobe(&event->u.kprobe.kp);
 101         if (ret)
 102                 goto register_error;
 103         return 0;
 104
 105 register_error:
 106         kfree(event->u.kprobe.symbol_name);
 107 name_error:
 108         kfree(event->desc->name);
 109         kfree(event->desc);
 110 error:
 111         return ret;
 112 }
 113 EXPORT_SYMBOL_GPL(lttng_kprobes_register);
 114
 115 void lttng_kprobes_unregister(struct ltt_event *event)
 116 {
 117         unregister_kprobe(&event->u.kprobe.kp);
 118         kfree(event->u.kprobe.symbol_name);
 119         kfree(event->desc->name);
 120         kfree(event->desc);
 121 }
 122 EXPORT_SYMBOL_GPL(lttng_kprobes_unregister);
 123
 124 MODULE_LICENSE("GPL and additional rights");
 125 MODULE_AUTHOR("Mathieu Desnoyers");
 126 MODULE_DESCRIPTION("Linux Trace Toolkit Kprobes Support");