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 /*
  11  * Ftrace function tracer does not seem to provide synchronization between probe
  12  * teardown and callback execution. Therefore, we make this module permanently
  13  * loaded (unloadable).
  14  */
  15
  16 #include <linux/module.h>
  17 #include <linux/ftrace.h>
  18 #include <linux/slab.h>
  19 #include "../ltt-events.h"
  20 #include "../wrapper/ringbuffer/frontend_types.h"
  21 #include "../wrapper/ftrace.h"
  22 #include "../wrapper/vmalloc.h"
  23 #include "../ltt-tracer.h"
  24
  25 static
  26 void lttng_ftrace_handler(unsigned long ip, unsigned long parent_ip, void **data)
  27 {
  28         struct ltt_event *event = *data;
  29         struct ltt_channel *chan = event->chan;
  30         struct lib_ring_buffer_ctx ctx;
  31         struct {
  32                 unsigned long ip;
  33                 unsigned long parent_ip;
  34         } payload;
  35         int ret;
  36
  37         if (!ACCESS_ONCE(chan->session->active))
  38                 return;
  39         lib_ring_buffer_ctx_init(&ctx, chan->chan, event,
  40                                  sizeof(payload), ltt_alignof(payload), -1);
  41         ret = chan->ops->event_reserve(&ctx, event->id);
  42         if (ret < 0)
  43                 return;
  44         payload.ip = ip;
  45         payload.parent_ip = parent_ip;
  46         lib_ring_buffer_align_ctx(&ctx, ltt_alignof(payload));
  47         chan->ops->event_write(&ctx, &payload, sizeof(payload));
  48         chan->ops->event_commit(&ctx);
  49         return;
  50 }
  51
  52 /*
  53  * Create event description
  54  */
  55 static
  56 int lttng_create_ftrace_event(const char *name, struct ltt_event *event)
  57 {
  58         struct lttng_event_field *fields;
  59         struct lttng_event_desc *desc;
  60         int ret;
  61
  62         desc = kzalloc(sizeof(*event->desc), GFP_KERNEL);
  63         if (!desc)
  64                 return -ENOMEM;
  65         desc->name = kstrdup(name, GFP_KERNEL);
  66         if (!desc->name) {
  67                 ret = -ENOMEM;
  68                 goto error_str;
  69         }
  70         desc->nr_fields = 2;
  71         desc->fields = fields =
  72                 kzalloc(2 * sizeof(struct lttng_event_field), GFP_KERNEL);
  73         if (!desc->fields) {
  74                 ret = -ENOMEM;
  75                 goto error_fields;
  76         }
  77         fields[0].name = "ip";
  78         fields[0].type.atype = atype_integer;
  79         fields[0].type.u.basic.integer.size = sizeof(unsigned long) * CHAR_BIT;
  80         fields[0].type.u.basic.integer.alignment = ltt_alignof(unsigned long) * CHAR_BIT;
  81         fields[0].type.u.basic.integer.signedness = is_signed_type(unsigned long);
  82         fields[0].type.u.basic.integer.reverse_byte_order = 0;
  83         fields[0].type.u.basic.integer.base = 16;
  84         fields[0].type.u.basic.integer.encoding = lttng_encode_none;
  85
  86         fields[1].name = "parent_ip";
  87         fields[1].type.atype = atype_integer;
  88         fields[1].type.u.basic.integer.size = sizeof(unsigned long) * CHAR_BIT;
  89         fields[1].type.u.basic.integer.alignment = ltt_alignof(unsigned long) * CHAR_BIT;
  90         fields[1].type.u.basic.integer.signedness = is_signed_type(unsigned long);
  91         fields[1].type.u.basic.integer.reverse_byte_order = 0;
  92         fields[1].type.u.basic.integer.base = 16;
  93         fields[1].type.u.basic.integer.encoding = lttng_encode_none;
  94
  95         desc->owner = THIS_MODULE;
  96         event->desc = desc;
  97
  98         return 0;
  99
 100 error_fields:
 101         kfree(desc->name);
 102 error_str:
 103         kfree(desc);
 104         return ret;
 105 }
 106
 107 static
 108 struct ftrace_probe_ops lttng_ftrace_ops = {
 109         .func = lttng_ftrace_handler,
 110 };
 111
 112 int lttng_ftrace_register(const char *name,
 113                           const char *symbol_name,
 114                           struct ltt_event *event)
 115 {
 116         int ret;
 117
 118         ret = lttng_create_ftrace_event(name, event);
 119         if (ret)
 120                 goto error;
 121
 122         event->u.ftrace.symbol_name = kstrdup(symbol_name, GFP_KERNEL);
 123         if (!event->u.ftrace.symbol_name)
 124                 goto name_error;
 125
 126         /* Ensure the memory we just allocated don't trigger page faults */
 127         wrapper_vmalloc_sync_all();
 128
 129         ret = wrapper_register_ftrace_function_probe(event->u.ftrace.symbol_name,
 130                         &lttng_ftrace_ops, event);
 131         if (ret < 0)
 132                 goto register_error;
 133         return 0;
 134
 135 register_error:
 136         kfree(event->u.ftrace.symbol_name);
 137 name_error:
 138         kfree(event->desc->name);
 139         kfree(event->desc);
 140 error:
 141         return ret;
 142 }
 143 EXPORT_SYMBOL_GPL(lttng_ftrace_register);
 144
 145 void lttng_ftrace_unregister(struct ltt_event *event)
 146 {
 147         wrapper_unregister_ftrace_function_probe(event->u.ftrace.symbol_name,
 148                         &lttng_ftrace_ops, event);
 149 }
 150 EXPORT_SYMBOL_GPL(lttng_ftrace_unregister);
 151
 152 void lttng_ftrace_destroy_private(struct ltt_event *event)
 153 {
 154         kfree(event->u.ftrace.symbol_name);
 155         kfree(event->desc->fields);
 156         kfree(event->desc->name);
 157         kfree(event->desc);
 158 }
 159 EXPORT_SYMBOL_GPL(lttng_ftrace_destroy_private);
 160
 161 int lttng_ftrace_init(void)
 162 {
 163         wrapper_vmalloc_sync_all();
 164         return 0;
 165 }
 166 module_init(lttng_ftrace_init)
 167
 168 /*
 169  * Ftrace takes care of waiting for a grace period (RCU sched) at probe
 170  * unregistration, and disables preemption around probe call.
 171  */
 172 void lttng_ftrace_exit(void)
 173 {
 174 }
 175 module_exit(lttng_ftrace_exit)
 176
 177 MODULE_LICENSE("GPL and additional rights");
 178 MODULE_AUTHOR("Mathieu Desnoyers");
 179 MODULE_DESCRIPTION("Linux Trace Toolkit Ftrace Support");