src/probes/lttng-uprobes.c

   1 /* SPDX-License-Identifier: (GPL-2.0-only OR LGPL-2.1-only)
   2  *
   3  * probes/lttng-uprobes.c
   4  *
   5  * LTTng uprobes integration module.
   6  *
   7  * Copyright (C) 2013 Yannick Brosseau <yannick.brosseau@gmail.com>
   8  * Copyright (C) 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   9  *
  10  */
  11
  12 #include <wrapper/fdtable.h>
  13 #include <linux/list.h>
  14 #include <linux/module.h>
  15 #include <linux/namei.h>
  16 #include <linux/slab.h>
  17 #include <linux/uaccess.h>
  18 #include <lttng/events.h>
  19 #include <lttng/events-internal.h>
  20 #include <lttng/tracer.h>
  21 #include <wrapper/irqflags.h>
  22 #include <ringbuffer/frontend_types.h>
  23 #include <wrapper/uprobes.h>
  24 #include <wrapper/vmalloc.h>
  25
  26 static
  27 int lttng_uprobes_event_handler_pre(struct uprobe_consumer *uc, struct pt_regs *regs)
  28 {
  29         struct lttng_uprobe_handler *uprobe_handler =
  30                 container_of(uc, struct lttng_uprobe_handler, up_consumer);
  31         struct lttng_kernel_event_recorder *event_recorder = uprobe_handler->u.event;
  32         struct lttng_probe_ctx lttng_probe_ctx = {
  33                 .event = event_recorder,
  34                 .interruptible = !lttng_regs_irqs_disabled(regs),
  35         };
  36         struct lttng_channel *chan = event_recorder->chan;
  37         struct lib_ring_buffer_ctx ctx;
  38         int ret;
  39
  40         struct {
  41                 unsigned long ip;
  42         } payload;
  43
  44         if (unlikely(!LTTNG_READ_ONCE(chan->session->active)))
  45                 return 0;
  46         if (unlikely(!LTTNG_READ_ONCE(chan->enabled)))
  47                 return 0;
  48         if (unlikely(!LTTNG_READ_ONCE(event_recorder->parent.enabled)))
  49                 return 0;
  50
  51         lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx,
  52                 sizeof(payload), lttng_alignof(payload), -1);
  53
  54         ret = chan->ops->event_reserve(&ctx, event_recorder->priv->id);
  55         if (ret < 0)
  56                 return 0;
  57
  58         /* Event payload. */
  59         payload.ip = (unsigned long)instruction_pointer(regs);
  60
  61         lib_ring_buffer_align_ctx(&ctx, lttng_alignof(payload));
  62         chan->ops->event_write(&ctx, &payload, sizeof(payload));
  63         chan->ops->event_commit(&ctx);
  64         return 0;
  65 }
  66
  67 static
  68 int lttng_uprobes_event_notifier_handler_pre(struct uprobe_consumer *uc, struct pt_regs *regs)
  69 {
  70         struct lttng_uprobe_handler *uprobe_handler =
  71                 container_of(uc, struct lttng_uprobe_handler, up_consumer);
  72         struct lttng_kernel_event_notifier *event_notifier = uprobe_handler->u.event_notifier;
  73         struct lttng_kernel_notification_ctx notif_ctx;
  74
  75         if (unlikely(!READ_ONCE(event_notifier->parent.enabled)))
  76                 return 0;
  77
  78         notif_ctx.eval_capture = LTTNG_READ_ONCE(event_notifier->eval_capture);
  79         event_notifier->notification_send(event_notifier, NULL, NULL, &notif_ctx);
  80         return 0;
  81 }
  82
  83 static const struct lttng_kernel_type_common *event_type =
  84         lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER, 16);
  85
  86 /*
  87  * Create event description.
  88  */
  89 static
  90 int lttng_create_uprobe_event(const char *name, struct lttng_kernel_event_recorder *event_recorder)
  91 {
  92         const struct lttng_kernel_event_field **fieldp_array;
  93         struct lttng_kernel_event_field *field;
  94         struct lttng_kernel_event_desc *desc;
  95         int ret;
  96
  97         desc = kzalloc(sizeof(*desc), GFP_KERNEL);
  98         if (!desc)
  99                 return -ENOMEM;
 100         desc->event_name = kstrdup(name, GFP_KERNEL);
 101         if (!desc->event_name) {
 102                 ret = -ENOMEM;
 103                 goto error_str;
 104         }
 105         desc->nr_fields = 1;
 106         fieldp_array = kzalloc(1 * sizeof(struct lttng_kernel_event_field *), GFP_KERNEL);
 107         if (!fieldp_array) {
 108                 ret = -ENOMEM;
 109                 goto error_fieldp_array;
 110         }
 111         desc->fields = fieldp_array;
 112         desc->fields[0] = field =
 113                 kzalloc(sizeof(struct lttng_kernel_event_field), GFP_KERNEL);
 114         if (!field) {
 115                 ret = -ENOMEM;
 116                 goto error_field;
 117         }
 118         field->name = "ip";
 119         field->type = event_type;
 120         desc->owner = THIS_MODULE;
 121         event_recorder->priv->parent.desc = desc;
 122
 123         return 0;
 124
 125 error_field:
 126         kfree(fieldp_array);
 127 error_fieldp_array:
 128         kfree(desc->event_name);
 129 error_str:
 130         kfree(desc);
 131         return ret;
 132 }
 133
 134 /*
 135  * Create event_notifier description.
 136  */
 137 static
 138 int lttng_create_uprobe_event_notifier(const char *name, struct lttng_kernel_event_notifier *event_notifier)
 139 {
 140         struct lttng_kernel_event_desc *desc;
 141         int ret;
 142
 143         desc = kzalloc(sizeof(*desc), GFP_KERNEL);
 144         if (!desc)
 145                 return -ENOMEM;
 146         desc->event_name = kstrdup(name, GFP_KERNEL);
 147         if (!desc->event_name) {
 148                 ret = -ENOMEM;
 149                 goto error_str;
 150         }
 151
 152         desc->nr_fields = 0;
 153
 154         desc->owner = THIS_MODULE;
 155         event_notifier->priv->parent.desc = desc;
 156
 157         return 0;
 158
 159 error_str:
 160         kfree(desc);
 161         return ret;
 162 }
 163
 164 /*
 165  * Returns the inode struct from the current task and an fd. The inode is
 166  * grabbed by this function and must be put once we are done with it using
 167  * iput().
 168  */
 169 static struct inode *get_inode_from_fd(int fd)
 170 {
 171         struct file *file;
 172         struct inode *inode;
 173
 174         rcu_read_lock();
 175         /*
 176          * Returns the file backing the given fd. Needs to be done inside an RCU
 177          * critical section.
 178          */
 179         file = lttng_lookup_fd_rcu(fd);
 180         if (file == NULL) {
 181                 printk(KERN_WARNING "LTTng: Cannot access file backing the fd(%d)\n", fd);
 182                 inode = NULL;
 183                 goto error;
 184         }
 185
 186         /* Grab a reference on the inode. */
 187         inode = igrab(file->f_path.dentry->d_inode);
 188         if (inode == NULL)
 189                 printk(KERN_WARNING "LTTng: Cannot grab a reference on the inode.\n");
 190 error:
 191         rcu_read_unlock();
 192         return inode;
 193 }
 194
 195
 196 static
 197 int lttng_uprobes_add_callsite(struct lttng_uprobe *uprobe,
 198         struct lttng_kernel_abi_event_callsite __user *callsite,
 199         int (*handler)(struct uprobe_consumer *self, struct pt_regs *regs),
 200         void *priv_data)
 201 {
 202         int ret = 0;
 203         struct lttng_uprobe_handler *uprobe_handler;
 204
 205         if (!priv_data) {
 206                 ret = -EINVAL;
 207                 goto end;
 208         }
 209
 210         uprobe_handler = kzalloc(sizeof(struct lttng_uprobe_handler), GFP_KERNEL);
 211         if (!uprobe_handler) {
 212                 printk(KERN_WARNING "LTTng: Error allocating uprobe_handler");
 213                 ret = -ENOMEM;
 214                 goto end;
 215         }
 216
 217         /* Ensure the memory we just allocated don't notify page faults. */
 218         wrapper_vmalloc_sync_mappings();
 219
 220         uprobe_handler->u.event = priv_data;
 221         uprobe_handler->up_consumer.handler = handler;
 222
 223         ret = copy_from_user(&uprobe_handler->offset, &callsite->u.uprobe.offset, sizeof(uint64_t));
 224         if (ret) {
 225                 goto register_error;
 226         }
 227
 228         ret = wrapper_uprobe_register(uprobe->inode,
 229                       uprobe_handler->offset, &uprobe_handler->up_consumer);
 230         if (ret) {
 231                 printk(KERN_WARNING "LTTng: Error registering probe on inode %lu "
 232                        "and offset 0x%llx\n", uprobe->inode->i_ino,
 233                        uprobe_handler->offset);
 234                 ret = -1;
 235                 goto register_error;
 236         }
 237
 238         list_add(&uprobe_handler->node, &uprobe->head);
 239
 240         return ret;
 241
 242 register_error:
 243         kfree(uprobe_handler);
 244 end:
 245         return ret;
 246 }
 247
 248 int lttng_uprobes_event_add_callsite(struct lttng_kernel_event_recorder *event_recorder,
 249         struct lttng_kernel_abi_event_callsite __user *callsite)
 250 {
 251         return lttng_uprobes_add_callsite(&event_recorder->priv->parent.u.uprobe, callsite,
 252                 lttng_uprobes_event_handler_pre, event_recorder);
 253 }
 254 EXPORT_SYMBOL_GPL(lttng_uprobes_event_add_callsite);
 255
 256 int lttng_uprobes_event_notifier_add_callsite(struct lttng_kernel_event_notifier *event_notifier,
 257         struct lttng_kernel_abi_event_callsite __user *callsite)
 258 {
 259         return lttng_uprobes_add_callsite(&event_notifier->priv->parent.u.uprobe, callsite,
 260                 lttng_uprobes_event_notifier_handler_pre, event_notifier);
 261 }
 262 EXPORT_SYMBOL_GPL(lttng_uprobes_event_notifier_add_callsite);
 263
 264 static
 265 int lttng_uprobes_register(struct lttng_uprobe *uprobe, int fd)
 266 {
 267         int ret = 0;
 268         struct inode *inode;
 269
 270         inode = get_inode_from_fd(fd);
 271         if (!inode) {
 272                 printk(KERN_WARNING "LTTng: Cannot get inode from fd\n");
 273                 ret = -EBADF;
 274                 goto inode_error;
 275         }
 276         uprobe->inode = inode;
 277         INIT_LIST_HEAD(&uprobe->head);
 278
 279 inode_error:
 280         return ret;
 281 }
 282
 283 int lttng_uprobes_register_event(const char *name, int fd, struct lttng_kernel_event_recorder *event_recorder)
 284 {
 285         int ret = 0;
 286
 287         ret = lttng_create_uprobe_event(name, event_recorder);
 288         if (ret)
 289                 goto error;
 290
 291         ret = lttng_uprobes_register(&event_recorder->priv->parent.u.uprobe, fd);
 292         if (ret)
 293                 goto register_error;
 294
 295         return 0;
 296
 297 register_error:
 298         kfree(event_recorder->priv->parent.desc->event_name);
 299         kfree(event_recorder->priv->parent.desc);
 300 error:
 301         return ret;
 302 }
 303 EXPORT_SYMBOL_GPL(lttng_uprobes_register_event);
 304
 305 int lttng_uprobes_register_event_notifier(const char *name, int fd,
 306                 struct lttng_kernel_event_notifier *event_notifier)
 307 {
 308         int ret = 0;
 309
 310         ret = lttng_create_uprobe_event_notifier(name, event_notifier);
 311         if (ret)
 312                 goto error;
 313
 314         ret = lttng_uprobes_register(&event_notifier->priv->parent.u.uprobe, fd);
 315         if (ret)
 316                 goto register_error;
 317
 318         return 0;
 319
 320 register_error:
 321         kfree(event_notifier->priv->parent.desc->event_name);
 322         kfree(event_notifier->priv->parent.desc);
 323 error:
 324         return ret;
 325 }
 326 EXPORT_SYMBOL_GPL(lttng_uprobes_register_event_notifier);
 327
 328 static
 329 void lttng_uprobes_unregister(struct inode *inode, struct list_head *head)
 330 {
 331         struct lttng_uprobe_handler *iter, *tmp;
 332
 333         /*
 334          * Iterate over the list of handler, remove each handler from the list
 335          * and free the struct.
 336          */
 337         list_for_each_entry_safe(iter, tmp, head, node) {
 338                 wrapper_uprobe_unregister(inode, iter->offset, &iter->up_consumer);
 339                 list_del(&iter->node);
 340                 kfree(iter);
 341         }
 342
 343 }
 344
 345 void lttng_uprobes_unregister_event(struct lttng_kernel_event_recorder *event_recorder)
 346 {
 347         lttng_uprobes_unregister(event_recorder->priv->parent.u.uprobe.inode, &event_recorder->priv->parent.u.uprobe.head);
 348 }
 349 EXPORT_SYMBOL_GPL(lttng_uprobes_unregister_event);
 350
 351 void lttng_uprobes_unregister_event_notifier(struct lttng_kernel_event_notifier *event_notifier)
 352 {
 353         lttng_uprobes_unregister(event_notifier->priv->parent.u.uprobe.inode, &event_notifier->priv->parent.u.uprobe.head);
 354 }
 355 EXPORT_SYMBOL_GPL(lttng_uprobes_unregister_event_notifier);
 356
 357 void lttng_uprobes_destroy_event_private(struct lttng_kernel_event_recorder *event_recorder)
 358 {
 359         iput(event_recorder->priv->parent.u.uprobe.inode);
 360         kfree(event_recorder->priv->parent.desc->fields[0]);
 361         kfree(event_recorder->priv->parent.desc->fields);
 362         kfree(event_recorder->priv->parent.desc->event_name);
 363         kfree(event_recorder->priv->parent.desc);
 364 }
 365 EXPORT_SYMBOL_GPL(lttng_uprobes_destroy_event_private);
 366
 367 void lttng_uprobes_destroy_event_notifier_private(struct lttng_kernel_event_notifier *event_notifier)
 368 {
 369         iput(event_notifier->priv->parent.u.uprobe.inode);
 370         kfree(event_notifier->priv->parent.desc->event_name);
 371         kfree(event_notifier->priv->parent.desc);
 372 }
 373 EXPORT_SYMBOL_GPL(lttng_uprobes_destroy_event_notifier_private);
 374
 375 MODULE_LICENSE("GPL and additional rights");
 376 MODULE_AUTHOR("Yannick Brosseau");
 377 MODULE_DESCRIPTION("Linux Trace Toolkit Uprobes Support");