probes/lttng-ftrace.c

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