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