X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=ltt-events.c;h=20db4c55bdc75703a8fad2b7016a38887ae768c1;hb=833ad6a0c344849269df6875f40c3d7cb21529d3;hp=b0191596d4519529be5a15fcfd3744aaf16ce7cf;hpb=f40270adf3e31289ac13a482e830b4a19d8df3bf;p=lttng-modules.git diff --git a/ltt-events.c b/ltt-events.c index b0191596..20db4c55 100644 --- a/ltt-events.c +++ b/ltt-events.c @@ -12,6 +12,7 @@ #include #include #include +#include #include "wrapper/vmalloc.h" /* for wrapper_vmalloc_sync_all() */ #include "ltt-events.h" #include "ltt-tracer.h" @@ -21,6 +22,8 @@ static LIST_HEAD(ltt_transport_list); static DEFINE_MUTEX(sessions_mutex); static struct kmem_cache *event_cache; +static void _ltt_event_destroy(struct ltt_event *event); +static int _ltt_event_unregister(struct ltt_event *event); static int _ltt_event_metadata_statedump(struct ltt_session *session, struct ltt_channel *chan, @@ -48,6 +51,7 @@ struct ltt_session *ltt_session_create(void) return NULL; INIT_LIST_HEAD(&session->chan); INIT_LIST_HEAD(&session->events); + uuid_le_gen(&session->uuid); list_add(&session->list, &sessions); mutex_unlock(&sessions_mutex); return session; @@ -164,7 +168,7 @@ struct ltt_channel *ltt_channel_create(struct ltt_session *session, goto nomem; chan->session = session; init_waitqueue_head(&chan->notify_wait); - chan->chan = transport->ops.channel_create("[lttng]", session, buf_addr, + chan->chan = transport->ops.channel_create("[lttng]", chan, buf_addr, subbuf_size, num_subbuf, switch_timer_interval, read_timer_interval); if (!chan->chan) @@ -198,8 +202,7 @@ void _ltt_channel_destroy(struct ltt_channel *chan) * Supports event creation while tracing session is active. */ struct ltt_event *ltt_event_create(struct ltt_channel *chan, char *name, - enum instrum_type itype, - const struct lttng_event_desc *event_desc, + struct lttng_kernel_event *event_param, void *filter) { struct ltt_event *event; @@ -219,16 +222,35 @@ struct ltt_event *ltt_event_create(struct ltt_channel *chan, char *name, if (!event) goto cache_error; event->chan = chan; - event->desc = event_desc; event->filter = filter; event->id = chan->free_event_id++; - event->itype = itype; + event->instrumentation = event_param->instrumentation; /* Populate ltt_event structure before tracepoint registration. */ smp_wmb(); - switch (itype) { - case INSTRUM_TRACEPOINTS: - ret = tracepoint_probe_register(name, event_desc->probe_callback, - event); + switch (event_param->instrumentation) { + case LTTNG_KERNEL_TRACEPOINTS: + event->desc = ltt_event_get(name); + if (!event->desc) + goto register_error; + ret = tracepoint_probe_register(name, + event->desc->probe_callback, + event); + if (ret) + goto register_error; + break; + case LTTNG_KERNEL_KPROBES: + ret = lttng_kprobes_register(name, + event_param->u.kprobe.symbol_name, + event_param->u.kprobe.offset, + event_param->u.kprobe.addr, + event); + if (ret) + goto register_error; + break; + case LTTNG_KERNEL_FUNCTION_TRACER: + ret = lttng_ftrace_register(name, + event_param->u.ftrace.symbol_name, + event); if (ret) goto register_error; break; @@ -243,8 +265,10 @@ struct ltt_event *ltt_event_create(struct ltt_channel *chan, char *name, return event; statedump_error: - WARN_ON_ONCE(tracepoint_probe_unregister(name, event_desc->probe_callback, - event)); + WARN_ON_ONCE(tracepoint_probe_unregister(name, + event->desc->probe_callback, + event)); + ltt_event_put(event->desc); register_error: kmem_cache_free(event_cache, event); cache_error: @@ -261,13 +285,22 @@ int _ltt_event_unregister(struct ltt_event *event) { int ret = -EINVAL; - switch (event->itype) { - case INSTRUM_TRACEPOINTS: + switch (event->instrumentation) { + case LTTNG_KERNEL_TRACEPOINTS: ret = tracepoint_probe_unregister(event->desc->name, event->desc->probe_callback, event); if (ret) return ret; + ltt_event_put(event->desc); + break; + case LTTNG_KERNEL_KPROBES: + lttng_kprobes_unregister(event); + ret = 0; + break; + case LTTNG_KERNEL_FUNCTION_TRACER: + lttng_ftrace_unregister(event); + ret = 0; break; default: WARN_ON_ONCE(1); @@ -275,9 +308,23 @@ int _ltt_event_unregister(struct ltt_event *event) return ret; } +/* + * Used when an event FD is released. + */ +int ltt_event_unregister(struct ltt_event *event) +{ + int ret; + + mutex_lock(&sessions_mutex); + ret = ltt_event_unregister(event); + mutex_unlock(&sessions_mutex); + return ret; +} + /* * Only used internally at session destruction. */ +static void _ltt_event_destroy(struct ltt_event *event) { ltt_event_put(event->desc); @@ -285,6 +332,12 @@ void _ltt_event_destroy(struct ltt_event *event) kmem_cache_free(event_cache, event); } +/* + * We have exclusive access to our metadata buffer (protected by the + * sessions_mutex), so we can do racy operations such as looking for + * remaining space left in packet and write, since mutual exclusion + * protects us from concurrent writes. + */ int lttng_metadata_printf(struct ltt_session *session, const char *fmt, ...) { @@ -292,7 +345,7 @@ int lttng_metadata_printf(struct ltt_session *session, struct ltt_channel *chan = session->metadata; char *str; int ret = 0, waitret; - size_t len; + size_t len, reserve_len, pos; va_list ap; WARN_ON_ONCE(!ACCESS_ONCE(session->active)); @@ -303,29 +356,38 @@ int lttng_metadata_printf(struct ltt_session *session, if (!str) return -ENOMEM; - len = strlen(str) + 1; - lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, len, sizeof(char), -1); - /* - * We don't care about metadata buffer's records lost count, because we - * always retry here. Report error if we need to bail out after timeout - * or being interrupted. - */ - waitret = wait_event_interruptible_timeout(*chan->ops->get_reader_wait_queue(chan), - ({ - ret = chan->ops->event_reserve(&ctx); - ret != -ENOBUFS || !ret; - }), - msecs_to_jiffies(LTTNG_METADATA_TIMEOUT_MSEC)); - if (waitret || ret) { - printk(KERN_WARNING "LTTng: Failure to write metadata to buffers (%s)\n", - waitret == -ERESTARTSYS ? "interrupted" : - (ret == -ENOBUFS ? "timeout" : "I/O error")); - if (waitret == -ERESTARTSYS) - ret = waitret; - goto end; + len = strlen(str); + pos = 0; + + for (pos = 0; pos < len; pos += reserve_len) { + reserve_len = min_t(size_t, + chan->ops->packet_avail_size(chan->chan), + len - pos); + lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len, + sizeof(char), -1); + /* + * We don't care about metadata buffer's records lost + * count, because we always retry here. Report error if + * we need to bail out after timeout or being + * interrupted. + */ + waitret = wait_event_interruptible_timeout(*chan->ops->get_reader_wait_queue(chan), + ({ + ret = chan->ops->event_reserve(&ctx); + ret != -ENOBUFS || !ret; + }), + msecs_to_jiffies(LTTNG_METADATA_TIMEOUT_MSEC)); + if (!waitret || waitret == -ERESTARTSYS || ret) { + printk(KERN_WARNING "LTTng: Failure to write metadata to buffers (%s)\n", + waitret == -ERESTARTSYS ? "interrupted" : + (ret == -ENOBUFS ? "timeout" : "I/O error")); + if (waitret == -ERESTARTSYS) + ret = waitret; + goto end; + } + chan->ops->event_write(&ctx, &str[pos], len); + chan->ops->event_commit(&ctx); } - chan->ops->event_write(&ctx, str, len); - chan->ops->event_commit(&ctx); end: kfree(str); return ret; @@ -345,10 +407,16 @@ int _ltt_fields_metadata_statedump(struct ltt_session *session, switch (field->type.atype) { case atype_integer: ret = lttng_metadata_printf(session, - " integer { size = %u; align = %u; signed = %u;%s } %s;\n", + " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } %s;\n", field->type.u.basic.integer.size, field->type.u.basic.integer.alignment, field->type.u.basic.integer.signedness, + (field->type.u.basic.integer.encoding == lttng_encode_none) + ? "none" + : (field->type.u.basic.integer.encoding == lttng_encode_UTF8) + ? "UTF8" + : "ASCII", + field->type.u.basic.integer.base, #ifdef __BIG_ENDIAN field->type.u.basic.integer.reverse_byte_order ? " byte_order = le;" : "", #else @@ -368,10 +436,16 @@ int _ltt_fields_metadata_statedump(struct ltt_session *session, elem_type = &field->type.u.array.elem_type; ret = lttng_metadata_printf(session, - " integer { size = %u; align = %u; signed = %u;%s } %s[%u];\n", + " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } %s[%u];\n", elem_type->u.basic.integer.size, elem_type->u.basic.integer.alignment, elem_type->u.basic.integer.signedness, + (elem_type->u.basic.integer.encoding == lttng_encode_none) + ? "none" + : (elem_type->u.basic.integer.encoding == lttng_encode_UTF8) + ? "UTF8" + : "ASCII", + elem_type->u.basic.integer.base, #ifdef __BIG_ENDIAN elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "", #else @@ -388,29 +462,46 @@ int _ltt_fields_metadata_statedump(struct ltt_session *session, elem_type = &field->type.u.sequence.elem_type; length_type = &field->type.u.sequence.length_type; ret = lttng_metadata_printf(session, - " integer { size = %u; align = %u; signed = %u;%s } %s[ integer { size = %u; align = %u; signed = %u;%s } ];\n", + " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } __%s_length;\n", + " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } %s[ __%s_length ];\n", + length_type->u.basic.integer.size, + length_type->u.basic.integer.alignment, + length_type->u.basic.integer.signedness, + (length_type->u.basic.integer.encoding == lttng_encode_none) + ? "none" + : (length_type->u.basic.integer.encoding == lttng_encode_UTF8) + ? "UTF8" + : "ASCII", + length_type->u.basic.integer.base, +#ifdef __BIG_ENDIAN + length_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "", +#else + length_type->u.basic.integer.reverse_byte_order +? " byte_order = be;" : "", +#endif + field->name, elem_type->u.basic.integer.size, elem_type->u.basic.integer.alignment, elem_type->u.basic.integer.signedness, + (elem_type->u.basic.integer.encoding == lttng_encode_none) + ? "none" + : (elem_type->u.basic.integer.encoding == lttng_encode_UTF8) + ? "UTF8" + : "ASCII", + elem_type->u.basic.integer.base, #ifdef __BIG_ENDIAN elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "", #else elem_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "", #endif field->name, - length_type->u.basic.integer.size, - length_type->u.basic.integer.alignment, - length_type->u.basic.integer.signedness, -#ifdef __BIG_ENDIAN - length_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "", -#else - length_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "" -#endif + field->name ); break; } case atype_string: + /* Default encoding is UTF8 */ ret = lttng_metadata_printf(session, " string%s %s;\n", field->type.u.basic.string.encoding == lttng_encode_ASCII ? @@ -458,8 +549,8 @@ int _ltt_event_metadata_statedump(struct ltt_session *session, * byte size. */ ret = lttng_metadata_printf(session, - " } aligned(%u);\n" - "};\n", ltt_get_header_alignment()); + " };\n" + "};\n\n"); if (ret) goto end; @@ -487,8 +578,9 @@ int _ltt_channel_metadata_statedump(struct ltt_session *session, ret = lttng_metadata_printf(session, "stream {\n" " id = %u;\n" - " event.header := %s;\n", - "};\n", + " event.header := %s;\n" + " packet.context := struct packet_context;\n" + "};\n\n", chan->id, chan->header_type == 1 ? "struct event_header_compact" : "struct event_header_large"); @@ -500,12 +592,71 @@ end: return ret; } +static +int _ltt_stream_packet_context_declare(struct ltt_session *session) +{ + return lttng_metadata_printf(session, + "struct packet_context {\n" + " uint64_t timestamp_begin;\n" + " uint64_t timestamp_end;\n" + " uint32_t events_discarded;\n" + " uint32_t content_size;\n" + " uint32_t packet_size;\n" + " uint32_t cpu_id;\n" + "};\n" + ); +} + +/* + * Compact header: + * id: range: 0 - 30. + * id 31 is reserved to indicate an extended header. + * + * Large header: + * id: range: 0 - 65534. + * id 65535 is reserved to indicate an extended header. + */ +static +int _ltt_event_header_declare(struct ltt_session *session) +{ + return lttng_metadata_printf(session, + "struct event_header_compact {\n" + " enum : uint5_t { compact = 0 ... 30, extended = 31 } id;\n" + " variant {\n" + " struct {\n" + " uint27_t timestamp;\n" + " } compact;\n" + " struct {\n" + " uint32_t id;\n" + " uint64_t timestamp;\n" + " } extended;\n" + " } v;\n" + "} align(%u);\n" + "\n" + "struct event_header_large {\n" + " enum : uint16_t { compact = 0 ... 65534, extended = 65535 } id;\n" + " variant {\n" + " struct {\n" + " uint32_t timestamp;\n" + " } compact;\n" + " struct {\n" + " uint32_t id;\n" + " uint64_t timestamp;\n" + " } extended;\n" + " } v;\n" + "} align(%u);\n\n", + ltt_alignof(uint32_t) * CHAR_BIT, + ltt_alignof(uint16_t) * CHAR_BIT + ); +} + /* * Output metadata into this session's metadata buffers. */ static int _ltt_session_metadata_statedump(struct ltt_session *session) { + char uuid_s[37]; struct ltt_channel *chan; struct ltt_event *event; int ret = 0; @@ -515,10 +666,59 @@ int _ltt_session_metadata_statedump(struct ltt_session *session) if (session->metadata_dumped) goto skip_session; if (!session->metadata) { - printk(KERN_WARNING "LTTng: tracing is starting, but metadata channel is not found\n"); + printk(KERN_WARNING "LTTng: attempt to start tracing, but metadata channel is not found. Operation abort.\n"); return -EPERM; } + snprintf(uuid_s, sizeof(uuid_s), + "%x%x%x%x-%x%x-%x%x-%x%x-%x%x%x%x%x%x", + uuid_s[0], uuid_s[1], uuid_s[2], uuid_s[3], + uuid_s[4], uuid_s[5], uuid_s[6], uuid_s[7], + uuid_s[8], uuid_s[9], uuid_s[10], uuid_s[11], + uuid_s[12], uuid_s[13], uuid_s[14], uuid_s[15]); + + ret = lttng_metadata_printf(session, + "typealias integer { size = 8; align = %u; signed = false; } := uint8_t;\n" + "typealias integer { size = 16; align = %u; signed = false; } := uint16_t;\n" + "typealias integer { size = 32; align = %u; signed = false; } := uint32_t;\n" + "typealias integer { size = 64; align = %u; signed = false; } := uint64_t;\n" + "typealias integer { size = 5; align = 1; signed = false; } := uint5_t;\n" + "typealias integer { size = 27; align = 1; signed = false; } := uint27_t;\n" + "\n" + "trace {\n" + " major = %u;\n" + " minor = %u;\n" + " uuid = %s;\n" + " byte_order = %s;\n" + " packet.header := struct {\n" + " uint32_t magic;\n" + " uint8_t uuid[16];\n" + " uint32_t stream_id;\n" + " };\n", + "};\n\n", + ltt_alignof(uint8_t) * CHAR_BIT, + ltt_alignof(uint32_t) * CHAR_BIT, + ltt_alignof(uint64_t) * CHAR_BIT, + CTF_VERSION_MAJOR, + CTF_VERSION_MINOR, + uuid_s, +#ifdef __BIG_ENDIAN + "be" +#else + "le" +#endif + ); + if (ret) + goto end; + + ret = _ltt_stream_packet_context_declare(session); + if (ret) + goto end; + + ret = _ltt_event_header_declare(session); + if (ret) + goto end; + skip_session: list_for_each_entry(chan, &session->chan, list) { ret = _ltt_channel_metadata_statedump(session, chan);