src/probes/lttng-kretprobes.c

   1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
   2  *
   3  * probes/lttng-kretprobes.c
   4  *
   5  * LTTng kretprobes integration module.
   6  *
   7  * Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   8  */
   9
  10 #include <linux/module.h>
  11 #include <wrapper/kprobes.h>
  12 #include <linux/slab.h>
  13 #include <linux/kref.h>
  14 #include <lttng/events.h>
  15 #include <lttng/events-internal.h>
  16 #include <ringbuffer/frontend_types.h>
  17 #include <wrapper/vmalloc.h>
  18 #include <wrapper/irqflags.h>
  19 #include <lttng/tracer.h>
  20 #include <blacklist/kprobes.h>
  21
  22 enum lttng_kretprobe_type {
  23         EVENT_ENTRY     = 0,
  24         EVENT_EXIT      = 1,
  25 };
  26
  27 struct lttng_krp {
  28         struct kretprobe krp;
  29         struct lttng_kernel_event_common *event[2];     /* ENTRY and EXIT */
  30         struct kref kref_register;
  31         struct kref kref_alloc;
  32 };
  33
  34 static
  35 int _lttng_kretprobes_handler(struct kretprobe_instance *krpi,
  36                               struct pt_regs *regs,
  37                               enum lttng_kretprobe_type type)
  38 {
  39         struct lttng_krp *lttng_krp =
  40                 container_of(lttng_get_kretprobe(krpi), struct lttng_krp, krp);
  41         struct lttng_kernel_event_common *event = lttng_krp->event[type];
  42         struct lttng_kernel_probe_ctx lttng_probe_ctx = {
  43                 .event = event,
  44                 .interruptible = !lttng_regs_irqs_disabled(regs),
  45         };
  46         struct {
  47                 unsigned long ip;
  48                 unsigned long parent_ip;
  49         } payload;
  50
  51         switch (event->type) {
  52         case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
  53         {
  54                 struct lttng_kernel_event_recorder *event_recorder =
  55                         container_of(event, struct lttng_kernel_event_recorder, parent);
  56                 struct lttng_channel *chan = event_recorder->chan;
  57
  58                 if (unlikely(!LTTNG_READ_ONCE(chan->session->active)))
  59                         return 0;
  60                 if (unlikely(!LTTNG_READ_ONCE(chan->enabled)))
  61                         return 0;
  62                 break;
  63         }
  64         case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:  /* Fall-through. */
  65         default:
  66                 WARN_ON_ONCE(1);
  67         }
  68
  69         if (unlikely(!LTTNG_READ_ONCE(event->enabled)))
  70                 return 0;
  71
  72         switch (event->type) {
  73         case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
  74         {
  75                 struct lttng_kernel_event_recorder *event_recorder =
  76                         container_of(event, struct lttng_kernel_event_recorder, parent);
  77                 struct lttng_channel *chan = event_recorder->chan;
  78                 struct lttng_kernel_ring_buffer_ctx ctx;
  79                 int ret;
  80
  81                 payload.ip = (unsigned long) lttng_get_kretprobe(krpi)->kp.addr;
  82                 payload.parent_ip = (unsigned long) krpi->ret_addr;
  83
  84                 lib_ring_buffer_ctx_init(&ctx, event_recorder, sizeof(payload),
  85                                          lttng_alignof(payload), &lttng_probe_ctx);
  86                 ret = chan->ops->event_reserve(&ctx);
  87                 if (ret < 0)
  88                         return 0;
  89                 lib_ring_buffer_align_ctx(&ctx, lttng_alignof(payload));
  90                 chan->ops->event_write(&ctx, &payload, sizeof(payload));
  91                 chan->ops->event_commit(&ctx);
  92                 break;
  93         }
  94         case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:  /* Fall-through. */
  95         default:
  96                 WARN_ON_ONCE(1);
  97         }
  98         return 0;
  99 }
 100
 101 static
 102 int lttng_kretprobes_handler_entry(struct kretprobe_instance *krpi,
 103                                    struct pt_regs *regs)
 104 {
 105         return _lttng_kretprobes_handler(krpi, regs, EVENT_ENTRY);
 106 }
 107
 108 static
 109 int lttng_kretprobes_handler_exit(struct kretprobe_instance *krpi,
 110                                   struct pt_regs *regs)
 111 {
 112         return _lttng_kretprobes_handler(krpi, regs, EVENT_EXIT);
 113 }
 114
 115 static const struct lttng_kernel_type_common *event_type =
 116         lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER, 16);
 117
 118 /*
 119  * Create event description
 120  */
 121 static
 122 int lttng_create_kprobe_event(const char *name, struct lttng_kernel_event_recorder *event_recorder,
 123                               enum lttng_kretprobe_type type)
 124 {
 125         const struct lttng_kernel_event_field **fieldp_array;
 126         struct lttng_kernel_event_field *field;
 127         struct lttng_kernel_event_desc *desc;
 128         char *alloc_name;
 129         size_t name_len;
 130         const char *suffix = NULL;
 131         int ret;
 132
 133         desc = kzalloc(sizeof(*desc), GFP_KERNEL);
 134         if (!desc)
 135                 return -ENOMEM;
 136         name_len = strlen(name);
 137         switch (type) {
 138         case EVENT_ENTRY:
 139                 suffix = "_entry";
 140                 break;
 141         case EVENT_EXIT:
 142                 suffix = "_exit";
 143                 break;
 144         }
 145         name_len += strlen(suffix);
 146         alloc_name = kmalloc(name_len + 1, GFP_KERNEL);
 147         if (!alloc_name) {
 148                 ret = -ENOMEM;
 149                 goto error_str;
 150         }
 151         strcpy(alloc_name, name);
 152         strcat(alloc_name, suffix);
 153         desc->event_name = alloc_name;
 154         desc->nr_fields = 2;
 155         fieldp_array = kzalloc(desc->nr_fields * sizeof(struct lttng_kernel_event_field *), GFP_KERNEL);
 156         if (!fieldp_array) {
 157                 ret = -ENOMEM;
 158                 goto error_fieldp_array;
 159         }
 160         desc->fields = fieldp_array;
 161
 162         field = kzalloc(sizeof(struct lttng_kernel_event_field), GFP_KERNEL);
 163         if (!field) {
 164                 ret = -ENOMEM;
 165                 goto error_field0;
 166         }
 167         field->name = "ip";
 168         field->type = event_type;
 169         desc->fields[0] = field;
 170
 171         field = kzalloc(sizeof(struct lttng_kernel_event_field), GFP_KERNEL);
 172         if (!field) {
 173                 ret = -ENOMEM;
 174                 goto error_field1;
 175         }
 176         field->name = "parent_ip";
 177         field->type = event_type;
 178         desc->fields[1] = field;
 179
 180         desc->owner = THIS_MODULE;
 181         event_recorder->priv->parent.desc = desc;
 182
 183         return 0;
 184
 185 error_field1:
 186         kfree(desc->fields[0]);
 187 error_field0:
 188         kfree(fieldp_array);
 189 error_fieldp_array:
 190         kfree(desc->event_name);
 191 error_str:
 192         kfree(desc);
 193         return ret;
 194 }
 195
 196 int lttng_kretprobes_register(const char *name,
 197                            const char *symbol_name,
 198                            uint64_t offset,
 199                            uint64_t addr,
 200                            struct lttng_kernel_event_recorder *event_recorder_entry,
 201                            struct lttng_kernel_event_recorder *event_recorder_exit)
 202 {
 203         int ret;
 204         struct lttng_krp *lttng_krp;
 205
 206         /* Kprobes expects a NULL symbol name if unused */
 207         if (symbol_name[0] == '\0')
 208                 symbol_name = NULL;
 209
 210         ret = lttng_create_kprobe_event(name, event_recorder_entry, EVENT_ENTRY);
 211         if (ret)
 212                 goto error;
 213         ret = lttng_create_kprobe_event(name, event_recorder_exit, EVENT_EXIT);
 214         if (ret)
 215                 goto event_exit_error;
 216         lttng_krp = kzalloc(sizeof(*lttng_krp), GFP_KERNEL);
 217         if (!lttng_krp)
 218                 goto krp_error;
 219         lttng_krp->krp.entry_handler = lttng_kretprobes_handler_entry;
 220         lttng_krp->krp.handler = lttng_kretprobes_handler_exit;
 221         if (symbol_name) {
 222                 char *alloc_symbol;
 223
 224                 alloc_symbol = kstrdup(symbol_name, GFP_KERNEL);
 225                 if (!alloc_symbol) {
 226                         ret = -ENOMEM;
 227                         goto name_error;
 228                 }
 229                 lttng_krp->krp.kp.symbol_name =
 230                         alloc_symbol;
 231                 event_recorder_entry->priv->parent.u.kretprobe.symbol_name =
 232                         alloc_symbol;
 233                 event_recorder_exit->priv->parent.u.kretprobe.symbol_name =
 234                         alloc_symbol;
 235         }
 236         lttng_krp->krp.kp.offset = offset;
 237         lttng_krp->krp.kp.addr = (void *) (unsigned long) addr;
 238
 239         /* Allow probe handler to find event structures */
 240         lttng_krp->event[EVENT_ENTRY] = &event_recorder_entry->parent;
 241         lttng_krp->event[EVENT_EXIT] = &event_recorder_exit->parent;
 242         event_recorder_entry->priv->parent.u.kretprobe.lttng_krp = lttng_krp;
 243         event_recorder_exit->priv->parent.u.kretprobe.lttng_krp = lttng_krp;
 244
 245         /*
 246          * Both events must be unregistered before the kretprobe is
 247          * unregistered. Same for memory allocation.
 248          */
 249         kref_init(&lttng_krp->kref_alloc);
 250         kref_get(&lttng_krp->kref_alloc);       /* inc refcount to 2, no overflow. */
 251         kref_init(&lttng_krp->kref_register);
 252         kref_get(&lttng_krp->kref_register);    /* inc refcount to 2, no overflow. */
 253
 254         /*
 255          * Ensure the memory we just allocated don't trigger page faults.
 256          * Well.. kprobes itself puts the page fault handler on the blacklist,
 257          * but we can never be too careful.
 258          */
 259         wrapper_vmalloc_sync_mappings();
 260
 261         ret = register_kretprobe(&lttng_krp->krp);
 262         if (ret)
 263                 goto register_error;
 264         return 0;
 265
 266 register_error:
 267         kfree(lttng_krp->krp.kp.symbol_name);
 268 name_error:
 269         kfree(lttng_krp);
 270 krp_error:
 271         kfree(event_recorder_exit->priv->parent.desc->fields[0]);
 272         kfree(event_recorder_exit->priv->parent.desc->fields[1]);
 273         kfree(event_recorder_exit->priv->parent.desc->fields);
 274         kfree(event_recorder_exit->priv->parent.desc->event_name);
 275         kfree(event_recorder_exit->priv->parent.desc);
 276 event_exit_error:
 277         kfree(event_recorder_entry->priv->parent.desc->fields[0]);
 278         kfree(event_recorder_entry->priv->parent.desc->fields[1]);
 279         kfree(event_recorder_entry->priv->parent.desc->fields);
 280         kfree(event_recorder_entry->priv->parent.desc->event_name);
 281         kfree(event_recorder_entry->priv->parent.desc);
 282 error:
 283         return ret;
 284 }
 285 EXPORT_SYMBOL_GPL(lttng_kretprobes_register);
 286
 287 static
 288 void _lttng_kretprobes_unregister_release(struct kref *kref)
 289 {
 290         struct lttng_krp *lttng_krp =
 291                 container_of(kref, struct lttng_krp, kref_register);
 292         unregister_kretprobe(&lttng_krp->krp);
 293 }
 294
 295 void lttng_kretprobes_unregister(struct lttng_kernel_event_recorder *event_recorder)
 296 {
 297         kref_put(&event_recorder->priv->parent.u.kretprobe.lttng_krp->kref_register,
 298                 _lttng_kretprobes_unregister_release);
 299 }
 300 EXPORT_SYMBOL_GPL(lttng_kretprobes_unregister);
 301
 302 static
 303 void _lttng_kretprobes_release(struct kref *kref)
 304 {
 305         struct lttng_krp *lttng_krp =
 306                 container_of(kref, struct lttng_krp, kref_alloc);
 307         kfree(lttng_krp->krp.kp.symbol_name);
 308 }
 309
 310 void lttng_kretprobes_destroy_private(struct lttng_kernel_event_recorder *event_recorder)
 311 {
 312         kfree(event_recorder->priv->parent.desc->fields[0]);
 313         kfree(event_recorder->priv->parent.desc->fields[1]);
 314         kfree(event_recorder->priv->parent.desc->fields);
 315         kfree(event_recorder->priv->parent.desc->event_name);
 316         kfree(event_recorder->priv->parent.desc);
 317         kref_put(&event_recorder->priv->parent.u.kretprobe.lttng_krp->kref_alloc,
 318                 _lttng_kretprobes_release);
 319 }
 320 EXPORT_SYMBOL_GPL(lttng_kretprobes_destroy_private);
 321
 322 int lttng_kretprobes_event_enable_state(struct lttng_kernel_event_common *event,
 323                 int enable)
 324 {
 325         struct lttng_kernel_event_common *event_exit;
 326         struct lttng_krp *lttng_krp;
 327
 328         if (event->priv->instrumentation != LTTNG_KERNEL_ABI_KRETPROBE) {
 329                 return -EINVAL;
 330         }
 331         if (event->enabled == enable) {
 332                 return -EBUSY;
 333         }
 334         lttng_krp = event->priv->u.kretprobe.lttng_krp;
 335         event_exit = lttng_krp->event[EVENT_EXIT];
 336         WRITE_ONCE(event->enabled, enable);
 337         WRITE_ONCE(event_exit->enabled, enable);
 338         return 0;
 339 }
 340 EXPORT_SYMBOL_GPL(lttng_kretprobes_event_enable_state);
 341
 342 MODULE_LICENSE("GPL and additional rights");
 343 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
 344 MODULE_DESCRIPTION("LTTng kretprobes probes");
 345 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
 346         __stringify(LTTNG_MODULES_MINOR_VERSION) "."
 347         __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
 348         LTTNG_MODULES_EXTRAVERSION);