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