X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=libust%2Fltt-events.c;h=68531bcd628e435e62805d52b5f593054ec5089b;hb=4318ae1be57eb7983ab4857a7a8eeb4a030a8216;hp=e4ffc69a32474b9fdd45331e893770ee399ba5b7;hpb=8d8a24c8565ce6dce7e7bd1045a95d1d2af5e536;p=lttng-ust.git

diff --git a/libust/ltt-events.c b/libust/ltt-events.c
index e4ffc69a..68531bcd 100644
--- a/libust/ltt-events.c
+++ b/libust/ltt-events.c
@@ -10,26 +10,63 @@
 
 #define _GNU_SOURCE
 #include <stdio.h>
+#include <endian.h>
 #include <urcu/list.h>
+#include <urcu/hlist.h>
 #include <pthread.h>
 #include <urcu-bp.h>
 #include <urcu/compiler.h>
 #include <urcu/uatomic.h>
 #include <uuid/uuid.h>
-#include <ust/tracepoint.h>
+#include <lttng/tracepoint.h>
 #include <errno.h>
 #include <sys/shm.h>
 #include <sys/ipc.h>
-#include <ust/lttng-events.h>
-#include "usterr_signal_safe.h"
-#include "ust/core.h"
+#include <lttng/ust-events.h>
+#include <lttng/usterr-signal-safe.h>
+#include "lttng/core.h"
 #include "ltt-tracer.h"
-#include "ust/wait.h"
+#include "ltt-tracer-core.h"
+#include "lttng/wait.h"
 #include "../libringbuffer/shm.h"
 
+typedef u32 uint32_t;
+#include <lttng/kcompat/jhash.h>
+
+/*
+ * The sessions mutex is the centralized mutex across UST tracing
+ * control and probe registration. All operations within this file are
+ * called by the communication thread, under ust_lock protection.
+ */
+static DEFINE_MUTEX(sessions_mutex);
+
+void ust_lock(void)
+{
+	pthread_mutex_lock(&sessions_mutex);
+}
+
+void ust_unlock(void)
+{
+	pthread_mutex_unlock(&sessions_mutex);
+}
+
 static CDS_LIST_HEAD(sessions);
 static CDS_LIST_HEAD(ltt_transport_list);
-static DEFINE_MUTEX(sessions_mutex);
+
+/*
+ * Pending probes hash table, containing the registered ltt events for
+ * which tracepoint probes are still missing. Protected by the sessions
+ * mutex.
+ */
+#define PENDING_PROBE_HASH_BITS		6
+#define PENDING_PROBE_HASH_SIZE		(1 << PENDING_PROBE_HASH_BITS)
+static struct cds_hlist_head pending_probe_table[PENDING_PROBE_HASH_SIZE];
+
+struct ust_pending_probe {
+	struct ltt_event *event;
+	struct cds_hlist_node node;
+	char name[];
+};
 
 static void _ltt_event_destroy(struct ltt_event *event);
 static void _ltt_channel_destroy(struct ltt_channel *chan);
