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