X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=lttng-sessiond%2Fmain.c;h=a40c3693452fd8a464b8121724eed1fe41572658;hp=ea3853c1a6f19b5a0132e86f287e82b3d313073a;hb=509cbaf89ee874b312c89ca8276b13569b49c4c5;hpb=322585731ced1adba36cddcb8bdd5d997d1b2e3e

diff --git a/lttng-sessiond/main.c b/lttng-sessiond/main.c
index ea3853c1a..a40c36934 100644
--- a/lttng-sessiond/main.c
+++ b/lttng-sessiond/main.c
@@ -338,12 +338,6 @@ static void cleanup(void)
 
 	DBG("Cleaning up");
 
-	/* <fun> */
-	MSG("%c[%d;%dm*** assert failed *** ==> %c[%dm%c[%d;%dm"
-		"Matthew, BEET driven development works!%c[%dm",
-		27, 1, 31, 27, 0, 27, 1, 33, 27, 0);
-	/* </fun> */
-
 	if (is_root) {
 		DBG("Removing %s directory", LTTNG_RUNDIR);
 		ret = asprintf(&cmd, "rm -rf " LTTNG_RUNDIR);
@@ -388,6 +382,12 @@ static void cleanup(void)
 
 	close(thread_quit_pipe[0]);
 	close(thread_quit_pipe[1]);
+
+	/* <fun> */
+	MSG("%c[%d;%dm*** assert failed :-) *** ==> %c[%dm%c[%d;%dm"
+			"Matthew, BEET driven development works!%c[%dm",
+			27, 1, 31, 27, 0, 27, 1, 33, 27, 0);
+	/* </fun> */
 }
 
 /*
@@ -711,6 +711,21 @@ error:
 	return ret;
 }
 
+/*
+ * For each tracing session, update newly registered apps.
+ */
+static void update_ust_app(int app_sock)
+{
+	struct ltt_session *sess, *stmp;
+
+	/* For all tracing session(s) */
+	cds_list_for_each_entry_safe(sess, stmp, &session_list_ptr->head, list) {
+		if (sess->ust_session) {
+			ust_app_global_update(sess->ust_session, app_sock);
+		}
+	}
+}
+
 /*
  * This thread manage event coming from the kernel.
  *
@@ -1042,6 +1057,12 @@ static void *thread_manage_apps(void *data)
 						goto error;
 					}
 
+					/*
+					 * Add channel(s) and event(s) to newly registered apps
+					 * from lttng global UST domain.
+					 */
+					update_ust_app(ust_cmd.sock);
+
 					ret = ustctl_register_done(ust_cmd.sock);
 					if (ret < 0) {
 						/*
@@ -1062,6 +1083,7 @@ static void *thread_manage_apps(void *data)
 						DBG("Apps with sock %d added to poll set",
 								ust_cmd.sock);
 					}
+
 					break;
 				}
 			} else {
@@ -1699,6 +1721,7 @@ static int create_ust_session(struct ltt_session *session,
 		/* No ustctl for the global UST domain */
 		break;
 	default:
+		ERR("Unknown UST domain on create session %d", domain->type);
 		goto error;
 	}
 	session->ust_session = lus;
@@ -1772,7 +1795,7 @@ static void list_lttng_sessions(struct lttng_session *sessions)
 /*
  * Fill lttng_channel array of all channels.
  */
