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_channel *chan = event->chan;
  30         struct lib_ring_buffer_ctx ctx;
  31         int ret;
  32         unsigned long data = (unsigned long) p->addr;
  33
  34         if (unlikely(!LTTNG_READ_ONCE(chan->session->active)))
  35                 return 0;
  36         if (unlikely(!LTTNG_READ_ONCE(chan->enabled)))
  37                 return 0;
  38         if (unlikely(!LTTNG_READ_ONCE(event->enabled)))
  39                 return 0;
  40
  41         lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx, sizeof(data),
  42                                  lttng_alignof(data), -1);
  43         ret = chan->ops->event_reserve(&ctx, event->id);
  44         if (ret < 0)
  45                 return 0;
  46         lib_ring_buffer_align_ctx(&ctx, lttng_alignof(data));
  47         chan->ops->event_write(&ctx, &data, sizeof(data));
  48         chan->ops->event_commit(&ctx);
  49         return 0;
  50 }
  51
  52 static
  53 int lttng_kprobes_event_notifier_handler_pre(struct kprobe *p, struct pt_regs *regs)
  54 {
  55         struct lttng_event_notifier *event_notifier =
  56                 container_of(p, struct lttng_event_notifier, u.kprobe.kp);
  57         struct lttng_kernel_notifier_ctx notif_ctx;
  58
  59         if (unlikely(!READ_ONCE(event_notifier->enabled)))
  60                 return 0;
  61
  62         notif_ctx.eval_capture = LTTNG_READ_ONCE(event_notifier->eval_capture);
  63         event_notifier->send_notification(event_notifier, NULL, NULL, &notif_ctx);
  64
  65         return 0;
  66 }
  67
  68 static const struct lttng_kernel_type_common *event_type =
  69         lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER, 16);
  70
  71 /*
  72  * Create event description
  73  */
  74 static
  75 int lttng_create_kprobe_event(const char *name, struct lttng_event *event)
  76 {
  77         const struct lttng_kernel_event_field **fieldp_array;
  78         struct lttng_kernel_event_field *field;
  79         struct lttng_kernel_event_desc *desc;
  80         int ret;
  81
  82         desc = kzalloc(sizeof(*desc), GFP_KERNEL);
  83         if (!desc)
  84                 return -ENOMEM;
  85         desc->event_name = kstrdup(name, GFP_KERNEL);
  86         if (!desc->event_name) {
  87                 ret = -ENOMEM;
  88                 goto error_str;
  89         }
  90         desc->nr_fields = 1;
  91         fieldp_array = kzalloc(1 * sizeof(struct lttng_kernel_event_field *), GFP_KERNEL);
  92         if (!fieldp_array) {
  93                 ret = -ENOMEM;
  94                 goto error_fieldp_array;
  95         }
  96         desc->fields = fieldp_array;
  97         desc->fields[0] = field =
  98                 kzalloc(sizeof(struct lttng_kernel_event_field), GFP_KERNEL);
  99         if (!field) {
 100                 ret = -ENOMEM;
 101                 goto error_field;
 102         }
 103         field->name = "ip";
 104         field->type = event_type;
 105         desc->owner = THIS_MODULE;
 106         event->desc = desc;
 107
 108         return 0;
 109
 110 error_field:
 111         kfree(fieldp_array);
 112 error_fieldp_array:
 113         kfree(desc->event_name);
 114 error_str:
 115         kfree(desc);
 116         return ret;
 117 }
 118
 119 /*
 120  * Create event_notifier description
 121  */
 122 static
 123 int lttng_create_kprobe_event_notifier(const char *name, struct lttng_event_notifier *event_notifier)
 124 {
 125         struct lttng_kernel_event_desc *desc;
 126         int ret;
 127
 128         desc = kzalloc(sizeof(*desc), GFP_KERNEL);
 129         if (!desc)
 130                 return -ENOMEM;
 131         desc->event_name = kstrdup(name, GFP_KERNEL);
 132         if (!desc->event_name) {
 133                 ret = -ENOMEM;
 134                 goto error_str;
 135         }
 136         desc->nr_fields = 0;
 137
 138         desc->owner = THIS_MODULE;
 139         event_notifier->desc = desc;
 140
 141         return 0;
 142
 143 error_str:
 144         kfree(desc);
 145         return ret;
 146 }
 147
 148 static
 149 int _lttng_kprobes_register(const char *symbol_name,
 150                            uint64_t offset,
 151                            uint64_t addr,
 152                            struct lttng_kprobe *lttng_kp,
 153                            kprobe_pre_handler_t pre_handler)
 154 {
 155         int ret;
 156
 157         /* Kprobes expects a NULL symbol name if unused */
 158         if (symbol_name[0] == '\0')
 159                 symbol_name = NULL;
 160
 161         memset(&lttng_kp->kp, 0, sizeof(lttng_kp->kp));
 162         lttng_kp->kp.pre_handler = pre_handler;
 163
 164         if (symbol_name) {
 165                 lttng_kp->symbol_name =
 166                         kzalloc(LTTNG_KERNEL_SYM_NAME_LEN * sizeof(char),
 167                                 GFP_KERNEL);
 168                 if (!lttng_kp->symbol_name) {
 169                         ret = -ENOMEM;
 170                         goto name_error;
 171                 }
 172                 memcpy(lttng_kp->symbol_name, symbol_name,
 173                        LTTNG_KERNEL_SYM_NAME_LEN * sizeof(char));
 174                 lttng_kp->kp.symbol_name = lttng_kp->symbol_name;
 175         }
 176
 177         lttng_kp->kp.offset = offset;
 178         lttng_kp->kp.addr = (void *) (unsigned long) addr;
 179
 180         /*
 181          * Ensure the memory we just allocated don't notify page faults.
 182          * Well.. kprobes itself puts the page fault handler on the blacklist,
 183          * but we can never be too careful.
 184          */
 185         wrapper_vmalloc_sync_mappings();
 186
 187         ret = register_kprobe(&lttng_kp->kp);
 188         if (ret)
 189                 goto register_error;
 190
 191         return 0;
 192
 193 register_error:
 194         kfree(lttng_kp->symbol_name);
 195 name_error:
 196         return ret;
 197 }
 198
 199 int lttng_kprobes_register_event(const char *name,
 200                            const char *symbol_name,
 201                            uint64_t offset,
 202                            uint64_t addr,
 203                            struct lttng_event *event)
 204 {
 205         int ret;
 206
 207         ret = lttng_create_kprobe_event(name, event);
 208         if (ret)
 209                 goto error;
 210
 211         ret = _lttng_kprobes_register(symbol_name, offset, addr,
 212                 &event->u.kprobe, lttng_kprobes_event_handler_pre);
 213         if (ret)
 214                 goto register_error;
 215
 216         return 0;
 217
 218 register_error:
 219         kfree(event->desc->fields);
 220         kfree(event->desc->event_name);
 221         kfree(event->desc);
 222 error:
 223         return ret;
 224 }
 225 EXPORT_SYMBOL_GPL(lttng_kprobes_register_event);
 226
 227 int lttng_kprobes_register_event_notifier(const char *symbol_name,
 228                            uint64_t offset,
 229                            uint64_t addr,
 230                            struct lttng_event_notifier *event_notifier)
 231 {
 232         int ret;
 233         ret = lttng_create_kprobe_event_notifier(symbol_name, event_notifier);
 234         if (ret)
 235                 goto error;
 236
 237         ret = _lttng_kprobes_register(symbol_name, offset, addr,
 238                 &event_notifier->u.kprobe, lttng_kprobes_event_notifier_handler_pre);
 239         if (ret)
 240                 goto register_error;
 241
 242         return 0;
 243
 244 register_error:
 245         kfree(event_notifier->desc->event_name);
 246         kfree(event_notifier->desc);
 247 error:
 248         return ret;
 249 }
 250 EXPORT_SYMBOL_GPL(lttng_kprobes_register_event_notifier);
 251
 252 void lttng_kprobes_unregister_event(struct lttng_event *event)
 253 {
 254         unregister_kprobe(&event->u.kprobe.kp);
 255 }
 256 EXPORT_SYMBOL_GPL(lttng_kprobes_unregister_event);
 257
 258 void lttng_kprobes_unregister_event_notifier(struct lttng_event_notifier *event_notifier)
 259 {
 260         unregister_kprobe(&event_notifier->u.kprobe.kp);
 261 }
 262 EXPORT_SYMBOL_GPL(lttng_kprobes_unregister_event_notifier);
 263
 264 void lttng_kprobes_destroy_event_private(struct lttng_event *event)
 265 {
 266         kfree(event->u.kprobe.symbol_name);
 267         kfree(event->desc->fields[0]);
 268         kfree(event->desc->fields);
 269         kfree(event->desc->event_name);
 270         kfree(event->desc);
 271 }
 272 EXPORT_SYMBOL_GPL(lttng_kprobes_destroy_event_private);
 273
 274 void lttng_kprobes_destroy_event_notifier_private(struct lttng_event_notifier *event_notifier)
 275 {
 276         kfree(event_notifier->u.kprobe.symbol_name);
 277         kfree(event_notifier->desc->event_name);
 278         kfree(event_notifier->desc);
 279 }
 280 EXPORT_SYMBOL_GPL(lttng_kprobes_destroy_event_notifier_private);
 281
 282 MODULE_LICENSE("GPL and additional rights");
 283 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
 284 MODULE_DESCRIPTION("LTTng kprobes probes");
 285 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
 286         __stringify(LTTNG_MODULES_MINOR_VERSION) "."
 287         __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
 288         LTTNG_MODULES_EXTRAVERSION);