static struct kmem_cache *event_cache;
static void _ltt_event_destroy(struct ltt_event *event);
+static void _ltt_channel_destroy(struct ltt_channel *chan);
static int _ltt_event_unregister(struct ltt_event *event);
static
int _ltt_event_metadata_statedump(struct ltt_session *session,
goto nomem;
chan->session = session;
init_waitqueue_head(&chan->notify_wait);
+ chan->id = session->free_chan_id++;
+ /*
+ * Note: the channel creation op already writes into the packet
+ * headers. Therefore the "chan" information used as input
+ * should be already accessible.
+ */
chan->chan = transport->ops.channel_create("[lttng]", chan, buf_addr,
subbuf_size, num_subbuf, switch_timer_interval,
read_timer_interval);
if (!chan->chan)
goto create_error;
- chan->id = session->free_chan_id++;
chan->ops = &transport->ops;
list_add(&chan->list, &session->chan);
mutex_unlock(&sessions_mutex);
/*
* Only used internally at session destruction.
*/
+static
void _ltt_channel_destroy(struct ltt_channel *chan)
{
chan->ops->channel_destroy(chan->chan);
/*
* Supports event creation while tracing session is active.
*/
-struct ltt_event *ltt_event_create(struct ltt_channel *chan, char *name,
+struct ltt_event *ltt_event_create(struct ltt_channel *chan,
struct lttng_kernel_event *event_param,
void *filter)
{
* creation). Might require a hash if we have lots of events.
*/
list_for_each_entry(event, &chan->session->events, list)
- if (!strcmp(event->desc->name, name))
+ if (!strcmp(event->desc->name, event_param->name))
goto exist;
event = kmem_cache_zalloc(event_cache, GFP_KERNEL);
if (!event)
/* Populate ltt_event structure before tracepoint registration. */
smp_wmb();
switch (event_param->instrumentation) {
- case LTTNG_KERNEL_TRACEPOINTS:
- event->desc = ltt_event_get(name);
+ case LTTNG_KERNEL_TRACEPOINT:
+ event->desc = ltt_event_get(event_param->name);
if (!event->desc)
goto register_error;
- ret = tracepoint_probe_register(name,
+ ret = tracepoint_probe_register(event_param->name,
event->desc->probe_callback,
event);
if (ret)
goto register_error;
break;
- case LTTNG_KERNEL_KPROBES:
- ret = lttng_kprobes_register(name,
+ case LTTNG_KERNEL_KPROBE:
+ ret = lttng_kprobes_register(event_param->name,
event_param->u.kprobe.symbol_name,
event_param->u.kprobe.offset,
event_param->u.kprobe.addr,
if (ret)
goto register_error;
break;
- case LTTNG_KERNEL_FUNCTION_TRACER:
- ret = lttng_ftrace_register(name,
+ case LTTNG_KERNEL_FUNCTION:
+ ret = lttng_ftrace_register(event_param->name,
event_param->u.ftrace.symbol_name,
event);
if (ret)
return event;
statedump_error:
- WARN_ON_ONCE(tracepoint_probe_unregister(name,
+ WARN_ON_ONCE(tracepoint_probe_unregister(event_param->name,
event->desc->probe_callback,
event));
ltt_event_put(event->desc);
int ret = -EINVAL;
switch (event->instrumentation) {
- case LTTNG_KERNEL_TRACEPOINTS:
+ case LTTNG_KERNEL_TRACEPOINT:
ret = tracepoint_probe_unregister(event->desc->name,
event->desc->probe_callback,
event);
return ret;
ltt_event_put(event->desc);
break;
- case LTTNG_KERNEL_KPROBES:
+ case LTTNG_KERNEL_KPROBE:
lttng_kprobes_unregister(event);
ret = 0;
break;
- case LTTNG_KERNEL_FUNCTION_TRACER:
+ case LTTNG_KERNEL_FUNCTION:
lttng_ftrace_unregister(event);
ret = 0;
break;
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.
*/
*/
waitret = wait_event_interruptible_timeout(*chan->ops->get_reader_wait_queue(chan),
({
- ret = chan->ops->event_reserve(&ctx);
+ ret = chan->ops->event_reserve(&ctx, 0);
ret != -ENOBUFS || !ret;
}),
msecs_to_jiffies(LTTNG_METADATA_TIMEOUT_MSEC));
" name = %s;\n"
" id = %u;\n"
" stream_id = %u;\n"
- " event.fields := struct {\n",
+ " fields := struct {\n",
event->desc->name,
event->id,
event->chan->id);
" uint32_t content_size;\n"
" uint32_t packet_size;\n"
" uint32_t cpu_id;\n"
- "};\n"
+ "};\n\n"
);
}
static
int _ltt_session_metadata_statedump(struct ltt_session *session)
{
- char uuid_s[37];
+ unsigned char *uuid_c = session->uuid.b;
+ unsigned char uuid_s[37];
struct ltt_channel *chan;
struct ltt_event *event;
int ret = 0;
}
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]);
+ "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+ uuid_c[0], uuid_c[1], uuid_c[2], uuid_c[3],
+ uuid_c[4], uuid_c[5], uuid_c[6], uuid_c[7],
+ uuid_c[8], uuid_c[9], uuid_c[10], uuid_c[11],
+ uuid_c[12], uuid_c[13], uuid_c[14], uuid_c[15]);
ret = lttng_metadata_printf(session,
"typealias integer { size = 8; align = %u; signed = false; } := uint8_t;\n"
"trace {\n"
" major = %u;\n"
" minor = %u;\n"
- " uuid = %s;\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\n",
ltt_alignof(uint8_t) * CHAR_BIT,
+ ltt_alignof(uint16_t) * CHAR_BIT,
ltt_alignof(uint32_t) * CHAR_BIT,
ltt_alignof(uint64_t) * CHAR_BIT,
CTF_VERSION_MAJOR,
}
list_for_each_entry(event, &session->events, list) {
- ret = _ltt_event_metadata_statedump(session, chan, event);
+ ret = _ltt_event_metadata_statedump(session, event->chan, event);
if (ret)
goto end;
}