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,
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)
* Supports event creation while tracing session is active.
*/
struct ltt_event *ltt_event_create(struct ltt_channel *chan, char *name,
- enum instrum_type itype,
+ struct lttng_kernel_event *event_param,
const struct lttng_event_desc *event_desc,
void *filter)
{
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:
+ switch (event_param->instrumentation) {
+ case LTTNG_KERNEL_TRACEPOINTS:
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;
default:
WARN_ON_ONCE(1);
}
{
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;
break;
+ case LTTNG_KERNEL_KPROBES:
+ lttng_kprobes_unregister(event);
+ ret = 0;
+ break;
default:
WARN_ON_ONCE(1);
}
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);
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, ...)
{
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));
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 || waitret == -ERESTARTSYS || ret) {
- printk(KERN_WARNING "LTTng: Failure to write metadata to buffers (%s)\n",
- waitret == -ERESTARTSYS ? "interrupted" :
- (ret == -ENOBUFS ? "timeout" : "I/O error"));
- printk("waitret %d retval %d\n", waitret, ret);
- 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;
* byte size.
*/
ret = lttng_metadata_printf(session,
- " } aligned(%u);\n"
- "};\n\n", ltt_get_header_alignment());
+ " };\n"
+ "};\n\n");
if (ret)
goto end;
ret = lttng_metadata_printf(session,
"stream {\n"
" id = %u;\n"
- " event.header := %s;\n",
+ " event.header := %s;\n"
+ " packet.context := struct packet_context;\n"
"};\n\n",
chan->id,
chan->header_type == 1 ? "struct event_header_compact" :
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 <id> {\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 <id> {\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.
*/
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 = 32; align = %u; signed = false; } := uint32_t;\n"
- "typealias integer {size = 64; align = %u; signed = false; } := uint64_t;\n"
+ "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"
" byte_order = %s;\n"
" packet.header := struct {\n"
" uint32_t magic;\n"
- " uint8_t trace_uuid[16];\n"
+ " uint8_t uuid[16];\n"
" uint32_t stream_id;\n"
- " uint64_t timestamp_begin;\n"
- " uint64_t timestamp_end;\n"
- " uint32_t content_size;\n"
- " uint32_t packet_size;\n"
- " uint32_t events_lost;\n"
" };\n",
"};\n\n",
ltt_alignof(uint8_t) * CHAR_BIT,
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);
projects / lttng-modules.git / blobdiff