@@ -41,6 +78,83 @@ int _ltt_event_metadata_statedump(struct ltt_session *session,
 static
 int _ltt_session_metadata_statedump(struct ltt_session *session);
 
+/*
+ * called at event creation if probe is missing.
+ * called with session mutex held.
+ */
+static
+int add_pending_probe(struct ltt_event *event, const char *name)
+{
+	struct cds_hlist_head *head;
+	struct ust_pending_probe *e;
+	size_t name_len = strlen(name) + 1;
+	u32 hash = jhash(name, name_len - 1, 0);
+
+	head = &pending_probe_table[hash & (PENDING_PROBE_HASH_SIZE - 1)];
+	e = zmalloc(sizeof(struct ust_pending_probe) + name_len);
+	if (!e)
+		return -ENOMEM;
+	memcpy(&e->name[0], name, name_len);
+	cds_hlist_add_head(&e->node, head);
+	e->event = event;
+	event->pending_probe = e;
+	return 0;
+}
+
+/*
+ * remove a pending probe. called when at event teardown and when an
+ * event is fixed (probe is loaded).
+ * called with session mutex held.
+ */
+static
+void remove_pending_probe(struct ust_pending_probe *e)
+{
+	if (!e)
+		return;
+	cds_hlist_del(&e->node);
+	free(e);
+}
+
+/*
+ * Called at library load: connect the probe on the events pending on
+ * probe load.
+ * called with session mutex held.
+ */
+int pending_probe_fix_events(const struct lttng_event_desc *desc)
+{
+	struct cds_hlist_head *head;
+	struct cds_hlist_node *node, *p;
+	struct ust_pending_probe *e;
+	const char *name = desc->name;
+	size_t name_len = strlen(name) + 1;
+	u32 hash = jhash(name, name_len - 1, 0);
+	int ret = 0;
+
+	head = &pending_probe_table[hash & (PENDING_PROBE_HASH_SIZE - 1)];
+	cds_hlist_for_each_entry_safe(e, node, p, head, node) {
+		struct ltt_event *event;
+		struct ltt_channel *chan;
+
+		if (strcmp(name, e->name))
+			continue;
+		event = e->event;
+		chan = event->chan;
+		assert(!event->desc);
+		event->desc = desc;
+		event->pending_probe = NULL;
+		remove_pending_probe(e);
+		ret |= __tracepoint_probe_register(name,
+				event->desc->probe_callback,
+				event);
+		if (ret)
+			continue;
+		event->id = chan->free_event_id++;
+		ret |= _ltt_event_metadata_statedump(chan->session, chan,
+				event);
+	}
+	return ret;
+}
+
 void synchronize_trace(void)
 {
 	synchronize_rcu();
@@ -50,7 +164,6 @@ struct ltt_session *ltt_session_create(void)
 {
 	struct ltt_session *session;
 
-	pthread_mutex_lock(&sessions_mutex);
 	session = zmalloc(sizeof(struct ltt_session));
 	if (!session)
 		return NULL;
@@ -58,7 +171,6 @@ struct ltt_session *ltt_session_create(void)
 	CDS_INIT_LIST_HEAD(&session->events);
 	uuid_generate(session->uuid);
 	cds_list_add(&session->list, &sessions);
-	pthread_mutex_unlock(&sessions_mutex);
 	return session;
 }
 
@@ -68,7 +180,6 @@ void ltt_session_destroy(struct ltt_session *session)
 	struct ltt_event *event, *tmpevent;
 	int ret;
 
-	pthread_mutex_lock(&sessions_mutex);
 	CMM_ACCESS_ONCE(session->active) = 0;
 	cds_list_for_each_entry(event, &session->events, list) {
 		ret = _ltt_event_unregister(event);
@@ -80,7 +191,6 @@ void ltt_session_destroy(struct ltt_session *session)
 	cds_list_for_each_entry_safe(chan, tmpchan, &session->chan, list)
 		_ltt_channel_destroy(chan);
 	cds_list_del(&session->list);
-	pthread_mutex_unlock(&sessions_mutex);
 	free(session);
 }
 
@@ -89,7 +199,6 @@ int ltt_session_enable(struct ltt_session *session)
 	int ret = 0;
 	struct ltt_channel *chan;
 
-	pthread_mutex_lock(&sessions_mutex);
 	if (session->active) {
 		ret = -EBUSY;
 		goto end;
@@ -114,7 +223,6 @@ int ltt_session_enable(struct ltt_session *session)
 	if (ret)
 		CMM_ACCESS_ONCE(session->active) = 0;
 end:
-	pthread_mutex_unlock(&sessions_mutex);
 	return ret;
 }
 
@@ -122,14 +230,12 @@ int ltt_session_disable(struct ltt_session *session)
 {
 	int ret = 0;
 
-	pthread_mutex_lock(&sessions_mutex);
 	if (!session->active) {
 		ret = -EBUSY;
 		goto end;
 	}
 	CMM_ACCESS_ONCE(session->active) = 0;
 end:
-	pthread_mutex_unlock(&sessions_mutex);
 	return ret;
 }
 
@@ -197,12 +303,13 @@ struct ltt_channel *ltt_channel_create(struct ltt_session *session,
 				       void *buf_addr,
 				       size_t subbuf_size, size_t num_subbuf,
 				       unsigned int switch_timer_interval,
-				       unsigned int read_timer_interval)
+				       unsigned int read_timer_interval,
+				       int *shm_fd, int *wait_fd,
+				       uint64_t *memory_map_size)
 {
 	struct ltt_channel *chan;
 	struct ltt_transport *transport;
 
-	pthread_mutex_lock(&sessions_mutex);
 	if (session->been_active)
 		goto active;	/* Refuse to add channel to active session */
 	transport = ltt_transport_find(transport_name);
@@ -221,16 +328,15 @@ struct ltt_channel *ltt_channel_create(struct ltt_session *session,
 	 * headers. Therefore the "chan" information used as input
 	 * should be already accessible.
 	 */
-	chan->handle = transport->ops.channel_create("[lttng]", chan, buf_addr,
+	transport->ops.channel_create("[lttng]", chan, buf_addr,
 			subbuf_size, num_subbuf, switch_timer_interval,
-			read_timer_interval);
-	chan->chan = shmp(chan->handle->header->chan);
+			read_timer_interval, shm_fd, wait_fd,
+			memory_map_size);
 	if (!chan->chan)
 		goto create_error;
 	chan->enabled = 1;
 	chan->ops = &transport->ops;
 	cds_list_add(&chan->list, &session->chan);
-	pthread_mutex_unlock(&sessions_mutex);
 	return chan;
 
 create_error:
@@ -238,7 +344,6 @@ create_error:
 nomem:
 notransport:
 active:
-	pthread_mutex_unlock(&sessions_mutex);
 	return NULL;
 }
 
@@ -248,7 +353,7 @@ active:
 static
 void _ltt_channel_destroy(struct ltt_channel *chan)
 {
-	chan->ops->channel_destroy(chan->handle);
+	chan->ops->channel_destroy(chan);
 	cds_list_del(&chan->list);
 	lttng_destroy_context(chan->ctx);
 	free(chan);
@@ -264,22 +369,25 @@ struct ltt_event *ltt_event_create(struct ltt_channel *chan,
 	struct ltt_event *event;
 	int ret;
 
-	pthread_mutex_lock(&sessions_mutex);
-	if (chan->free_event_id == -1UL)
+	if (chan->used_event_id == -1UL)
 		goto full;
 	/*
 	 * This is O(n^2) (for each event, the loop is called at event
 	 * creation). Might require a hash if we have lots of events.
 	 */
 	cds_list_for_each_entry(event, &chan->session->events, list)
-		if (!strcmp(event->desc->name, event_param->name))
+		if (event->desc && !strcmp(event->desc->name, event_param->name))
 			goto exist;
 	event = zmalloc(sizeof(struct ltt_event));
 	if (!event)
 		goto cache_error;
 	event->chan = chan;
 	event->filter = filter;
-	event->id = chan->free_event_id++;
+	/*
+	 * used_event_id counts the maximum number of event IDs that can
+	 * register if all probes register.
+	 */
+	chan->used_event_id++;
 	event->enabled = 1;
 	event->instrumentation = event_param->instrumentation;
 	/* Populate ltt_event structure before tracepoint registration. */
@@ -287,35 +395,48 @@ struct ltt_event *ltt_event_create(struct ltt_channel *chan,
 	switch (event_param->instrumentation) {
 	case LTTNG_UST_TRACEPOINT:
 		event->desc = ltt_event_get(event_param->name);
-		if (!event->desc)
-			goto register_error;
-		ret = __tracepoint_probe_register(event_param->name,
-				event->desc->probe_callback,
-				event);
-		if (ret)
-			goto register_error;
+		if (event->desc) {
+			ret = __tracepoint_probe_register(event_param->name,
+					event->desc->probe_callback,
+					event);
+			if (ret)
+				goto register_error;
+			event->id = chan->free_event_id++;
+		} else {
+			/*
+			 * If the probe is not present, event->desc stays NULL,
+			 * waiting for the probe to register, and the event->id
+			 * stays unallocated.
+			 */
+			ret = add_pending_probe(event, event_param->name);
+			if (ret)
+				goto add_pending_error;
+		}
 		break;
 	default:
 		WARN_ON_ONCE(1);
 	}
-	ret = _ltt_event_metadata_statedump(chan->session, chan, event);
-	if (ret)
-		goto statedump_error;
+	if (event->desc) {
+		ret = _ltt_event_metadata_statedump(chan->session, chan, event);
+		if (ret)
+			goto statedump_error;
+	}
 	cds_list_add(&event->list, &chan->session->events);
-	pthread_mutex_unlock(&sessions_mutex);
 	return event;
 
 statedump_error:
-	WARN_ON_ONCE(__tracepoint_probe_unregister(event_param->name,
-				event->desc->probe_callback,
-				event));
-	ltt_event_put(event->desc);
+	if (event->desc) {
+		WARN_ON_ONCE(__tracepoint_probe_unregister(event_param->name,
+					event->desc->probe_callback,
+					event));
+		ltt_event_put(event->desc);
+	}
+add_pending_error:
 register_error:
 	free(event);
 cache_error:
 exist:
 full:
-	pthread_mutex_unlock(&sessions_mutex);
 	return NULL;
 }
 
@@ -328,11 +449,16 @@ int _ltt_event_unregister(struct ltt_event *event)
 
 	switch (event->instrumentation) {
 	case LTTNG_UST_TRACEPOINT:
-		ret = __tracepoint_probe_unregister(event->desc->name,
-						  event->desc->probe_callback,
-						  event);
-		if (ret)
-			return ret;
+		if (event->desc) {
+			ret = __tracepoint_probe_unregister(event->desc->name,
+							  event->desc->probe_callback,
+							  event);
+			if (ret)
+				return ret;
+		} else {
+			remove_pending_probe(event->pending_probe);
+			ret = 0;
+		}
 		break;
 	default:
 		WARN_ON_ONCE(1);
@@ -348,7 +474,9 @@ void _ltt_event_destroy(struct ltt_event *event)
 {
 	switch (event->instrumentation) {
 	case LTTNG_UST_TRACEPOINT:
-		ltt_event_put(event->desc);
+		if (event->desc) {
+			ltt_event_put(event->desc);
+		}
 		break;
 	default:
 		WARN_ON_ONCE(1);
@@ -360,14 +488,14 @@ void _ltt_event_destroy(struct ltt_event *event)
 
 /*
  * We have exclusive access to our metadata buffer (protected by the
- * sessions_mutex), so we can do racy operations such as looking for
+ * ust_lock), 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 lib_ring_buffer_ctx ctx;
+	struct lttng_ust_lib_ring_buffer_ctx ctx;
 	struct ltt_channel *chan = session->metadata;
 	char *str = NULL;
 	int ret = 0, waitret;
@@ -387,10 +515,10 @@ int lttng_metadata_printf(struct ltt_session *session,
 
 	for (pos = 0; pos < len; pos += reserve_len) {
 		reserve_len = min_t(size_t,
-				chan->ops->packet_avail_size(chan->chan),
+				chan->ops->packet_avail_size(chan->chan, chan->handle),
 				len - pos);
 		lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len,
-					 sizeof(char), -1);
+					 sizeof(char), -1, chan->handle);
 		/*
 		 * We don't care about metadata buffer's records lost
 		 * count, because we always retry here. Report error if
@@ -403,7 +531,7 @@ int lttng_metadata_printf(struct ltt_session *session,
 				ret != -ENOBUFS || !ret;
 			}),
 			LTTNG_METADATA_TIMEOUT_MSEC);
-		if (!waitret || waitret == -EINTR || ret) {
+		if (waitret == -ETIMEDOUT || waitret == -EINTR || ret) {
 			DBG("LTTng: Failure to write metadata to buffers (%s)\n",
 				waitret == -EINTR ? "interrupted" :
 					(ret == -ENOBUFS ? "timeout" : "I/O error"));
@@ -428,7 +556,7 @@ int _ltt_field_statedump(struct ltt_session *session,
 	switch (field->type.atype) {
 	case atype_integer:
 		ret = lttng_metadata_printf(session,
-			"		integer { size = %u; align = %u; signed = %u; encoding = %s; base = %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,
@@ -438,7 +566,7 @@ int _ltt_field_statedump(struct ltt_session *session,
 					? "UTF8"
 					: "ASCII",
 			field->type.u.basic.integer.base,
-#ifdef __BIG_ENDIAN
+#if (BYTE_ORDER == BIG_ENDIAN)
 			field->type.u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 #else
 			field->type.u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
@@ -447,11 +575,11 @@ int _ltt_field_statedump(struct ltt_session *session,
 		break;
 	case atype_float:
 		ret = lttng_metadata_printf(session,
-			"		floating_point { exp_dig = %u; mant_dig = %u; align = %u; } %s;\n",
+			"		floating_point { exp_dig = %u; mant_dig = %u; align = %u;%s } _%s;\n",
 			field->type.u.basic._float.exp_dig,
 			field->type.u.basic._float.mant_dig,
 			field->type.u.basic._float.alignment,
-#ifdef __BIG_ENDIAN
+#if (BYTE_ORDER == BIG_ENDIAN)
 			field->type.u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
 #else
 			field->type.u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
@@ -470,7 +598,7 @@ int _ltt_field_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; encoding = %s; base = %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,
@@ -480,7 +608,7 @@ int _ltt_field_statedump(struct ltt_session *session,
 					? "UTF8"
 					: "ASCII",
 			elem_type->u.basic.integer.base,
-#ifdef __BIG_ENDIAN
+#if (BYTE_ORDER == 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;" : "",
@@ -506,7 +634,7 @@ int _ltt_field_statedump(struct ltt_session *session,
 					? "UTF8"
 					: "ASCII"),
 			length_type->u.basic.integer.base,
-#ifdef __BIG_ENDIAN
+#if (BYTE_ORDER == 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;" : "",
@@ -516,7 +644,7 @@ int _ltt_field_statedump(struct ltt_session *session,
 			return ret;
 
 		ret = lttng_metadata_printf(session,
-			"		integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } %s[ __%s_length ];\n",
+			"		integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[ __%s_length ];\n",
 			elem_type->u.basic.integer.size,
 			(unsigned int) elem_type->u.basic.integer.alignment,
 			elem_type->u.basic.integer.signedness,
@@ -526,7 +654,7 @@ int _ltt_field_statedump(struct ltt_session *session,
 					? "UTF8"
 					: "ASCII"),
 			elem_type->u.basic.integer.base,
-#ifdef __BIG_ENDIAN
+#if (BYTE_ORDER == 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;" : "",
@@ -539,7 +667,7 @@ int _ltt_field_statedump(struct ltt_session *session,
 	case atype_string:
 		/* Default encoding is UTF8 */
 		ret = lttng_metadata_printf(session,
-			"		string%s %s;\n",
+			"		string%s _%s;\n",
 			field->type.u.basic.string.encoding == lttng_encode_ASCII ?
 				" { encoding = ASCII; }" : "",
 			field->name);
@@ -599,6 +727,11 @@ int _ltt_event_metadata_statedump(struct ltt_session *session,
 		return 0;
 	if (chan == session->metadata)
 		return 0;
+	/*
+	 * Don't print events for which probe load is pending.
+	 */
+	if (!event->desc)
+		return 0;
 
 	ret = lttng_metadata_printf(session,
 		"event {\n"
@@ -753,8 +886,8 @@ int _ltt_event_header_declare(struct ltt_session *session)
 	"		} extended;\n"
 	"	} v;\n"
 	"} align(%u);\n\n",
-	ltt_alignof(uint32_t) * CHAR_BIT,
-	ltt_alignof(uint16_t) * CHAR_BIT
+	lttng_alignof(uint32_t) * CHAR_BIT,
+	lttng_alignof(uint16_t) * CHAR_BIT
 	);
 }
 
@@ -805,14 +938,14 @@ int _ltt_session_metadata_statedump(struct ltt_session *session)
 		"		uint32_t stream_id;\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,
+		lttng_alignof(uint8_t) * CHAR_BIT,
+		lttng_alignof(uint16_t) * CHAR_BIT,
+		lttng_alignof(uint32_t) * CHAR_BIT,
+		lttng_alignof(uint64_t) * CHAR_BIT,
 		CTF_VERSION_MAJOR,
 		CTF_VERSION_MINOR,
 		uuid_s,
-#ifdef __BIG_ENDIAN
+#if (BYTE_ORDER == BIG_ENDIAN)
 		"be"
 #else
 		"le"
@@ -851,28 +984,24 @@ end:
  * @transport: transport structure
  *
  * Registers a transport which can be used as output to extract the data out of
- * LTTng.
+ * LTTng. Called with ust_lock held.
  */
 void ltt_transport_register(struct ltt_transport *transport)
 {
-	pthread_mutex_lock(&sessions_mutex);
 	cds_list_add_tail(&transport->node, &ltt_transport_list);
-	pthread_mutex_unlock(&sessions_mutex);
 }
 
 /**
  * ltt_transport_unregister - LTT transport unregistration
  * @transport: transport structure
+ * Called with ust_lock held.
  */
 void ltt_transport_unregister(struct ltt_transport *transport)
 {
-	pthread_mutex_lock(&sessions_mutex);
 	cds_list_del(&transport->node);
-	pthread_mutex_unlock(&sessions_mutex);
 }
 
-static
-void __attribute__((destructor)) ltt_events_exit(void)
+void lttng_ust_events_exit(void)
 {
 	struct ltt_session *session, *tmpsession;