X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fprobes%2Flttng-kprobes.c;h=b7d1c85d9b01bdacc7c2dd27025d3e5a7f591b5d;hb=0c023c019b5c133847347f3da005dbb3288312ab;hp=e127d72fa4fd654e7f1b34c0abcca16c398eb533;hpb=585e5dcc4bf017c03b86dc84371f9c6170e12785;p=deliverable%2Flttng-modules.git diff --git a/src/probes/lttng-kprobes.c b/src/probes/lttng-kprobes.c index e127d72f..b7d1c85d 100644 --- a/src/probes/lttng-kprobes.c +++ b/src/probes/lttng-kprobes.c @@ -18,7 +18,7 @@ #include static -int lttng_kprobes_handler_pre(struct kprobe *p, struct pt_regs *regs) +int lttng_kprobes_event_handler_pre(struct kprobe *p, struct pt_regs *regs) { struct lttng_event *event = container_of(p, struct lttng_event, u.kprobe.kp); @@ -26,26 +26,58 @@ int lttng_kprobes_handler_pre(struct kprobe *p, struct pt_regs *regs) .event = event, .interruptible = !lttng_regs_irqs_disabled(regs), }; - struct lttng_channel *chan = event->chan; - struct lib_ring_buffer_ctx ctx; + struct lttng_event_container *container = event->container; int ret; unsigned long data = (unsigned long) p->addr; - if (unlikely(!LTTNG_READ_ONCE(chan->session->active))) + if (unlikely(!LTTNG_READ_ONCE(container->session->active))) return 0; - if (unlikely(!LTTNG_READ_ONCE(chan->enabled))) + if (unlikely(!LTTNG_READ_ONCE(container->enabled))) return 0; if (unlikely(!LTTNG_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) + switch (container->type) { + case LTTNG_EVENT_CONTAINER_CHANNEL: + { + struct lttng_channel *chan = lttng_event_container_get_channel(container); + struct lib_ring_buffer_ctx ctx; + + 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 0; + lib_ring_buffer_align_ctx(&ctx, lttng_alignof(data)); + chan->ops->event_write(&ctx, &data, sizeof(data)); + chan->ops->event_commit(&ctx); + break; + } + case LTTNG_EVENT_CONTAINER_COUNTER: + { + struct lttng_counter *counter = lttng_event_container_get_counter(container); + size_t index = event->id; + + (void) counter->ops->counter_add(counter->counter, &index, 1); + break; + } + } + return 0; +} + +static +int lttng_kprobes_event_notifier_handler_pre(struct kprobe *p, struct pt_regs *regs) +{ + struct lttng_event_notifier *event_notifier = + container_of(p, struct lttng_event_notifier, u.kprobe.kp); + struct lttng_kernel_notifier_ctx notif_ctx; + + if (unlikely(!READ_ONCE(event_notifier->enabled))) return 0; - lib_ring_buffer_align_ctx(&ctx, lttng_alignof(data)); - chan->ops->event_write(&ctx, &data, sizeof(data)); - chan->ops->event_commit(&ctx); + + notif_ctx.eval_capture = LTTNG_READ_ONCE(event_notifier->eval_capture); + event_notifier->send_notification(event_notifier, NULL, NULL, ¬if_ctx); + return 0; } @@ -94,11 +126,41 @@ error_str: return ret; } -int lttng_kprobes_register(const char *name, - const char *symbol_name, +/* + * Create event_notifier description + */ +static +int lttng_create_kprobe_event_notifier(const char *name, struct lttng_event_notifier *event_notifier) +{ + struct lttng_event_desc *desc; + int ret; + + desc = kzalloc(sizeof(*event_notifier->desc), GFP_KERNEL); + if (!desc) + return -ENOMEM; + desc->name = kstrdup(name, GFP_KERNEL); + if (!desc->name) { + ret = -ENOMEM; + goto error_str; + } + desc->nr_fields = 0; + + desc->owner = THIS_MODULE; + event_notifier->desc = desc; + + return 0; + +error_str: + kfree(desc); + return ret; +} + +static +int _lttng_kprobes_register(const char *symbol_name, uint64_t offset, uint64_t addr, - struct lttng_event *event) + struct lttng_kprobe *lttng_kp, + kprobe_pre_handler_t pre_handler) { int ret; @@ -106,64 +168,125 @@ int lttng_kprobes_register(const char *name, 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; + memset(<tng_kp->kp, 0, sizeof(lttng_kp->kp)); + lttng_kp->kp.pre_handler = pre_handler; + if (symbol_name) { - event->u.kprobe.symbol_name = + lttng_kp->symbol_name = kzalloc(LTTNG_KERNEL_SYM_NAME_LEN * sizeof(char), GFP_KERNEL); - if (!event->u.kprobe.symbol_name) { + if (!lttng_kp->symbol_name) { ret = -ENOMEM; goto name_error; } - memcpy(event->u.kprobe.symbol_name, symbol_name, + memcpy(lttng_kp->symbol_name, symbol_name, LTTNG_KERNEL_SYM_NAME_LEN * sizeof(char)); - event->u.kprobe.kp.symbol_name = - event->u.kprobe.symbol_name; + lttng_kp->kp.symbol_name = lttng_kp->symbol_name; } - event->u.kprobe.kp.offset = offset; - event->u.kprobe.kp.addr = (void *) (unsigned long) addr; + + lttng_kp->kp.offset = offset; + lttng_kp->kp.addr = (void *) (unsigned long) addr; /* - * Ensure the memory we just allocated don't trigger page faults. + * Ensure the memory we just allocated don't event_notifier page faults. * Well.. kprobes itself puts the page fault handler on the blacklist, * but we can never be too careful. */ wrapper_vmalloc_sync_mappings(); - ret = register_kprobe(&event->u.kprobe.kp); + ret = register_kprobe(<tng_kp->kp); if (ret) goto register_error; + return 0; register_error: - kfree(event->u.kprobe.symbol_name); + kfree(lttng_kp->symbol_name); name_error: + return ret; +} + +int lttng_kprobes_register_event(const char *name, + const char *symbol_name, + uint64_t offset, + uint64_t addr, + struct lttng_event *event) +{ + int ret; + + ret = lttng_create_kprobe_event(name, event); + if (ret) + goto error; + + ret = _lttng_kprobes_register(symbol_name, offset, addr, + &event->u.kprobe, lttng_kprobes_event_handler_pre); + if (ret) + goto register_error; + + return 0; + +register_error: kfree(event->desc->fields); kfree(event->desc->name); kfree(event->desc); error: return ret; } -EXPORT_SYMBOL_GPL(lttng_kprobes_register); +EXPORT_SYMBOL_GPL(lttng_kprobes_register_event); -void lttng_kprobes_unregister(struct lttng_event *event) +int lttng_kprobes_register_event_notifier(const char *symbol_name, + uint64_t offset, + uint64_t addr, + struct lttng_event_notifier *event_notifier) +{ + int ret; + ret = lttng_create_kprobe_event_notifier(symbol_name, event_notifier); + if (ret) + goto error; + + ret = _lttng_kprobes_register(symbol_name, offset, addr, + &event_notifier->u.kprobe, lttng_kprobes_event_notifier_handler_pre); + if (ret) + goto register_error; + + return 0; + +register_error: + kfree(event_notifier->desc->name); + kfree(event_notifier->desc); +error: + return ret; +} +EXPORT_SYMBOL_GPL(lttng_kprobes_register_event_notifier); + +void lttng_kprobes_unregister_event(struct lttng_event *event) { unregister_kprobe(&event->u.kprobe.kp); } -EXPORT_SYMBOL_GPL(lttng_kprobes_unregister); +EXPORT_SYMBOL_GPL(lttng_kprobes_unregister_event); -void lttng_kprobes_destroy_private(struct lttng_event *event) +void lttng_kprobes_unregister_event_notifier(struct lttng_event_notifier *event_notifier) +{ + unregister_kprobe(&event_notifier->u.kprobe.kp); +} +EXPORT_SYMBOL_GPL(lttng_kprobes_unregister_event_notifier); + +void lttng_kprobes_destroy_event_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_destroy_private); +EXPORT_SYMBOL_GPL(lttng_kprobes_destroy_event_private); + +void lttng_kprobes_destroy_event_notifier_private(struct lttng_event_notifier *event_notifier) +{ + kfree(event_notifier->u.kprobe.symbol_name); + kfree(event_notifier->desc->name); + kfree(event_notifier->desc); +} +EXPORT_SYMBOL_GPL(lttng_kprobes_destroy_event_notifier_private); MODULE_LICENSE("GPL and additional rights"); MODULE_AUTHOR("Mathieu Desnoyers ");