probes/lttng-ftrace.c

   1 /*
   2  * probes/lttng-ftrace.c
   3  *
   4  * LTTng function tracer integration module.
   5  *
   6  * Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; only
  11  * version 2.1 of the License.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 /*
  24  * Ftrace function tracer does not seem to provide synchronization between probe
  25  * teardown and callback execution. Therefore, we make this module permanently
  26  * loaded (unloadable).
  27  *
  28  * TODO: Move to register_ftrace_function() (which is exported for
  29  * modules) for Linux >= 3.0. It is faster (only enables the selected
  30  * functions), and will stay there.
  31  */
  32
  33 #include <linux/module.h>
  34 #include <linux/ftrace.h>
  35 #include <linux/slab.h>
  36 #include <lttng-events.h>
  37 #include <wrapper/ringbuffer/frontend_types.h>
  38 #include <wrapper/ftrace.h>
  39 #include <wrapper/vmalloc.h>
  40 #include <lttng-tracer.h>
  41
  42 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
  43 static
  44 void lttng_ftrace_handler(unsigned long ip, unsigned long parent_ip,
  45                 struct trace_array *tr, struct ftrace_probe_ops *ops,
  46                 void *data)
  47 {
  48         struct lttng_event *event = data;
  49         struct lttng_probe_ctx lttng_probe_ctx = {
  50                 .event = event,
  51                 .interruptible = !irqs_disabled(),
  52         };
  53         struct lttng_channel *chan = event->chan;
  54         struct lib_ring_buffer_ctx ctx;
  55         struct {
  56                 unsigned long ip;
  57                 unsigned long parent_ip;
  58         } payload;
  59         int ret;
  60
  61         if (unlikely(!READ_ONCE(chan->session->active)))
  62                 return;
  63         if (unlikely(!READ_ONCE(chan->enabled)))
  64                 return;
  65         if (unlikely(!READ_ONCE(event->enabled)))
  66                 return;
  67
  68         lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx,
  69                                  sizeof(payload), lttng_alignof(payload), -1);
  70         ret = chan->ops->event_reserve(&ctx, event->id);
  71         if (ret < 0)
  72                 return;
  73         payload.ip = ip;
  74         payload.parent_ip = parent_ip;
  75         lib_ring_buffer_align_ctx(&ctx, lttng_alignof(payload));
  76         chan->ops->event_write(&ctx, &payload, sizeof(payload));
  77         chan->ops->event_commit(&ctx);
  78         return;
  79 }
  80 #else
  81 static
  82 void lttng_ftrace_handler(unsigned long ip, unsigned long parent_ip, void **data)
  83 {
  84         struct lttng_event *event = *data;
  85         struct lttng_probe_ctx lttng_probe_ctx = {
  86                 .event = event,
  87                 .interruptible = !irqs_disabled(),
  88         };
  89         struct lttng_channel *chan = event->chan;
  90         struct lib_ring_buffer_ctx ctx;
  91         struct {
  92                 unsigned long ip;
  93                 unsigned long parent_ip;
  94         } payload;
  95         int ret;
  96
  97         if (unlikely(!READ_ONCE(chan->session->active)))
  98                 return;
  99         if (unlikely(!READ_ONCE(chan->enabled)))
 100                 return;
 101         if (unlikely(!READ_ONCE(event->enabled)))
 102                 return;
 103
 104         lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx,
 105                                  sizeof(payload), lttng_alignof(payload), -1);
 106         ret = chan->ops->event_reserve(&ctx, event->id);
 107         if (ret < 0)
 108                 return;
 109         payload.ip = ip;
 110         payload.parent_ip = parent_ip;
 111         lib_ring_buffer_align_ctx(&ctx, lttng_alignof(payload));
 112         chan->ops->event_write(&ctx, &payload, sizeof(payload));
 113         chan->ops->event_commit(&ctx);
 114         return;
 115 }
 116 #endif
 117
 118 /*
 119  * Create event description
 120  */
 121 static
 122 int lttng_create_ftrace_event(const char *name, struct lttng_event *event)
 123 {
 124         struct lttng_event_field *fields;
 125         struct lttng_event_desc *desc;
 126         int ret;
 127
 128         desc = kzalloc(sizeof(*event->desc), GFP_KERNEL);
 129         if (!desc)
 130                 return -ENOMEM;
 131         desc->name = kstrdup(name, GFP_KERNEL);
 132         if (!desc->name) {
 133                 ret = -ENOMEM;
 134                 goto error_str;
 135         }
 136         desc->nr_fields = 2;
 137         desc->fields = fields =
 138                 kzalloc(2 * sizeof(struct lttng_event_field), GFP_KERNEL);
 139         if (!desc->fields) {
 140                 ret = -ENOMEM;
 141                 goto error_fields;
 142         }
 143         fields[0].name = "ip";
 144         fields[0].type.atype = atype_integer;
 145         fields[0].type.u.basic.integer.size = sizeof(unsigned long) * CHAR_BIT;
 146         fields[0].type.u.basic.integer.alignment = lttng_alignof(unsigned long) * CHAR_BIT;
 147         fields[0].type.u.basic.integer.signedness = lttng_is_signed_type(unsigned long);
 148         fields[0].type.u.basic.integer.reverse_byte_order = 0;
 149         fields[0].type.u.basic.integer.base = 16;
 150         fields[0].type.u.basic.integer.encoding = lttng_encode_none;
 151
 152         fields[1].name = "parent_ip";
 153         fields[1].type.atype = atype_integer;
 154         fields[1].type.u.basic.integer.size = sizeof(unsigned long) * CHAR_BIT;
 155         fields[1].type.u.basic.integer.alignment = lttng_alignof(unsigned long) * CHAR_BIT;
 156         fields[1].type.u.basic.integer.signedness = lttng_is_signed_type(unsigned long);
 157         fields[1].type.u.basic.integer.reverse_byte_order = 0;
 158         fields[1].type.u.basic.integer.base = 16;
 159         fields[1].type.u.basic.integer.encoding = lttng_encode_none;
 160
 161         desc->owner = THIS_MODULE;
 162         event->desc = desc;
 163
 164         return 0;
 165
 166 error_fields:
 167         kfree(desc->name);
 168 error_str:
 169         kfree(desc);
 170         return ret;
 171 }
 172
 173 static
 174 struct ftrace_probe_ops lttng_ftrace_ops = {
 175         .func = lttng_ftrace_handler,
 176 };
 177
 178 int lttng_ftrace_register(const char *name,
 179                           const char *symbol_name,
 180                           struct lttng_event *event)
 181 {
 182         int ret;
 183
 184         ret = lttng_create_ftrace_event(name, event);
 185         if (ret)
 186                 goto error;
 187
 188         event->u.ftrace.symbol_name = kstrdup(symbol_name, GFP_KERNEL);
 189         if (!event->u.ftrace.symbol_name)
 190                 goto name_error;
 191
 192         /* Ensure the memory we just allocated don't trigger page faults */
 193         wrapper_vmalloc_sync_all();
 194
 195         ret = wrapper_register_ftrace_function_probe(event->u.ftrace.symbol_name,
 196                         &lttng_ftrace_ops, event);
 197         if (ret < 0)
 198                 goto register_error;
 199         return 0;
 200
 201 register_error:
 202         kfree(event->u.ftrace.symbol_name);
 203 name_error:
 204         kfree(event->desc->name);
 205         kfree(event->desc);
 206 error:
 207         return ret;
 208 }
 209 EXPORT_SYMBOL_GPL(lttng_ftrace_register);
 210
 211 void lttng_ftrace_unregister(struct lttng_event *event)
 212 {
 213         wrapper_unregister_ftrace_function_probe(event->u.ftrace.symbol_name,
 214                         &lttng_ftrace_ops, event);
 215 }
 216 EXPORT_SYMBOL_GPL(lttng_ftrace_unregister);
 217
 218 void lttng_ftrace_destroy_private(struct lttng_event *event)
 219 {
 220         kfree(event->u.ftrace.symbol_name);
 221         kfree(event->desc->fields);
 222         kfree(event->desc->name);
 223         kfree(event->desc);
 224 }
 225 EXPORT_SYMBOL_GPL(lttng_ftrace_destroy_private);
 226
 227 int lttng_ftrace_init(void)
 228 {
 229         wrapper_vmalloc_sync_all();
 230         return 0;
 231 }
 232 module_init(lttng_ftrace_init)
 233
 234 /*
 235  * Ftrace takes care of waiting for a grace period (RCU sched) at probe
 236  * unregistration, and disables preemption around probe call.
 237  */
 238 void lttng_ftrace_exit(void)
 239 {
 240 }
 241 module_exit(lttng_ftrace_exit)
 242
 243 MODULE_LICENSE("GPL and additional rights");
 244 MODULE_AUTHOR("Mathieu Desnoyers");
 245 MODULE_DESCRIPTION("Linux Trace Toolkit Ftrace Support");
 246 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
 247         __stringify(LTTNG_MODULES_MINOR_VERSION) "."
 248         __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
 249         LTTNG_MODULES_EXTRAVERSION);