-static void list_lttng_channels(struct ltt_session *session,
+static void list_lttng_channels(int domain, struct ltt_session *session,
 		struct lttng_channel *channels)
 {
 	int i = 0;
@@ -1780,59 +1803,162 @@ static void list_lttng_channels(struct ltt_session *session,
 
 	DBG("Listing channels for session %s", session->name);
 
-	/* Kernel channels */
-	if (session->kernel_session != NULL) {
-		cds_list_for_each_entry(kchan,
-				&session->kernel_session->channel_list.head, list) {
-			/* Copy lttng_channel struct to array */
-			memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel));
-			channels[i].enabled = kchan->enabled;
+	switch (domain) {
+	case LTTNG_DOMAIN_KERNEL:
+		/* Kernel channels */
+		if (session->kernel_session != NULL) {
+			cds_list_for_each_entry(kchan,
+					&session->kernel_session->channel_list.head, list) {
+				/* Copy lttng_channel struct to array */
+				memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel));
+				channels[i].enabled = kchan->enabled;
+				i++;
+			}
+		}
+		break;
+	case LTTNG_DOMAIN_UST:
+	{
+		struct cds_lfht_iter iter;
+		struct ltt_ust_channel *uchan;
+
+		cds_lfht_for_each_entry(session->ust_session->domain_global.channels,
+				&iter, uchan, node) {
+			strncpy(channels[i].name, uchan->name, LTTNG_SYMBOL_NAME_LEN);
+			channels[i].attr.overwrite = uchan->attr.overwrite;
+			channels[i].attr.subbuf_size = uchan->attr.subbuf_size;
+			channels[i].attr.num_subbuf = uchan->attr.num_subbuf;
+			channels[i].attr.switch_timer_interval =
+				uchan->attr.switch_timer_interval;
+			channels[i].attr.read_timer_interval =
+				uchan->attr.read_timer_interval;
+			channels[i].attr.output = uchan->attr.output;
+		}
+		break;
+	}
+	default:
+		break;
+	}
+}
+
+/*
+ * Create a list of ust global domain events.
+ */
+static int list_lttng_ust_global_events(char *channel_name,
+		struct ltt_ust_domain_global *ust_global, struct lttng_event **events)
+{
+	int i = 0, ret = 0;
+	unsigned int nb_event = 0;
+	struct cds_lfht_iter iter;
+	struct ltt_ust_channel *uchan;
+	struct ltt_ust_event *uevent;
+	struct lttng_event *tmp;
+
+	DBG("Listing UST global events for channel %s", channel_name);
+
+	rcu_read_lock();
+
+	/* Count events in all channels */
+	cds_lfht_for_each_entry(ust_global->channels, &iter, uchan, node) {
+		nb_event += hashtable_get_count(uchan->events);
+	}
+
+	if (nb_event == 0) {
+		ret = nb_event;
+		goto error;
+	}
+
+	DBG3("Listing UST global %d events", nb_event);
+
+	tmp = zmalloc(nb_event * sizeof(struct lttng_event));
+	if (tmp == NULL) {
+		ret = -LTTCOMM_FATAL;
+		goto error;
+	}
+
+	cds_lfht_for_each_entry(ust_global->channels, &iter, uchan, node) {
+		cds_lfht_for_each_entry(uchan->events, &iter, uevent, node) {
+			strncpy(tmp[i].name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN);
+			tmp[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
+			switch (uevent->attr.instrumentation) {
+			case LTTNG_UST_TRACEPOINT:
+				tmp[i].type = LTTNG_EVENT_TRACEPOINT;
+				break;
+			case LTTNG_UST_PROBE:
+				tmp[i].type = LTTNG_EVENT_PROBE;
+				break;
+			case LTTNG_UST_FUNCTION:
+				tmp[i].type = LTTNG_EVENT_FUNCTION;
+				break;
+			}
 			i++;
 		}
 	}
 
-	/* TODO: Missing UST listing */
+	ret = nb_event;
+	*events = tmp;
+
+error:
+	rcu_read_unlock();
+	return ret;
 }
 
 /*
- * Fill lttng_event array of all events in the channel.
+ * Fill lttng_event array of all kernel events in the channel.
  */
-static void list_lttng_events(struct ltt_kernel_channel *kchan,
-		struct lttng_event *events)
+static int list_lttng_kernel_events(char *channel_name,
+		struct ltt_kernel_session *kernel_session, struct lttng_event **events)
 {
-	/*
-	 * TODO: This is ONLY kernel. Need UST support.
-	 */
-	int i = 0;
+	int i = 0, ret;
+	unsigned int nb_event;
 	struct ltt_kernel_event *event;
+	struct ltt_kernel_channel *kchan;
+
+	kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session);
+	if (kchan == NULL) {
+		ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
+		goto error;
+	}
+
+	nb_event = kchan->event_count;
 
 	DBG("Listing events for channel %s", kchan->channel->name);
 
+	if (nb_event == 0) {
+		ret = nb_event;
+		goto error;
+	}
+
+	*events = zmalloc(nb_event * sizeof(struct lttng_event));
+	if (*events == NULL) {
+		ret = LTTCOMM_FATAL;
+		goto error;
+	}
+
 	/* Kernel channels */
 	cds_list_for_each_entry(event, &kchan->events_list.head , list) {
-		strncpy(events[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN);
-		events[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
-		events[i].enabled = event->enabled;
+		strncpy((*events)[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN);
+		(*events)[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
+		(*events)[i].enabled = event->enabled;
 		switch (event->event->instrumentation) {
 			case LTTNG_KERNEL_TRACEPOINT:
-				events[i].type = LTTNG_EVENT_TRACEPOINT;
+				(*events)[i].type = LTTNG_EVENT_TRACEPOINT;
 				break;
 			case LTTNG_KERNEL_KPROBE:
 			case LTTNG_KERNEL_KRETPROBE:
-				events[i].type = LTTNG_EVENT_PROBE;
-				memcpy(&events[i].attr.probe, &event->event->u.kprobe,
+				(*events)[i].type = LTTNG_EVENT_PROBE;
+				memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe,
 						sizeof(struct lttng_kernel_kprobe));
 				break;
 			case LTTNG_KERNEL_FUNCTION:
-				events[i].type = LTTNG_EVENT_FUNCTION;
-				memcpy(&events[i].attr.ftrace, &event->event->u.ftrace,
+				(*events)[i].type = LTTNG_EVENT_FUNCTION;
+				memcpy(&((*events)[i].attr.ftrace), &event->event->u.ftrace,
 						sizeof(struct lttng_kernel_function));
 				break;
 			case LTTNG_KERNEL_NOOP:
-				events[i].type = LTTNG_EVENT_NOOP;
+				(*events)[i].type = LTTNG_EVENT_NOOP;
 				break;
 			case LTTNG_KERNEL_SYSCALL:
-				events[i].type = LTTNG_EVENT_SYSCALL;
+				(*events)[i].type = LTTNG_EVENT_SYSCALL;
 				break;
 			case LTTNG_KERNEL_ALL:
 				assert(0);
@@ -1840,6 +1966,11 @@ static void list_lttng_events(struct ltt_kernel_channel *kchan,
 		}
 		i++;
 	}
+
+	return nb_event;
+
+error:
+	return ret;
 }
 
 /*
@@ -1963,8 +2094,9 @@ static int cmd_enable_channel(struct ltt_session *session,
 			goto error;
 		}
 
-		ret = ust_app_add_channel(usess, uchan);
-		if (ret != LTTCOMM_OK) {
+		/* Add channel to all registered applications */
+		ret = ust_app_add_channel_all(usess, uchan);
+		if (ret != 0) {
 			goto error;
 		}
 
@@ -2223,11 +2355,15 @@ static int cmd_enable_event(struct ltt_session *session, int domain,
 			}
 		}
 
-		ret = ust_app_add_event(usess, uchan, uevent);
+		ret = ust_app_add_event_all(usess, uchan, uevent);
 		if (ret < 0) {
 			ret = LTTCOMM_UST_ENABLE_FAIL;
 			goto error;
 		}
+
+		rcu_read_lock();
+		hashtable_add_unique(uchan->events, &uevent->node);
+		rcu_read_unlock();
 		break;
 	}
 	case LTTNG_DOMAIN_UST_EXEC_NAME:
@@ -2331,8 +2467,14 @@ static ssize_t cmd_list_tracepoints(int domain, struct lttng_event **events)
 			goto error;
 		}
 		break;
+	case LTTNG_DOMAIN_UST:
+		nb_events = ust_app_list_events(events);
+		if (nb_events < 0) {
+			ret = LTTCOMM_UST_LIST_FAIL;
+			goto error;
+		}
+		break;
 	default:
-		/* TODO: Userspace listing */
 		ret = LTTCOMM_NOT_IMPLEMENTED;
 		goto error;
 	}
@@ -2410,7 +2552,10 @@ static int cmd_start_trace(struct ltt_session *session)
 		kernel_wait_quiescent(kernel_tracer_fd);
 	}
 
-	ret = ust_app_start_trace(usess);
+	/* Flag session that trace should start automatically */
+	usess->start_trace = 1;
+
+	ret = ust_app_start_trace_all(usess);
 	if (ret < 0) {
 		ret = LTTCOMM_UST_START_FAIL;
 		goto error;
@@ -2611,22 +2756,34 @@ error:
 static ssize_t cmd_list_domains(struct ltt_session *session,
 		struct lttng_domain **domains)
 {
-	int ret;
+	int ret, index = 0;
 	ssize_t nb_dom = 0;
 
 	if (session->kernel_session != NULL) {
+		DBG3("Listing domains found kernel domain");
 		nb_dom++;
 	}
 
-	/* TODO: User-space tracer domain support */
+	if (session->ust_session != NULL) {
+		DBG3("Listing domains found UST global domain");
+		nb_dom++;
+	}
 
-	*domains = malloc(nb_dom * sizeof(struct lttng_domain));
+	*domains = zmalloc(nb_dom * sizeof(struct lttng_domain));
 	if (*domains == NULL) {
 		ret = -LTTCOMM_FATAL;
 		goto error;
 	}
 
-	(*domains)[0].type = LTTNG_DOMAIN_KERNEL;
+	if (session->kernel_session != NULL) {
+		(*domains)[index].type = LTTNG_DOMAIN_KERNEL;
+		index++;
+	}
+
+	if (session->ust_session != NULL) {
+		(*domains)[index].type = LTTNG_DOMAIN_UST;
+		index++;
+	}
 
 	return nb_dom;
 
@@ -2637,25 +2794,43 @@ error:
 /*
  * Command LTTNG_LIST_CHANNELS processed by the client thread.
  */
-static ssize_t cmd_list_channels(struct ltt_session *session,
+static ssize_t cmd_list_channels(int domain, struct ltt_session *session,
 		struct lttng_channel **channels)
 {
 	int ret;
 	ssize_t nb_chan = 0;
 
-	if (session->kernel_session != NULL) {
-		nb_chan += session->kernel_session->channel_count;
-	}
-
-	*channels = malloc(nb_chan * sizeof(struct lttng_channel));
-	if (*channels == NULL) {
-		ret = -LTTCOMM_FATAL;
+	switch (domain) {
+	case LTTNG_DOMAIN_KERNEL:
+		if (session->kernel_session != NULL) {
+			nb_chan = session->kernel_session->channel_count;
+		}
+		DBG3("Number of kernel channels %ld", nb_chan);
+		break;
+	case LTTNG_DOMAIN_UST:
+		if (session->ust_session != NULL) {
+			nb_chan = hashtable_get_count(
+					session->ust_session->domain_global.channels);
+		}
+		DBG3("Number of UST global channels %ld", nb_chan);
+		break;
+	default:
+		*channels = NULL;
+		ret = -LTTCOMM_NOT_IMPLEMENTED;
 		goto error;
 	}
 
-	list_lttng_channels(session, *channels);
+	if (nb_chan > 0) {
+		*channels = zmalloc(nb_chan * sizeof(struct lttng_channel));
+		if (*channels == NULL) {
+			ret = -LTTCOMM_FATAL;
+			goto error;
+		}
 
-	/* TODO UST support */
+		list_lttng_channels(domain, session, *channels);
+	} else {
+		*channels = NULL;
+	}
 
 	return nb_chan;
 
@@ -2666,34 +2841,33 @@ error:
 /*
  * Command LTTNG_LIST_EVENTS processed by the client thread.
  */
-static ssize_t cmd_list_events(struct ltt_session *session,
+static ssize_t cmd_list_events(int domain, struct ltt_session *session,
 		char *channel_name, struct lttng_event **events)
 {
-	int ret;
+	int ret = 0;
 	ssize_t nb_event = 0;
-	struct ltt_kernel_channel *kchan = NULL;
 
-	if (session->kernel_session != NULL) {
-		kchan = trace_kernel_get_channel_by_name(channel_name,
-				session->kernel_session);
-		if (kchan == NULL) {
-			ret = -LTTCOMM_KERN_CHAN_NOT_FOUND;
-			goto error;
+	switch (domain) {
+	case LTTNG_DOMAIN_KERNEL:
+		if (session->kernel_session != NULL) {
+			nb_event = list_lttng_kernel_events(channel_name,
+					session->kernel_session, events);
+		}
+		break;
+	case LTTNG_DOMAIN_UST:
+	{
+		if (session->ust_session != NULL) {
+			nb_event = list_lttng_ust_global_events(channel_name,
+					&session->ust_session->domain_global, events);
 		}
-		nb_event += kchan->event_count;
+		break;
 	}
-
-	*events = malloc(nb_event * sizeof(struct lttng_event));
-	if (*events == NULL) {
-		ret = -LTTCOMM_FATAL;
+	default:
+		ret = -LTTCOMM_NOT_IMPLEMENTED;
 		goto error;
 	}
 
-	list_lttng_events(kchan, *events);
-
-	/* TODO: User-space tracer support */
-
-	return nb_event;
+	ret = nb_event;
 
 error:
 	return ret;
@@ -2969,7 +3143,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 		size_t nb_chan;
 		struct lttng_channel *channels;
 
-		nb_chan = cmd_list_channels(cmd_ctx->session, &channels);
+		nb_chan = cmd_list_channels(cmd_ctx->lsm->domain.type,
+				cmd_ctx->session, &channels);
 		if (nb_chan < 0) {
 			ret = -nb_chan;
 			goto error;
@@ -2991,10 +3166,10 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 	}
 	case LTTNG_LIST_EVENTS:
 	{
-		size_t nb_event;
+		ssize_t nb_event;
 		struct lttng_event *events = NULL;
 
-		nb_event = cmd_list_events(cmd_ctx->session,
+		nb_event = cmd_list_events(cmd_ctx->lsm->domain.type, cmd_ctx->session,
 				cmd_ctx->lsm->u.list.channel_name, &events);
 		if (nb_event < 0) {
 			ret = -nb_event;