X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=probes%2Flttng-ftrace.c;h=2a939216ef5e3233edc484b66dcb288837f42a99;hb=a90917c3f8c4ed79117f1caa333b29a2108084ec;hp=3ec000ae576e8b5adde12b6bb27fc4b408f033fc;hpb=5a9479dcba0b43d326569fa0bd48318222d23fcb;p=lttng-modules.git diff --git a/probes/lttng-ftrace.c b/probes/lttng-ftrace.c index 3ec000ae..2a939216 100644 --- a/probes/lttng-ftrace.c +++ b/probes/lttng-ftrace.c @@ -7,19 +7,30 @@ * Dual LGPL v2.1/GPL v2 license. */ +/* + * Ftrace function tracer does not seem to provide synchronization between probe + * teardown and callback execution. Therefore, we make this module permanently + * loaded (unloadable). + * + * TODO: Move to register_ftrace_function() (which is exported for + * modules) for Linux >= 3.0. It is faster (only enables the selected + * functions), and will stay there. + */ + #include #include #include -#include "../ltt-events.h" +#include "../lttng-events.h" #include "../wrapper/ringbuffer/frontend_types.h" #include "../wrapper/ftrace.h" -#include "../ltt-tracer.h" +#include "../wrapper/vmalloc.h" +#include "../lttng-tracer.h" static void lttng_ftrace_handler(unsigned long ip, unsigned long parent_ip, void **data) { - struct ltt_event *event = *data; - struct ltt_channel *chan = event->chan; + struct lttng_event *event = *data; + struct lttng_channel *chan = event->chan; struct lib_ring_buffer_ctx ctx; struct { unsigned long ip; @@ -27,16 +38,21 @@ void lttng_ftrace_handler(unsigned long ip, unsigned long parent_ip, void **data } payload; int ret; - if (!ACCESS_ONCE(chan->session->active)) + if (unlikely(!ACCESS_ONCE(chan->session->active))) return; - lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, - sizeof(payload), ltt_alignof(payload), -1); - ret = chan->ops->event_reserve(&ctx); + if (unlikely(!ACCESS_ONCE(chan->enabled))) + return; + if (unlikely(!ACCESS_ONCE(event->enabled))) + return; + + lib_ring_buffer_ctx_init(&ctx, chan->chan, event, + sizeof(payload), lttng_alignof(payload), -1); + ret = chan->ops->event_reserve(&ctx, event->id); if (ret < 0) return; payload.ip = ip; payload.parent_ip = parent_ip; - lib_ring_buffer_align_ctx(&ctx, ltt_alignof(payload)); + lib_ring_buffer_align_ctx(&ctx, lttng_alignof(payload)); chan->ops->event_write(&ctx, &payload, sizeof(payload)); chan->ops->event_commit(&ctx); return; @@ -46,7 +62,7 @@ void lttng_ftrace_handler(unsigned long ip, unsigned long parent_ip, void **data * Create event description */ static -int lttng_create_ftrace_event(const char *name, struct ltt_event *event) +int lttng_create_ftrace_event(const char *name, struct lttng_event *event) { struct lttng_event_field *fields; struct lttng_event_desc *desc; @@ -63,28 +79,35 @@ int lttng_create_ftrace_event(const char *name, struct ltt_event *event) desc->nr_fields = 2; desc->fields = fields = kzalloc(2 * sizeof(struct lttng_event_field), GFP_KERNEL); + if (!desc->fields) { + ret = -ENOMEM; + goto error_fields; + } fields[0].name = "ip"; fields[0].type.atype = atype_integer; - fields[0].type.u.basic.integer.size = sizeof(unsigned long); - fields[0].type.u.basic.integer.alignment = ltt_alignof(unsigned long); - fields[0].type.u.basic.integer.signedness = 0; + fields[0].type.u.basic.integer.size = sizeof(unsigned long) * CHAR_BIT; + fields[0].type.u.basic.integer.alignment = lttng_alignof(unsigned long) * CHAR_BIT; + fields[0].type.u.basic.integer.signedness = is_signed_type(unsigned long); fields[0].type.u.basic.integer.reverse_byte_order = 0; fields[0].type.u.basic.integer.base = 16; fields[0].type.u.basic.integer.encoding = lttng_encode_none; fields[1].name = "parent_ip"; fields[1].type.atype = atype_integer; - fields[1].type.u.basic.integer.size = sizeof(unsigned long); - fields[1].type.u.basic.integer.alignment = ltt_alignof(unsigned long); - fields[1].type.u.basic.integer.signedness = 0; + fields[1].type.u.basic.integer.size = sizeof(unsigned long) * CHAR_BIT; + fields[1].type.u.basic.integer.alignment = lttng_alignof(unsigned long) * CHAR_BIT; + fields[1].type.u.basic.integer.signedness = is_signed_type(unsigned long); fields[1].type.u.basic.integer.reverse_byte_order = 0; fields[1].type.u.basic.integer.base = 16; fields[1].type.u.basic.integer.encoding = lttng_encode_none; + desc->owner = THIS_MODULE; event->desc = desc; return 0; +error_fields: + kfree(desc->name); error_str: kfree(desc); return ret; @@ -97,7 +120,7 @@ struct ftrace_probe_ops lttng_ftrace_ops = { int lttng_ftrace_register(const char *name, const char *symbol_name, - struct ltt_event *event) + struct lttng_event *event) { int ret; @@ -105,13 +128,16 @@ int lttng_ftrace_register(const char *name, if (ret) goto error; - event->u.ftrace.symbol_name = kstrdup(name, GFP_KERNEL); + event->u.ftrace.symbol_name = kstrdup(symbol_name, GFP_KERNEL); if (!event->u.ftrace.symbol_name) goto name_error; + /* Ensure the memory we just allocated don't trigger page faults */ + wrapper_vmalloc_sync_all(); + ret = wrapper_register_ftrace_function_probe(event->u.ftrace.symbol_name, <tng_ftrace_ops, event); - if (ret) + if (ret < 0) goto register_error; return 0; @@ -125,15 +151,37 @@ error: } EXPORT_SYMBOL_GPL(lttng_ftrace_register); -void lttng_ftrace_unregister(struct ltt_event *event) +void lttng_ftrace_unregister(struct lttng_event *event) { wrapper_unregister_ftrace_function_probe(event->u.ftrace.symbol_name, <tng_ftrace_ops, event); +} +EXPORT_SYMBOL_GPL(lttng_ftrace_unregister); + +void lttng_ftrace_destroy_private(struct lttng_event *event) +{ kfree(event->u.ftrace.symbol_name); + kfree(event->desc->fields); kfree(event->desc->name); kfree(event->desc); } -EXPORT_SYMBOL_GPL(lttng_ftrace_unregister); +EXPORT_SYMBOL_GPL(lttng_ftrace_destroy_private); + +int lttng_ftrace_init(void) +{ + wrapper_vmalloc_sync_all(); + return 0; +} +module_init(lttng_ftrace_init) + +/* + * Ftrace takes care of waiting for a grace period (RCU sched) at probe + * unregistration, and disables preemption around probe call. + */ +void lttng_ftrace_exit(void) +{ +} +module_exit(lttng_ftrace_exit) MODULE_LICENSE("GPL and additional rights"); MODULE_AUTHOR("Mathieu Desnoyers");