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 "../wrapper/vmalloc.h"
  16 #include "../ltt-tracer.h"
  17
  18 static
  19 int lttng_kprobes_handler_pre(struct kprobe *p, struct pt_regs *regs)
  20 {
  21         struct ltt_event *event =
  22                 container_of(p, struct ltt_event, u.kprobe.kp);
  23         struct ltt_channel *chan = event->chan;
  24         struct lib_ring_buffer_ctx ctx;
  25         int ret;
  26         unsigned long data = (unsigned long) p->addr;
  27
  28         if (!ACCESS_ONCE(chan->session->active))
  29                 return 0;
  30         lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, sizeof(data),
  31                                  ltt_alignof(data), -1);
  32         ret = chan->ops->event_reserve(&ctx, event->id);
  33         if (ret < 0)
  34                 return 0;
  35         lib_ring_buffer_align_ctx(&ctx, ltt_alignof(data));
  36         chan->ops->event_write(&ctx, &data, sizeof(data));
  37         chan->ops->event_commit(&ctx);
  38         return 0;
  39 }
  40
  41 /*
  42  * Create event description
  43  */
  44 static
  45 int lttng_create_kprobe_event(const char *name, struct ltt_event *event)
  46 {
  47         struct lttng_event_field *field;
  48         struct lttng_event_desc *desc;
  49         int ret;
  50
  51         desc = kzalloc(sizeof(*event->desc), GFP_KERNEL);
  52         if (!desc)
  53                 return -ENOMEM;
  54         desc->name = kstrdup(name, GFP_KERNEL);
  55         if (!desc->name) {
  56                 ret = -ENOMEM;
  57                 goto error_str;
  58         }
  59         desc->nr_fields = 1;
  60         desc->fields = field =
  61                 kzalloc(1 * sizeof(struct lttng_event_field), GFP_KERNEL);
  62         if (!field) {
  63                 ret = -ENOMEM;
  64                 goto error_field;
  65         }
  66         field->name = "ip";
  67         field->type.atype = atype_integer;
  68         field->type.u.basic.integer.size = sizeof(unsigned long) * CHAR_BIT;
  69         field->type.u.basic.integer.alignment = ltt_alignof(unsigned long) * CHAR_BIT;
  70         field->type.u.basic.integer.signedness = is_signed_type(unsigned long);
  71         field->type.u.basic.integer.reverse_byte_order = 0;
  72         field->type.u.basic.integer.base = 16;
  73         field->type.u.basic.integer.encoding = lttng_encode_none;
  74         desc->owner = THIS_MODULE;
  75         event->desc = desc;
  76
  77         return 0;
  78
  79 error_field:
  80         kfree(desc->name);
  81 error_str:
  82         kfree(desc);
  83         return ret;
  84 }
  85
  86 int lttng_kprobes_register(const char *name,
  87                            const char *symbol_name,
  88                            uint64_t offset,
  89                            uint64_t addr,
  90                            struct ltt_event *event)
  91 {
  92         int ret;
  93
  94         ret = lttng_create_kprobe_event(name, event);
  95         if (ret)
  96                 goto error;
  97         memset(&event->u.kprobe.kp, 0, sizeof(event->u.kprobe.kp));
  98         event->u.kprobe.kp.pre_handler = lttng_kprobes_handler_pre;
  99         event->u.kprobe.symbol_name =
 100                 kzalloc(LTTNG_SYM_NAME_LEN * sizeof(char),
 101                         GFP_KERNEL);
 102         if (!event->u.kprobe.symbol_name) {
 103                 ret = -ENOMEM;
 104                 goto name_error;
 105         }
 106         memcpy(event->u.kprobe.symbol_name, symbol_name,
 107                LTTNG_SYM_NAME_LEN * sizeof(char));
 108         event->u.kprobe.kp.symbol_name =
 109                 event->u.kprobe.symbol_name;
 110         event->u.kprobe.kp.offset = offset;
 111         event->u.kprobe.kp.addr = (void *) addr;
 112
 113         /*
 114          * Ensure the memory we just allocated don't trigger page faults.
 115          * Well.. kprobes itself puts the page fault handler on the blacklist,
 116          * but we can never be too careful.
 117          */
 118         wrapper_vmalloc_sync_all();
 119
 120         ret = register_kprobe(&event->u.kprobe.kp);
 121         if (ret)
 122                 goto register_error;
 123         return 0;
 124
 125 register_error:
 126         kfree(event->u.kprobe.symbol_name);
 127 name_error:
 128         kfree(event->desc->fields);
 129         kfree(event->desc->name);
 130         kfree(event->desc);
 131 error:
 132         return ret;
 133 }
 134 EXPORT_SYMBOL_GPL(lttng_kprobes_register);
 135
 136 void lttng_kprobes_unregister(struct ltt_event *event)
 137 {
 138         unregister_kprobe(&event->u.kprobe.kp);
 139 }
 140 EXPORT_SYMBOL_GPL(lttng_kprobes_unregister);
 141
 142 void lttng_kprobes_destroy_private(struct ltt_event *event)
 143 {
 144         kfree(event->u.kprobe.symbol_name);
 145         kfree(event->desc->fields);
 146         kfree(event->desc->name);
 147         kfree(event->desc);
 148 }
 149 EXPORT_SYMBOL_GPL(lttng_kprobes_destroy_private);
 150
 151 MODULE_LICENSE("GPL and additional rights");
 152 MODULE_AUTHOR("Mathieu Desnoyers");
 153 MODULE_DESCRIPTION("Linux Trace Toolkit Kprobes Support");