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