X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust%2Flttng-ust-abi.c;h=716a2cc9d1a13efe8d8e943a6c41ad6c98395413;hb=e6c12e3dd164fcab19db5985f8729e3d1767571c;hp=6d17c2005dd2999a02ab20f382b0dd525761ef31;hpb=69400ac4a4e6575f749c6326df7c2a2c8ac3bdc5;p=lttng-ust.git

diff --git a/liblttng-ust/lttng-ust-abi.c b/liblttng-ust/lttng-ust-abi.c
index 6d17c200..716a2cc9 100644
--- a/liblttng-ust/lttng-ust-abi.c
+++ b/liblttng-ust/lttng-ust-abi.c
@@ -28,9 +28,16 @@
 #include <urcu/compiler.h>
 #include <urcu/list.h>
 #include <lttng/ust-events.h>
-#include <lttng/usterr-signal-safe.h>
-#include "lttng/core.h"
+#include <lttng/ust-version.h>
+#include <usterr-signal-safe.h>
+#include <helper.h>
 #include "ltt-tracer.h"
+#include "tracepoint-internal.h"
+
+static int lttng_ust_abi_close_in_progress;
+
+static
+int lttng_abi_tracepoint_list(void);
 
 /*
  * Object descriptor table. Should be protected from concurrent access
@@ -196,7 +203,10 @@ static const struct lttng_ust_objd_ops lttng_session_ops;
 static const struct lttng_ust_objd_ops lttng_channel_ops;
 static const struct lttng_ust_objd_ops lttng_metadata_ops;
 static const struct lttng_ust_objd_ops lttng_event_ops;
+static const struct lttng_ust_objd_ops lttng_loglevel_ops;
+static const struct lttng_ust_objd_ops lttng_wildcard_ops;
 static const struct lttng_ust_objd_ops lib_ring_buffer_objd_ops;
+static const struct lttng_ust_objd_ops lttng_tracepoint_list_ops;
 
 enum channel_type {
 	PER_CPU_CHANNEL,
@@ -233,33 +243,13 @@ objd_error:
 	return ret;
 }
 
-#if 0
-static
-int lttng_abi_tracepoint_list(void)
-{
-	int list_objd, ret;
-
-	/* TODO: Create list private data */
-	list_objd = objd_alloc(NULL, &lttng_tracepoint_list_ops);
-	if (list_objd < 0) {
-		ret = list_objd;
-		goto objd_error;
-	}
-
-	return list_objd;
-
-objd_error:
-	return ret;
-}
-#endif //0
-
 static
 long lttng_abi_tracer_version(int objd,
 	struct lttng_ust_tracer_version *v)
 {
-	v->version = LTTNG_UST_VERSION;
-	v->patchlevel = LTTNG_UST_PATCHLEVEL;
-	v->sublevel = LTTNG_UST_SUBLEVEL;
+	v->major = LTTNG_UST_MAJOR_VERSION;
+	v->minor = LTTNG_UST_MINOR_VERSION;
+	v->patchlevel = LTTNG_UST_PATCHLEVEL_VERSION;
 	return 0;
 }
 
@@ -314,8 +304,7 @@ long lttng_cmd(int objd, unsigned int cmd, unsigned long arg)
 		return lttng_abi_tracer_version(objd,
 				(struct lttng_ust_tracer_version *) arg);
 	case LTTNG_UST_TRACEPOINT_LIST:
-		return -ENOSYS;	//TODO
-		//return lttng_abi_tracepoint_list();
+		return lttng_abi_tracepoint_list();
 	case LTTNG_UST_WAIT_QUIESCENT:
 		synchronize_trace();
 		return 0;
@@ -339,7 +328,7 @@ void lttng_metadata_create_events(int channel_objd)
 	struct ltt_channel *channel = objd_private(channel_objd);
 	static struct lttng_ust_event metadata_params = {
 		.instrumentation = LTTNG_UST_TRACEPOINT,
-		.name = "lttng_metadata",
+		.name = "lttng_ust:metadata",
 	};
 	struct ltt_event *event;
 	int ret;
@@ -348,9 +337,8 @@ void lttng_metadata_create_events(int channel_objd)
 	 * We tolerate no failure path after event creation. It will stay
 	 * invariant for the rest of the session.
 	 */
