src/probes/lttng-kprobes.c

   1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
   2  *
   3  * probes/lttng-kprobes.c
   4  *
   5  * LTTng kprobes integration module.
   6  *
   7  * Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/kprobes.h>
  12 #include <linux/slab.h>
  13 #include <lttng/events.h>
  14 #include <ringbuffer/frontend_types.h>
  15 #include <wrapper/vmalloc.h>
  16 #include <wrapper/irqflags.h>
  17 #include <lttng/tracer.h>
  18 #include <blacklist/kprobes.h>
  19
  20 static
  21 int lttng_kprobes_event_handler_pre(struct kprobe *p, struct pt_regs *regs)
  22 {
  23         struct lttng_event *event =
  24                 container_of(p, struct lttng_event, u.kprobe.kp);
  25         struct lttng_probe_ctx lttng_probe_ctx = {
  26                 .event = event,
  27                 .interruptible = !lttng_regs_irqs_disabled(regs),
  28         };
  29         struct lttng_event_container *container = event->container;
  30         int ret;
  31         unsigned long data = (unsigned long) p->addr;
  32
  33         if (unlikely(!LTTNG_READ_ONCE(container->session->active)))
  34                 return 0;
  35         if (unlikely(!LTTNG_READ_ONCE(container->enabled)))
  36                 return 0;
  37         if (unlikely(!LTTNG_READ_ONCE(event->enabled)))
  38                 return 0;
  39
  40         switch (container->type) {
  41         case LTTNG_EVENT_CONTAINER_CHANNEL:
  42         {
  43                 struct lttng_channel *chan = lttng_event_container_get_channel(container);
  44                 struct lib_ring_buffer_ctx ctx;
  45
  46                 lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx, sizeof(data),
  47                                          lttng_alignof(data), -1);
  48                 ret = chan->ops->event_reserve(&ctx, event->id);
  49                 if (ret < 0)
  50                         return 0;
  51                 lib_ring_buffer_align_ctx(&ctx, lttng_alignof(data));
  52                 chan->ops->event_write(&ctx, &data, sizeof(data));
  53                 chan->ops->event_commit(&ctx);
  54                 break;
  55         }
  56         case LTTNG_EVENT_CONTAINER_COUNTER:
  57         {
  58                 struct lttng_counter *counter = lttng_event_container_get_counter(container);
  59                 size_t index = event->id;
  60
  61                 (void) counter->ops->counter_add(counter->counter, &index, 1);
  62                 break;
  63         }
  64         }
  65         return 0;
  66 }
  67
  68 static
  69 int lttng_kprobes_event_notifier_handler_pre(struct kprobe *p, struct pt_regs *regs)
  70 {
  71         struct lttng_event_notifier *event_notifier =
  72                 container_of(p, struct lttng_event_notifier, u.kprobe.kp);
  73         struct lttng_kernel_notifier_ctx notif_ctx;
  74
  75         if (unlikely(!READ_ONCE(event_notifier->enabled)))
  76                 return 0;
  77
  78         notif_ctx.eval_capture = LTTNG_READ_ONCE(event_notifier->eval_capture);
  79         event_notifier->send_notification(event_notifier, NULL, NULL, &notif_ctx);
  80
  81         return 0;
  82 }
  83
  84 /*
  85  * Create event description
  86  */
  87 static
  88 int lttng_create_kprobe_event(const char *name, struct lttng_event *event)
  89 {
  90         struct lttng_event_field *field;
  91         struct lttng_event_desc *desc;
  92         int ret;
  93
  94         desc = kzalloc(sizeof(*event->desc), GFP_KERNEL);
  95         if (!desc)
  96                 return -ENOMEM;
  97         desc->name = kstrdup(name, GFP_KERNEL);
  98         if (!desc->name) {
  99                 ret = -ENOMEM;
 100                 goto error_str;
 101         }
 102         desc->nr_fields = 1;
 103         desc->fields = field =
 104                 kzalloc(1 * sizeof(struct lttng_event_field), GFP_KERNEL);
 105         if (!field) {
 106                 ret = -ENOMEM;
 107                 goto error_field;
 108         }
 109         field->name = "ip";
 110         field->type.atype = atype_integer;
 111         field->type.u.integer.size = sizeof(unsigned long) * CHAR_BIT;
 112         field->type.u.integer.alignment = lttng_alignof(unsigned long) * CHAR_BIT;
 113         field->type.u.integer.signedness = lttng_is_signed_type(unsigned long);
 114         field->type.u.integer.reverse_byte_order = 0;
 115         field->type.u.integer.base = 16;
 116         field->type.u.integer.encoding = lttng_encode_none;
 117         desc->owner = THIS_MODULE;
 118         event->desc = desc;
 119
 120         return 0;
 121
 122 error_field:
 123         kfree(desc->name);
 124 error_str:
 125         kfree(desc);
 126         return ret;
 127 }
 128
 129 /*
 130  * Create event_notifier description
 131  */
 132 static
 133 int lttng_create_kprobe_event_notifier(const char *name, struct lttng_event_notifier *event_notifier)
 134 {
 135         struct lttng_event_desc *desc;
 136         int ret;
 137
 138         desc = kzalloc(sizeof(*event_notifier->desc), GFP_KERNEL);
 139         if (!desc)
 140                 return -ENOMEM;
 141         desc->name = kstrdup(name, GFP_KERNEL);
 142         if (!desc->name) {
 143                 ret = -ENOMEM;
 144                 goto error_str;
 145         }
 146         desc->nr_fields = 0;
 147
 148         desc->owner = THIS_MODULE;
 149         event_notifier->desc = desc;
 150
 151         return 0;
 152
 153 error_str:
 154         kfree(desc);
 155         return ret;
 156 }
 157
 158 static
 159 int _lttng_kprobes_register(const char *symbol_name,
 160                            uint64_t offset,
 161                            uint64_t addr,
 162                            struct lttng_kprobe *lttng_kp,
 163                            kprobe_pre_handler_t pre_handler)
 164 {
 165         int ret;
 166
 167         /* Kprobes expects a NULL symbol name if unused */
 168         if (symbol_name[0] == '\0')
 169                 symbol_name = NULL;
 170
 171         memset(&lttng_kp->kp, 0, sizeof(lttng_kp->kp));
 172         lttng_kp->kp.pre_handler = pre_handler;
 173
 174         if (symbol_name) {
 175                 lttng_kp->symbol_name =
 176                         kzalloc(LTTNG_KERNEL_SYM_NAME_LEN * sizeof(char),
 177                                 GFP_KERNEL);
 178                 if (!lttng_kp->symbol_name) {
 179                         ret = -ENOMEM;
 180                         goto name_error;
 181                 }
 182                 memcpy(lttng_kp->symbol_name, symbol_name,
 183                        LTTNG_KERNEL_SYM_NAME_LEN * sizeof(char));
 184                 lttng_kp->kp.symbol_name = lttng_kp->symbol_name;
 185         }
 186
 187         lttng_kp->kp.offset = offset;
 188         lttng_kp->kp.addr = (void *) (unsigned long) addr;
 189
 190         /*
 191          * Ensure the memory we just allocated don't event_notifier page faults.
 192          * Well.. kprobes itself puts the page fault handler on the blacklist,
 193          * but we can never be too careful.
 194          */
 195         wrapper_vmalloc_sync_mappings();
 196
 197         ret = register_kprobe(&lttng_kp->kp);
 198         if (ret)
 199                 goto register_error;
 200
 201         return 0;
 202
 203 register_error:
 204         kfree(lttng_kp->symbol_name);
 205 name_error:
 206         return ret;
 207 }
 208
 209 int lttng_kprobes_register_event(const char *name,
 210                            const char *symbol_name,
 211                            uint64_t offset,
 212                            uint64_t addr,
 213                            struct lttng_event *event)
 214 {
 215         int ret;
 216
 217         ret = lttng_create_kprobe_event(name, event);
 218         if (ret)
 219                 goto error;
 220
 221         ret = _lttng_kprobes_register(symbol_name, offset, addr,
 222                 &event->u.kprobe, lttng_kprobes_event_handler_pre);
 223         if (ret)
 224                 goto register_error;
 225
 226         return 0;
 227
 228 register_error:
 229         kfree(event->desc->fields);
 230         kfree(event->desc->name);
 231         kfree(event->desc);
 232 error:
 233         return ret;
 234 }
 235 EXPORT_SYMBOL_GPL(lttng_kprobes_register_event);
 236
 237 int lttng_kprobes_register_event_notifier(const char *symbol_name,
 238                            uint64_t offset,
 239                            uint64_t addr,
 240                            struct lttng_event_notifier *event_notifier)
 241 {
 242         int ret;
 243         ret = lttng_create_kprobe_event_notifier(symbol_name, event_notifier);
 244         if (ret)
 245                 goto error;
 246
 247         ret = _lttng_kprobes_register(symbol_name, offset, addr,
 248                 &event_notifier->u.kprobe, lttng_kprobes_event_notifier_handler_pre);
 249         if (ret)
 250                 goto register_error;
 251
 252         return 0;
 253
 254 register_error:
 255         kfree(event_notifier->desc->name);
 256         kfree(event_notifier->desc);
 257 error:
 258         return ret;
 259 }
 260 EXPORT_SYMBOL_GPL(lttng_kprobes_register_event_notifier);
 261
 262 void lttng_kprobes_unregister_event(struct lttng_event *event)
 263 {
 264         unregister_kprobe(&event->u.kprobe.kp);
 265 }
 266 EXPORT_SYMBOL_GPL(lttng_kprobes_unregister_event);
 267
 268 void lttng_kprobes_unregister_event_notifier(struct lttng_event_notifier *event_notifier)
 269 {
 270         unregister_kprobe(&event_notifier->u.kprobe.kp);
 271 }
 272 EXPORT_SYMBOL_GPL(lttng_kprobes_unregister_event_notifier);
 273
 274 void lttng_kprobes_destroy_event_private(struct lttng_event *event)
 275 {
 276         kfree(event->u.kprobe.symbol_name);
 277         kfree(event->desc->fields);
 278         kfree(event->desc->name);
 279         kfree(event->desc);
 280 }
 281 EXPORT_SYMBOL_GPL(lttng_kprobes_destroy_event_private);
 282
 283 void lttng_kprobes_destroy_event_notifier_private(struct lttng_event_notifier *event_notifier)
 284 {
 285         kfree(event_notifier->u.kprobe.symbol_name);
 286         kfree(event_notifier->desc->name);
 287         kfree(event_notifier->desc);
 288 }
 289 EXPORT_SYMBOL_GPL(lttng_kprobes_destroy_event_notifier_private);
 290
 291 MODULE_LICENSE("GPL and additional rights");
 292 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
 293 MODULE_DESCRIPTION("LTTng kprobes probes");
 294 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
 295         __stringify(LTTNG_MODULES_MINOR_VERSION) "."
 296         __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
 297         LTTNG_MODULES_EXTRAVERSION);