X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=probes%2Flttng-kprobes.c;h=40fe0f68d54e41e8d032ece226ef117cbf06a416;hb=ceabb767180e064629b5a9ab4ed14449da864763;hp=eb6e16a0c129e1afb9fc366c36ae2d39c6c36ace;hpb=d6d808f3780d0b519aaf966e66df501730db7d13;p=lttng-modules.git diff --git a/probes/lttng-kprobes.c b/probes/lttng-kprobes.c index eb6e16a0..40fe0f68 100644 --- a/probes/lttng-kprobes.c +++ b/probes/lttng-kprobes.c @@ -1,40 +1,174 @@ -/* - * (C) Copyright 2009-2011 - - * Mathieu Desnoyers +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) + * + * probes/lttng-kprobes.c * * LTTng kprobes integration module. * - * Dual LGPL v2.1/GPL v2 license. + * Copyright (C) 2009-2012 Mathieu Desnoyers */ #include #include -#include "../ltt-events.h" -#include "../wrapper/ringbuffer/frontend_types.h" -#include "../ltt-tracer.h" +#include +#include +#include +#include +#include +#include +#include -void lttng_kprobes_handler_pre(struct kprobe *p, struct pt_regs *regs) +static +int lttng_kprobes_handler_pre(struct kprobe *p, struct pt_regs *regs) { - struct ltt_event *event = - container_of(p, struct ltt_event, u.kprobe.kp); - struct ltt_channel *chan = event->chan; + struct lttng_event *event = + container_of(p, struct lttng_event, u.kprobe.kp); + struct lttng_probe_ctx lttng_probe_ctx = { + .event = event, + .interruptible = !lttng_regs_irqs_disabled(regs), + }; + struct lttng_channel *chan = event->chan; struct lib_ring_buffer_ctx ctx; int ret; unsigned long data = (unsigned long) p->addr; - if (!ACCESS_ONCE(chan->session->active)) - return; - lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, sizeof(data), - ltt_alignof(data), -1); - ret = chan->ops->event_reserve(&ctx); + if (unlikely(!READ_ONCE(chan->session->active))) + return 0; + if (unlikely(!READ_ONCE(chan->enabled))) + return 0; + if (unlikely(!READ_ONCE(event->enabled))) + return 0; + + lib_ring_buffer_ctx_init(&ctx, chan->chan, <tng_probe_ctx, sizeof(data), + lttng_alignof(data), -1); + ret = chan->ops->event_reserve(&ctx, event->id); if (ret < 0) - return; - lib_ring_buffer_align_ctx(&ctx, ltt_alignof(data)); + return 0; + lib_ring_buffer_align_ctx(&ctx, lttng_alignof(data)); chan->ops->event_write(&ctx, &data, sizeof(data)); chan->ops->event_commit(&ctx); + return 0; +} + +/* + * Create event description + */ +static +int lttng_create_kprobe_event(const char *name, struct lttng_event *event) +{ + struct lttng_event_field *field; + struct lttng_event_desc *desc; + int ret; + + desc = kzalloc(sizeof(*event->desc), GFP_KERNEL); + if (!desc) + return -ENOMEM; + desc->name = kstrdup(name, GFP_KERNEL); + if (!desc->name) { + ret = -ENOMEM; + goto error_str; + } + desc->nr_fields = 1; + desc->fields = field = + kzalloc(1 * sizeof(struct lttng_event_field), GFP_KERNEL); + if (!field) { + ret = -ENOMEM; + goto error_field; + } + field->name = "ip"; + field->type.atype = atype_integer; + field->type.u.integer.size = sizeof(unsigned long) * CHAR_BIT; + field->type.u.integer.alignment = lttng_alignof(unsigned long) * CHAR_BIT; + field->type.u.integer.signedness = lttng_is_signed_type(unsigned long); + field->type.u.integer.reverse_byte_order = 0; + field->type.u.integer.base = 16; + field->type.u.integer.encoding = lttng_encode_none; + desc->owner = THIS_MODULE; + event->desc = desc; + + return 0; + +error_field: + kfree(desc->name); +error_str: + kfree(desc); + return ret; +} + +int lttng_kprobes_register(const char *name, + const char *symbol_name, + uint64_t offset, + uint64_t addr, + struct lttng_event *event) +{ + int ret; + + /* Kprobes expects a NULL symbol name if unused */ + if (symbol_name[0] == '\0') + symbol_name = NULL; + + ret = lttng_create_kprobe_event(name, event); + if (ret) + goto error; + memset(&event->u.kprobe.kp, 0, sizeof(event->u.kprobe.kp)); + event->u.kprobe.kp.pre_handler = lttng_kprobes_handler_pre; + if (symbol_name) { + event->u.kprobe.symbol_name = + kzalloc(LTTNG_KERNEL_SYM_NAME_LEN * sizeof(char), + GFP_KERNEL); + if (!event->u.kprobe.symbol_name) { + ret = -ENOMEM; + goto name_error; + } + memcpy(event->u.kprobe.symbol_name, symbol_name, + LTTNG_KERNEL_SYM_NAME_LEN * sizeof(char)); + event->u.kprobe.kp.symbol_name = + event->u.kprobe.symbol_name; + } + event->u.kprobe.kp.offset = offset; + event->u.kprobe.kp.addr = (void *) (unsigned long) addr; + + /* + * Ensure the memory we just allocated don't trigger page faults. + * Well.. kprobes itself puts the page fault handler on the blacklist, + * but we can never be too careful. + */ + wrapper_vmalloc_sync_all(); + + ret = register_kprobe(&event->u.kprobe.kp); + if (ret) + goto register_error; + return 0; + +register_error: + kfree(event->u.kprobe.symbol_name); +name_error: + kfree(event->desc->fields); + kfree(event->desc->name); + kfree(event->desc); +error: + return ret; +} +EXPORT_SYMBOL_GPL(lttng_kprobes_register); + +void lttng_kprobes_unregister(struct lttng_event *event) +{ + unregister_kprobe(&event->u.kprobe.kp); +} +EXPORT_SYMBOL_GPL(lttng_kprobes_unregister); + +void lttng_kprobes_destroy_private(struct lttng_event *event) +{ + kfree(event->u.kprobe.symbol_name); + kfree(event->desc->fields); + kfree(event->desc->name); + kfree(event->desc); } -EXPORT_SYMBOL_GPL(lttng_kprobes_handler_pre); +EXPORT_SYMBOL_GPL(lttng_kprobes_destroy_private); MODULE_LICENSE("GPL and additional rights"); -MODULE_AUTHOR("Mathieu Desnoyers"); -MODULE_DESCRIPTION("Linux Trace Toolkit Kprobes Support"); +MODULE_AUTHOR("Mathieu Desnoyers "); +MODULE_DESCRIPTION("LTTng kprobes probes"); +MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "." + __stringify(LTTNG_MODULES_MINOR_VERSION) "." + __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION) + LTTNG_MODULES_EXTRAVERSION);