-	event = ltt_event_create(channel, &metadata_params, NULL);
-	if (!event) {
-		ret = -EINVAL;
+	ret = ltt_event_create(channel, &metadata_params, NULL, &event);
+	if (ret < 0) {
 		goto create_error;
 	}
 	return;
@@ -370,12 +358,8 @@ int lttng_abi_create_channel(int session_objd,
 	struct ltt_channel *chan;
 	int chan_objd;
 	int ret = 0;
+	struct ltt_channel chan_priv_init;
 
-	chan_objd = objd_alloc(NULL, &lttng_channel_ops);
-	if (chan_objd < 0) {
-		ret = chan_objd;
-		goto objd_error;
-	}
 	switch (channel_type) {
 	case PER_CPU_CHANNEL:
 		if (chan_param->output == LTTNG_UST_MMAP) {
@@ -395,8 +379,17 @@ int lttng_abi_create_channel(int session_objd,
 		break;
 	default:
 		transport_name = "<unknown>";
-		break;
+		return -EINVAL;
+	}
+	chan_objd = objd_alloc(NULL, ops);
+	if (chan_objd < 0) {
+		ret = chan_objd;
+		goto objd_error;
 	}
+	memset(&chan_priv_init, 0, sizeof(chan_priv_init));
+	/* Copy of session UUID for consumer (availability through shm) */
+	memcpy(chan_priv_init.uuid, session->uuid, sizeof(session->uuid));
+	
 	/*
 	 * We tolerate no failure path after channel creation. It will stay
 	 * invariant for the rest of the session.
@@ -408,7 +401,8 @@ int lttng_abi_create_channel(int session_objd,
 				  chan_param->read_timer_interval,
 				  &chan_param->shm_fd,
 				  &chan_param->wait_fd,
-				  &chan_param->memory_map_size);
+				  &chan_param->memory_map_size,
+				  &chan_priv_init);
 	if (!chan) {
 		ret = -EINVAL;
 		goto chan_error;
@@ -419,7 +413,6 @@ int lttng_abi_create_channel(int session_objd,
 		session->metadata = chan;
 		lttng_metadata_create_events(chan_objd);
 	}
-
 	/* The channel created holds a reference on the session */
 	objd_ref(session_objd);
 
@@ -506,6 +499,88 @@ static const struct lttng_ust_objd_ops lttng_session_ops = {
 	.cmd = lttng_session_cmd,
 };
 
+static
+long lttng_tracepoint_list_cmd(int objd, unsigned int cmd, unsigned long arg)
+{
+	struct lttng_ust_tracepoint_list *list = objd_private(objd);
+	struct lttng_ust_tracepoint_iter *tp =
+		(struct lttng_ust_tracepoint_iter *) arg;
+	struct lttng_ust_tracepoint_iter *iter;
+
+	switch (cmd) {
+	case LTTNG_UST_TRACEPOINT_LIST_GET:
+	{
+	retry:
+		iter = lttng_ust_tracepoint_list_get_iter_next(list);
+		if (!iter)
+			return -ENOENT;
+		if (!strcmp(iter->name, "lttng_ust:metadata"))
+			goto retry;
+		memcpy(tp, iter, sizeof(*tp));
+		return 0;
+	}
+	default:
+		return -EINVAL;
+	}
+}
+
+static
+int lttng_abi_tracepoint_list(void)
+{
+	int list_objd, ret;
+	struct lttng_ust_tracepoint_list *list;
+
+	list_objd = objd_alloc(NULL, &lttng_tracepoint_list_ops);
+	if (list_objd < 0) {
+		ret = list_objd;
+		goto objd_error;
+	}
+	list = zmalloc(sizeof(*list));
+	if (!list) {
+		ret = -ENOMEM;
+		goto alloc_error;
+	}
+	objd_set_private(list_objd, list);
+
+	/* populate list by walking on all registered probes. */
+	ret = ltt_probes_get_event_list(list);
+	if (ret) {
+		goto list_error;
+	}
+	return list_objd;
+
+list_error:
+	free(list);
+alloc_error:
+	{
+		int err;
+
+		err = lttng_ust_objd_unref(list_objd);
+		assert(!err);
+	}
+objd_error:
+	return ret;
+}
+
+static
+int lttng_release_tracepoint_list(int objd)
+{
+	struct lttng_ust_tracepoint_list *list = objd_private(objd);
+
+	if (list) {
+		ltt_probes_prune_event_list(list);
+		free(list);
+		return 0;
+	} else {
+		return -EINVAL;
+	}
+}
+
+static const struct lttng_ust_objd_ops lttng_tracepoint_list_ops = {
+	.release = lttng_release_tracepoint_list,
+	.cmd = lttng_tracepoint_list_cmd,
+};
+
 struct stream_priv_data {
 	struct lttng_ust_lib_ring_buffer *buf;
 	struct ltt_channel *ltt_chan;
@@ -565,9 +640,8 @@ int lttng_abi_create_event(int channel_objd,
 	 * We tolerate no failure path after event creation. It will stay
 	 * invariant for the rest of the session.
 	 */
-	event = ltt_event_create(channel, event_param, NULL);
-	if (!event) {
-		ret = -EINVAL;
+	ret = ltt_event_create(channel, event_param, NULL, &event);
+	if (ret < 0) {
 		goto event_error;
 	}
 	objd_set_private(event_objd, event);
@@ -586,6 +660,82 @@ objd_error:
 	return ret;
 }
 
+static
+int lttng_abi_create_loglevel(int channel_objd,
+			      struct lttng_ust_event *event_param)
+{
+	struct ltt_channel *channel = objd_private(channel_objd);
+	struct session_loglevel *loglevel;
+	int loglevel_objd, ret;
+
+	event_param->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+	loglevel_objd = objd_alloc(NULL, &lttng_loglevel_ops);
+	if (loglevel_objd < 0) {
+		ret = loglevel_objd;
+		goto objd_error;
+	}
+	/*
+	 * We tolerate no failure path after loglevel creation. It will
+	 * stay invariant for the rest of the session.
+	 */
+	ret = ltt_loglevel_create(channel, event_param, &loglevel);
+	if (ret < 0) {
+		goto loglevel_error;
+	}
+	objd_set_private(loglevel_objd, loglevel);
+	/* The loglevel holds a reference on the channel */
+	objd_ref(channel_objd);
+	return loglevel_objd;
+
+loglevel_error:
+	{
+		int err;
+
+		err = lttng_ust_objd_unref(loglevel_objd);
+		assert(!err);
+	}
+objd_error:
+	return ret;
+}
+
+static
+int lttng_abi_create_wildcard(int channel_objd,
+			      struct lttng_ust_event *event_param)
+{
+	struct ltt_channel *channel = objd_private(channel_objd);
+	struct session_wildcard *wildcard;
+	int wildcard_objd, ret;
+
+	event_param->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+	wildcard_objd = objd_alloc(NULL, &lttng_wildcard_ops);
+	if (wildcard_objd < 0) {
+		ret = wildcard_objd;
+		goto objd_error;
+	}
+	/*
+	 * We tolerate no failure path after wildcard creation. It will
+	 * stay invariant for the rest of the session.
+	 */
+	ret = ltt_wildcard_create(channel, event_param, &wildcard);
+	if (ret < 0) {
+		goto wildcard_error;
+	}
+	objd_set_private(wildcard_objd, wildcard);
+	/* The wildcard holds a reference on the channel */
+	objd_ref(channel_objd);
+	return wildcard_objd;
+
+wildcard_error:
+	{
+		int err;
+
+		err = lttng_ust_objd_unref(wildcard_objd);
+		assert(!err);
+	}
+objd_error:
+	return ret;
+}
+
 /**
  *	lttng_channel_cmd - lttng control through object descriptors
  *
@@ -623,7 +773,20 @@ long lttng_channel_cmd(int objd, unsigned int cmd, unsigned long arg)
 		return lttng_abi_open_stream(objd, stream);
 	}
 	case LTTNG_UST_EVENT:
-		return lttng_abi_create_event(objd, (struct lttng_ust_event *) arg);
+	{
+		struct lttng_ust_event *event_param =
+			(struct lttng_ust_event *) arg;
+		if (event_param->instrumentation == LTTNG_UST_TRACEPOINT_LOGLEVEL) {
+			return lttng_abi_create_loglevel(objd, event_param);
+		} else {
+			if (event_param->name[strlen(event_param->name) - 1] == '*') {
+				/* If ends with wildcard, create wildcard. */
+				return lttng_abi_create_wildcard(objd, event_param);
+			} else {
+				return lttng_abi_create_event(objd, event_param);
+			}
+		}
+	}
 	case LTTNG_UST_CONTEXT:
 		return lttng_abi_add_context(objd,
 				(struct lttng_ust_context *) arg,
@@ -754,7 +917,21 @@ int lttng_rb_release(int objd)
 		buf = priv->buf;
 		channel = priv->ltt_chan;
 		free(priv);
-		channel->ops->buffer_read_close(buf, channel->handle);
+		/*
+		 * If we are at ABI exit, we don't want to close the
+		 * buffer opened for read: it is being shared between
+		 * the parent and child (right after fork), and we don't
+		 * want the child to close it for the parent. For a real
+		 * exit, we don't care about marking it as closed, as
+		 * the consumer daemon (if there is one) will do fine
+		 * even if we don't mark it as "closed" for reading on
+		 * our side.
+		 * We only mark it as closed if it is being explicitely
+		 * released by the session daemon with an explicit
+		 * release command.
+		 */
+		if (!lttng_ust_abi_close_in_progress)
+			channel->ops->buffer_read_close(buf, channel->handle);
 
 		return lttng_ust_objd_unref(channel->objd);
 	}
@@ -816,7 +993,117 @@ static const struct lttng_ust_objd_ops lttng_event_ops = {
 	.cmd = lttng_event_cmd,
 };
 
+/**
+ *	lttng_loglevel_cmd - lttng control through object descriptors
+ *
+ *	@objd: the object descriptor
+ *	@cmd: the command
+ *	@arg: command arg
+ *
+ *	This object descriptor implements lttng commands:
+ *	LTTNG_UST_CONTEXT
+ *		Prepend a context field to each record of events of this
+ *		loglevel.
+ *	LTTNG_UST_ENABLE
+ *		Enable recording for these loglevel events (weak enable)
+ *	LTTNG_UST_DISABLE
+ *		Disable recording for these loglevel events (strong disable)
+ */
+static
+long lttng_loglevel_cmd(int objd, unsigned int cmd, unsigned long arg)
+{
+	struct session_loglevel *loglevel = objd_private(objd);
+
+	switch (cmd) {
+	case LTTNG_UST_CONTEXT:
+		return -ENOSYS;	/* not implemented yet */
+#if 0
+		return lttng_abi_add_context(objd,
+				(struct lttng_ust_context *) arg,
+				&loglevel->ctx, loglevel->chan->session);
+#endif
+	case LTTNG_UST_ENABLE:
+		return ltt_loglevel_enable(loglevel);
+	case LTTNG_UST_DISABLE:
+		return ltt_loglevel_disable(loglevel);
+	default:
+		return -EINVAL;
+	}
+}
+
+static
+int lttng_loglevel_release(int objd)
+{
+	struct session_loglevel *loglevel = objd_private(objd);
+
+	if (loglevel)
+		return lttng_ust_objd_unref(loglevel->chan->objd);
+	return 0;
+}
+
+/* TODO: filter control ioctl */
+static const struct lttng_ust_objd_ops lttng_loglevel_ops = {
+	.release = lttng_loglevel_release,
+	.cmd = lttng_loglevel_cmd,
+};
+
+/**
+ *	lttng_wildcard_cmd - lttng control through object descriptors
+ *
+ *	@objd: the object descriptor
+ *	@cmd: the command
+ *	@arg: command arg
+ *
+ *	This object descriptor implements lttng commands:
+ *	LTTNG_UST_CONTEXT
+ *		Prepend a context field to each record of events of this
+ *		wildcard.
+ *	LTTNG_UST_ENABLE
+ *		Enable recording for these wildcard events (weak enable)
+ *	LTTNG_UST_DISABLE
+ *		Disable recording for these wildcard events (strong disable)
+ */
+static
+long lttng_wildcard_cmd(int objd, unsigned int cmd, unsigned long arg)
+{
+	struct session_wildcard *wildcard = objd_private(objd);
+
+	switch (cmd) {
+	case LTTNG_UST_CONTEXT:
+		return -ENOSYS;	/* not implemented yet */
+#if 0
+		return lttng_abi_add_context(objd,
+				(struct lttng_ust_context *) arg,
+				&wildcard->ctx, wildcard->chan->session);
+#endif
+	case LTTNG_UST_ENABLE:
+		return ltt_wildcard_enable(wildcard);
+	case LTTNG_UST_DISABLE:
+		return ltt_wildcard_disable(wildcard);
+	default:
+		return -EINVAL;
+	}
+}
+
+static
+int lttng_wildcard_release(int objd)
+{
+	struct session_wildcard *wildcard = objd_private(objd);
+
+	if (wildcard)
+		return lttng_ust_objd_unref(wildcard->chan->objd);
+	return 0;
+}
+
+/* TODO: filter control ioctl */
+static const struct lttng_ust_objd_ops lttng_wildcard_ops = {
+	.release = lttng_wildcard_release,
+	.cmd = lttng_wildcard_cmd,
+};
+
 void lttng_ust_abi_exit(void)
 {
+	lttng_ust_abi_close_in_progress = 1;
 	objd_table_destroy();
+	lttng_ust_abi_close_in_progress = 0;
 }