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/file.h>
  14 #include <linux/list.h>
  15 #include <linux/module.h>
  16 #include <linux/namei.h>
  17 #include <linux/slab.h>
  18 #include <linux/uaccess.h>
  19 #include <lttng/events.h>
  20 #include <lttng/events-internal.h>
  21 #include <lttng/tracer.h>
  22 #include <wrapper/irqflags.h>
  23 #include <ringbuffer/frontend_types.h>
  24 #include <wrapper/uprobes.h>
  25 #include <wrapper/vmalloc.h>
  26
  27 static
  28 int lttng_uprobes_event_handler_pre(struct uprobe_consumer *uc, struct pt_regs *regs)
  29 {
  30         struct lttng_uprobe_handler *uprobe_handler =
  31                 container_of(uc, struct lttng_uprobe_handler, up_consumer);
  32         struct lttng_kernel_event_common *event = uprobe_handler->event;
  33         struct lttng_kernel_probe_ctx lttng_probe_ctx = {
  34                 .event = event,
  35                 .interruptible = !lttng_regs_irqs_disabled(regs),
  36         };
  37         struct {
  38                 unsigned long ip;
  39         } payload;
  40
  41         switch (event->type) {
  42         case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
  43         {
  44                 struct lttng_kernel_event_recorder *event_recorder =
  45                         container_of(event, struct lttng_kernel_event_recorder, parent);
  46                 struct lttng_kernel_channel_buffer *chan = event_recorder->chan;
  47
  48                 if (unlikely(!LTTNG_READ_ONCE(chan->parent.session->active)))
  49                         return 0;
  50                 if (unlikely(!LTTNG_READ_ONCE(chan->parent.enabled)))
  51                         return 0;
  52                 break;
  53         }
  54         case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
  55                 break;
  56         default:
  57                 WARN_ON_ONCE(1);
  58         }
  59
  60         if (unlikely(!LTTNG_READ_ONCE(event->enabled)))
  61                 return 0;
  62
  63         switch (event->type) {
  64         case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
  65         {
  66                 struct lttng_kernel_event_recorder *event_recorder =
  67                         container_of(event, struct lttng_kernel_event_recorder, parent);
  68                 struct lttng_kernel_channel_buffer *chan = event_recorder->chan;
  69                 struct lttng_kernel_ring_buffer_ctx ctx;
  70                 int ret;
  71
  72                 lib_ring_buffer_ctx_init(&ctx, event_recorder,
  73                         sizeof(payload), lttng_alignof(payload), &lttng_probe_ctx);
  74
  75                 ret = chan->ops->event_reserve(&ctx);
  76                 if (ret < 0)
  77                         return 0;
  78
  79                 /* Event payload. */
  80                 payload.ip = (unsigned long)instruction_pointer(regs);
  81
  82                 chan->ops->event_write(&ctx, &payload, sizeof(payload), lttng_alignof(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_event_field *event_fields[] = {
 103         lttng_kernel_static_event_field("ip",
 104                 lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER, 16),
 105                 false, false),
 106 };
 107
 108 static const struct lttng_kernel_tracepoint_class tp_class = {
 109         .nr_fields = ARRAY_SIZE(event_fields),
 110         .fields = event_fields,
 111 };
 112
 113 /*
 114  * Create event description.
 115  */
 116 static
 117 int lttng_create_uprobe_event(const char *name, struct lttng_kernel_event_recorder *event_recorder)
 118 {
 119         struct lttng_kernel_event_desc *desc;
 120         int ret;
 121
 122         desc = kzalloc(sizeof(*desc), GFP_KERNEL);
 123         if (!desc)
 124                 return -ENOMEM;
 125         desc->tp_class = &tp_class;
 126         desc->event_name = kstrdup(name, GFP_KERNEL);
 127         if (!desc->event_name) {
 128                 ret = -ENOMEM;
 129                 goto error_str;
 130         }
 131         desc->owner = THIS_MODULE;
 132         event_recorder->priv->parent.desc = desc;
 133
 134         return 0;
 135
 136 error_str:
 137         kfree(desc);
 138         return ret;
 139 }
 140
 141 /*
 142  * Create event_notifier description.
 143  */
 144 static
 145 int lttng_create_uprobe_event_notifier(const char *name, struct lttng_kernel_event_notifier *event_notifier)
 146 {
 147         struct lttng_kernel_event_desc *desc;
 148         int ret;
 149
 150         desc = kzalloc(sizeof(*desc), GFP_KERNEL);
 151         if (!desc)
 152                 return -ENOMEM;
 153         desc->tp_class = &tp_class;
 154         desc->event_name = kstrdup(name, GFP_KERNEL);
 155         if (!desc->event_name) {
 156                 ret = -ENOMEM;
 157                 goto error_str;
 158         }
 159         desc->owner = THIS_MODULE;
 160         event_notifier->priv->parent.desc = desc;
 161
 162         return 0;
 163
 164 error_str:
 165         kfree(desc);
 166         return ret;
 167 }
 168
 169 /*
 170  * Returns the inode struct from the current task and an fd. The inode is
 171  * grabbed by this function and must be put once we are done with it using
 172  * iput().
 173  */
 174 static struct inode *get_inode_from_fd(int fd)
 175 {
 176         struct file *file;
 177         struct inode *inode;
 178
 179         rcu_read_lock();
 180         /*
 181          * Returns the file backing the given fd. Needs to be done inside an RCU
 182          * critical section.
 183          */
 184         file = lttng_lookup_fdget_rcu(fd);
 185         if (file == NULL) {
 186                 printk(KERN_WARNING "LTTng: Cannot access file backing the fd(%d)\n", fd);
 187                 inode = NULL;
 188                 goto error;
 189         }
 190
 191         /* Grab a reference on the inode. */
 192         inode = igrab(file->f_path.dentry->d_inode);
 193         if (inode == NULL)
 194                 printk(KERN_WARNING "LTTng: Cannot grab a reference on the inode.\n");
 195
 196 error:
 197         rcu_read_unlock();
 198         if (file)
 199                 fput(file);
 200         return inode;
 201 }
 202
 203
 204 static
 205 int lttng_uprobes_add_callsite(struct lttng_uprobe *uprobe,
 206         struct lttng_kernel_abi_event_callsite __user *callsite,
 207         int (*handler)(struct uprobe_consumer *self, struct pt_regs *regs),
 208         void *priv_data)
 209 {
 210         int ret = 0;
 211         struct lttng_uprobe_handler *uprobe_handler;
 212
 213         if (!priv_data) {
 214                 ret = -EINVAL;
 215                 goto end;
 216         }
 217
 218         uprobe_handler = kzalloc(sizeof(struct lttng_uprobe_handler), GFP_KERNEL);
 219         if (!uprobe_handler) {
 220                 printk(KERN_WARNING "LTTng: Error allocating uprobe_handler");
 221                 ret = -ENOMEM;
 222                 goto end;
 223         }
 224
 225         /* Ensure the memory we just allocated don't notify page faults. */
 226         wrapper_vmalloc_sync_mappings();
 227
 228         uprobe_handler->event = priv_data;
 229         uprobe_handler->up_consumer.handler = handler;
 230
 231         ret = copy_from_user(&uprobe_handler->offset, &callsite->u.uprobe.offset, sizeof(uint64_t));
 232         if (ret) {
 233                 goto register_error;
 234         }
 235
 236         ret = wrapper_uprobe_register(uprobe->inode,
 237                       uprobe_handler->offset, &uprobe_handler->up_consumer);
 238         if (ret) {
 239                 printk(KERN_WARNING "LTTng: Error registering probe on inode %lu "
 240                        "and offset 0x%llx\n", uprobe->inode->i_ino,
 241                        uprobe_handler->offset);
 242                 ret = -1;
 243                 goto register_error;
 244         }
 245
 246         list_add(&uprobe_handler->node, &uprobe->head);
 247
 248         return ret;
 249
 250 register_error:
 251         kfree(uprobe_handler);
 252 end:
 253         return ret;
 254 }
 255
 256 int lttng_uprobes_event_add_callsite(struct lttng_kernel_event_common *event,
 257         struct lttng_kernel_abi_event_callsite __user *callsite)
 258 {
 259         return lttng_uprobes_add_callsite(&event->priv->u.uprobe, callsite,
 260                 lttng_uprobes_event_handler_pre, event);
 261 }
 262 EXPORT_SYMBOL_GPL(lttng_uprobes_event_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 void lttng_uprobes_unregister_event(struct lttng_kernel_event_recorder *event_recorder)
 345 {
 346         lttng_uprobes_unregister(event_recorder->priv->parent.u.uprobe.inode, &event_recorder->priv->parent.u.uprobe.head);
 347 }
 348 EXPORT_SYMBOL_GPL(lttng_uprobes_unregister_event);
 349
 350 void lttng_uprobes_unregister_event_notifier(struct lttng_kernel_event_notifier *event_notifier)
 351 {
 352         lttng_uprobes_unregister(event_notifier->priv->parent.u.uprobe.inode, &event_notifier->priv->parent.u.uprobe.head);
 353 }
 354 EXPORT_SYMBOL_GPL(lttng_uprobes_unregister_event_notifier);
 355
 356 void lttng_uprobes_destroy_event_private(struct lttng_kernel_event_recorder *event_recorder)
 357 {
 358         iput(event_recorder->priv->parent.u.uprobe.inode);
 359         kfree(event_recorder->priv->parent.desc->event_name);
 360         kfree(event_recorder->priv->parent.desc);
 361 }
 362 EXPORT_SYMBOL_GPL(lttng_uprobes_destroy_event_private);
 363
 364 void lttng_uprobes_destroy_event_notifier_private(struct lttng_kernel_event_notifier *event_notifier)
 365 {
 366         iput(event_notifier->priv->parent.u.uprobe.inode);
 367         kfree(event_notifier->priv->parent.desc->event_name);
 368         kfree(event_notifier->priv->parent.desc);
 369 }
 370 EXPORT_SYMBOL_GPL(lttng_uprobes_destroy_event_notifier_private);
 371
 372 MODULE_LICENSE("GPL and additional rights");
 373 MODULE_AUTHOR("Yannick Brosseau");
 374 MODULE_DESCRIPTION("Linux Trace Toolkit Uprobes Support");