X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fmain.c;h=548cc43095b633bb09528085dfb878a5e99578f6;hb=db322c4dcbe5bf4b8a16d8444fa7f56579c72b26;hp=659b2f67f00bf51c834adf41f88b0915cb4f8681;hpb=965444556d7b554bee46df96d7893d3d7518fa86;p=lttng-tools.git

diff --git a/src/bin/lttng-sessiond/main.c b/src/bin/lttng-sessiond/main.c
index 659b2f67f..548cc4309 100644
--- a/src/bin/lttng-sessiond/main.c
+++ b/src/bin/lttng-sessiond/main.c
@@ -68,6 +68,8 @@
 #include "testpoint.h"
 #include "ust-thread.h"
 #include "jul-thread.h"
+#include "save.h"
+#include "load-session-thread.h"
 
 #define CONSUMERD_FILE	"lttng-consumerd"
 
@@ -79,7 +81,7 @@ static int opt_sig_parent;
 static int opt_verbose_consumer;
 static int opt_daemon, opt_background;
 static int opt_no_kernel;
-static int is_root;			/* Set to 1 if the daemon is running as root */
+static char *opt_load_session_path;
 static pid_t ppid;          /* Parent PID for --sig-parent option */
 static pid_t child_ppid;    /* Internal parent PID use with daemonize. */
 static char *rundir;
@@ -152,6 +154,8 @@ static const struct option long_options[] = {
 	{ "pidfile", 1, 0, 'p' },
 	{ "jul-tcp-port", 1, 0, 'J' },
 	{ "config", 1, 0, 'f' },
+	{ "load", 1, 0, 'l' },
+	{ "kmod-probes", 1, 0, 'P' },
 	{ NULL, 0, 0, 0 }
 };
 
@@ -200,13 +204,16 @@ static pthread_t dispatch_thread;
 static pthread_t health_thread;
 static pthread_t ht_cleanup_thread;
 static pthread_t jul_reg_thread;
+static pthread_t load_session_thread;
 
 /*
  * UST registration command queue. This queue is tied with a futex and uses a N
  * wakers / 1 waiter implemented and detailed in futex.c/.h
  *
- * The thread_manage_apps and thread_dispatch_ust_registration interact with
- * this queue and the wait/wake scheme.
+ * The thread_registration_apps and thread_dispatch_ust_registration uses this
+ * queue along with the wait/wake scheme. The thread_manage_apps receives down
+ * the line new application socket and monitors it for any I/O error or clean
+ * close that triggers an unregistration of the application.
  */
 static struct ust_cmd_queue ust_cmd_queue;
 
@@ -284,19 +291,25 @@ struct health_app *health_sessiond;
 /* JUL TCP port for registration. Used by the JUL thread. */
 unsigned int jul_tcp_port = DEFAULT_JUL_TCP_PORT;
 
+/* Am I root or not. */
+int is_root;			/* Set to 1 if the daemon is running as root */
+
 const char * const config_section_name = "sessiond";
 
+/* Load session thread information to operate. */
+struct load_session_thread_data *load_info;
+
 /*
  * Whether sessiond is ready for commands/health check requests.
  * NR_LTTNG_SESSIOND_READY must match the number of calls to
- * lttng_sessiond_notify_ready().
+ * sessiond_notify_ready().
  */
-#define NR_LTTNG_SESSIOND_READY		2
+#define NR_LTTNG_SESSIOND_READY		3
 int lttng_sessiond_ready = NR_LTTNG_SESSIOND_READY;
 
 /* Notify parents that we are ready for cmd and health check */
-static
-void lttng_sessiond_notify_ready(void)
+LTTNG_HIDDEN
+void sessiond_notify_ready(void)
 {
 	if (uatomic_sub_return(&lttng_sessiond_ready, 1) == 0) {
 		/*
@@ -642,6 +655,15 @@ static void cleanup(void)
 		free(opt_pidfile);
 	}
 
+	if (opt_load_session_path) {
+		free(opt_load_session_path);
+	}
+
+	if (load_info) {
+		load_session_destroy_data(load_info);
+		free(load_info);
+	}
+
 	/* <fun> */
 	DBG("%c[%d;%dm*** assert failed :-) *** ==> %c[%dm%c[%d;%dm"
 			"Matthew, BEET driven development works!%c[%dm",
@@ -2228,9 +2250,12 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data)
 		 */
 		if (opt_verbose_consumer) {
 			verbosity = "--verbose";
-		} else {
+		} else if (lttng_opt_quiet) {
 			verbosity = "--quiet";
+		} else {
+			verbosity = "";
 		}
+
 		switch (consumer_data->type) {
 		case LTTNG_CONSUMER_KERNEL:
 			/*
@@ -2716,6 +2741,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int sock,
 	case LTTNG_SNAPSHOT_DEL_OUTPUT:
 	case LTTNG_SNAPSHOT_LIST_OUTPUT:
 	case LTTNG_SNAPSHOT_RECORD:
+	case LTTNG_SAVE_SESSION:
 		need_domain = 0;
 		break;
 	default:
@@ -2774,6 +2800,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int sock,
 	case LTTNG_LIST_SESSIONS:
 	case LTTNG_LIST_TRACEPOINTS:
 	case LTTNG_LIST_TRACEPOINT_FIELDS:
+	case LTTNG_SAVE_SESSION:
 		need_tracing_session = 0;
 		break;
 	default:
@@ -2795,6 +2822,38 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int sock,
 		break;
 	}
 
+	/*
+	 * Commands that need a valid session but should NOT create one if none
+	 * exists. Instead of creating one and destroying it when the command is
+	 * handled, process that right before so we save some round trip in useless
+	 * code path.
+	 */
+	switch (cmd_ctx->lsm->cmd_type) {
+	case LTTNG_DISABLE_CHANNEL:
+	case LTTNG_DISABLE_EVENT:
+	case LTTNG_DISABLE_ALL_EVENT:
+		switch (cmd_ctx->lsm->domain.type) {
+		case LTTNG_DOMAIN_KERNEL:
+			if (!cmd_ctx->session->kernel_session) {
+				ret = LTTNG_ERR_NO_CHANNEL;
+				goto error;
+			}
+			break;
+		case LTTNG_DOMAIN_JUL:
+		case LTTNG_DOMAIN_UST:
+			if (!cmd_ctx->session->ust_session) {
+				ret = LTTNG_ERR_NO_CHANNEL;
+				goto error;
+			}
+			break;
+		default:
+			ret = LTTNG_ERR_UNKNOWN_DOMAIN;
+			goto error;
+		}
+	default:
+		break;
+	}
+
 	if (!need_domain) {
 		goto skip_domain;
 	}
@@ -3037,6 +3096,7 @@ skip_domain:
 	{
 		struct lttng_event_exclusion *exclusion = NULL;
 		struct lttng_filter_bytecode *bytecode = NULL;
+		char *filter_expression = NULL;
 
 		/* Handle exclusion events and receive it from the client. */
 		if (cmd_ctx->lsm->u.enable.exclusion_count > 0) {
@@ -3062,6 +3122,38 @@ skip_domain:
 			}
 		}
 
+		/* Get filter expression from client. */
+		if (cmd_ctx->lsm->u.enable.expression_len > 0) {
+			size_t expression_len =
+				cmd_ctx->lsm->u.enable.expression_len;
+
+			if (expression_len > LTTNG_FILTER_MAX_LEN) {
+				ret = LTTNG_ERR_FILTER_INVAL;
+				free(exclusion);
+				goto error;
+			}
+
+			filter_expression = zmalloc(expression_len);
+			if (!filter_expression) {
+				free(exclusion);
+				ret = LTTNG_ERR_FILTER_NOMEM;
+				goto error;
+			}
+
+			/* Receive var. len. data */
+			DBG("Receiving var len filter's expression from client ...");
+			ret = lttcomm_recv_unix_sock(sock, filter_expression,
+				expression_len);
+			if (ret <= 0) {
+				DBG("Nothing recv() from client car len data... continuing");
+				*sock_error = 1;
+				free(filter_expression);
+				free(exclusion);
+				ret = LTTNG_ERR_FILTER_INVAL;
+				goto error;
+			}
+		}
+
 		/* Handle filter and get bytecode from client. */
 		if (cmd_ctx->lsm->u.enable.bytecode_len > 0) {
 			size_t bytecode_len = cmd_ctx->lsm->u.enable.bytecode_len;
@@ -3101,7 +3193,8 @@ skip_domain:
 
 		ret = cmd_enable_event(cmd_ctx->session, &cmd_ctx->lsm->domain,
 				cmd_ctx->lsm->u.enable.channel_name,
-				&cmd_ctx->lsm->u.enable.event, bytecode, exclusion,
+				&cmd_ctx->lsm->u.enable.event,
+				filter_expression, bytecode, exclusion,
 				kernel_poll_pipe[1]);
 		break;
 	}
@@ -3111,7 +3204,8 @@ skip_domain:
 
 		ret = cmd_enable_event_all(cmd_ctx->session, &cmd_ctx->lsm->domain,
 				cmd_ctx->lsm->u.enable.channel_name,
-				cmd_ctx->lsm->u.enable.event.type, NULL, kernel_poll_pipe[1]);
+				cmd_ctx->lsm->u.enable.event.type, NULL, NULL,
+				kernel_poll_pipe[1]);
 		break;
 	}
 	case LTTNG_LIST_TRACEPOINTS:
@@ -3119,7 +3213,9 @@ skip_domain:
 		struct lttng_event *events;
 		ssize_t nb_events;
 
+		session_lock_list();
 		nb_events = cmd_list_tracepoints(cmd_ctx->lsm->domain.type, &events);
+		session_unlock_list();
 		if (nb_events < 0) {
 			/* Return value is a negative lttng_error_code. */
 			ret = -nb_events;
@@ -3150,8 +3246,10 @@ skip_domain:
 		struct lttng_event_field *fields;
 		ssize_t nb_fields;
 
+		session_lock_list();
 		nb_fields = cmd_list_tracepoint_fields(cmd_ctx->lsm->domain.type,
 				&fields);
+		session_unlock_list();
 		if (nb_fields < 0) {
 			/* Return value is a negative lttng_error_code. */
 			ret = -nb_fields;
@@ -3570,6 +3668,12 @@ skip_domain:
 		free(uris);
 		break;
 	}
+	case LTTNG_SAVE_SESSION:
+	{
+		ret = cmd_save_sessions(&cmd_ctx->lsm->u.save_session.attr,
+			&cmd_ctx->creds);
+		break;
+	}
 	default:
 		ret = LTTNG_ERR_UND;
 		break;
@@ -3668,7 +3772,7 @@ static void *thread_manage_health(void *data)
 		goto error;
 	}
 
-	lttng_sessiond_notify_ready();
+	sessiond_notify_ready();
 
 	while (1) {
 		DBG("Health check ready");
@@ -3820,7 +3924,12 @@ static void *thread_manage_clients(void *data)
 		goto error;
 	}
 
-	lttng_sessiond_notify_ready();
+	sessiond_notify_ready();
+	ret = sem_post(&load_info->message_thread_ready);
+	if (ret) {
+		PERROR("sem_post message_thread_ready");
+		goto error;
+	}
 
 	/* This testpoint is after we signal readiness to the parent. */
 	if (testpoint(sessiond_thread_manage_clients)) {
@@ -4055,6 +4164,8 @@ static void usage(void)
 	fprintf(stderr, "      --no-kernel                    Disable kernel tracer\n");
 	fprintf(stderr, "      --jul-tcp-port                 JUL application registration TCP port\n");
 	fprintf(stderr, "  -f  --config                       Load daemon configuration file\n");
+	fprintf(stderr, "  -l  --load PATH                    Load session configuration\n");
+	fprintf(stderr, "      --kmod-probes                  Specify kernel module probes to load\n");
 }
 
 /*
@@ -4088,6 +4199,10 @@ static int set_option(int opt, const char *arg, const char *optname)
 		break;
 	case 'g':
 		tracing_group_name = strdup(arg);
+		if (!tracing_group_name) {
+			perror("strdup");
+			ret = -ENOMEM;
+		}
 		break;
 	case 'h':
 		usage();
@@ -4127,7 +4242,10 @@ static int set_option(int opt, const char *arg, const char *optname)
 		if (arg) {
 			lttng_opt_verbose = config_parse_value(arg);
 		} else {
-			lttng_opt_verbose += 1;
+			/* Only 3 level of verbosity (-vvv). */
+			if (lttng_opt_verbose < 3) {
+				lttng_opt_verbose += 1;
+			}
 		}
 		break;
 	case 'Z':
@@ -4139,22 +4257,42 @@ static int set_option(int opt, const char *arg, const char *optname)
 		break;
 	case 'u':
 		consumerd32_bin = strdup(arg);
+		if (!consumerd32_bin) {
+			perror("strdup");
+			ret = -ENOMEM;
+		}
 		consumerd32_bin_override = 1;
 		break;
 	case 'U':
 		consumerd32_libdir = strdup(arg);
+		if (!consumerd32_libdir) {
+			perror("strdup");
+			ret = -ENOMEM;
+		}
 		consumerd32_libdir_override = 1;
 		break;
 	case 't':
 		consumerd64_bin = strdup(arg);
+		if (!consumerd64_bin) {
+			perror("strdup");
+			ret = -ENOMEM;
+		}
 		consumerd64_bin_override = 1;
 		break;
 	case 'T':
 		consumerd64_libdir = strdup(arg);
+		if (!consumerd64_libdir) {
+			perror("strdup");
+			ret = -ENOMEM;
+		}
 		consumerd64_libdir_override = 1;
 		break;
 	case 'p':
 		opt_pidfile = strdup(arg);
+		if (!opt_pidfile) {
+			perror("strdup");
+			ret = -ENOMEM;
+		}
 		break;
 	case 'J': /* JUL TCP port. */
 	{
@@ -4174,6 +4312,23 @@ static int set_option(int opt, const char *arg, const char *optname)
 		DBG3("JUL TCP port set to non default: %u", jul_tcp_port);
 		break;
 	}
+	case 'l':
+		opt_load_session_path = strdup(arg);
+		if (!opt_load_session_path) {
+			perror("strdup");
+			ret = -ENOMEM;
+		}
+		break;
+	case 'P': /* probe modules list */
+		kmod_probes_list = strdup(arg);
+		if (!kmod_probes_list) {
+			perror("strdup");
+			ret = -ENOMEM;
+		}
+		break;
+	case 'f':
+		/* This is handled in set_options() thus silent break. */
+		break;
 	default:
 		/* Unknown option or other error.
 		 * Error is printed by getopt, just return */
@@ -4701,6 +4856,35 @@ error:
 	return;
 }
 
+/*
+ * Start the load session thread and dettach from it so the main thread can
+ * continue. This does not return a value since whatever the outcome, the main
+ * thread will continue.
+ */
+static void start_load_session_thread(void)
+{
+	int ret;
+
+	/* Create session loading thread. */
+	ret = pthread_create(&load_session_thread, NULL, thread_load_session,
+			load_info);
+	if (ret != 0) {
+		PERROR("pthread_create load_session_thread");
+		goto error_create;
+	}
+
+	ret = pthread_detach(load_session_thread);
+	if (ret != 0) {
+		PERROR("pthread_detach load_session_thread");
+	}
+
+	/* Everything went well so don't cleanup anything. */
+
+error_create:
+	/* The cleanup() function will destroy the load_info data. */
+	return;
+}
+
 /*
  * main
  */
@@ -5010,6 +5194,11 @@ int main(int argc, char **argv)
 	/* This is to get the TCP timeout value. */
 	lttcomm_inet_init();
 
+	if (load_session_init_data(&load_info) < 0) {
+		goto exit;
+	}
+	load_info->path = opt_load_session_path;
+
 	/*
 	 * Initialize the health check subsystem. This call should set the
 	 * appropriate time values.
@@ -5072,7 +5261,7 @@ int main(int argc, char **argv)
 	ret = pthread_create(&apps_notify_thread, NULL,
 			ust_thread_manage_notify, (void *) NULL);
 	if (ret != 0) {
-		PERROR("pthread_create apps");
+		PERROR("pthread_create notify");
 		goto exit_apps_notify;
 	}
 
@@ -5080,7 +5269,7 @@ int main(int argc, char **argv)
 	ret = pthread_create(&jul_reg_thread, NULL,
 			jul_thread_manage_registration, (void *) NULL);
 	if (ret != 0) {
-		PERROR("pthread_create apps");
+		PERROR("pthread_create JUL");
 		goto exit_jul_reg;
 	}
 
@@ -5093,7 +5282,12 @@ int main(int argc, char **argv)
 			PERROR("pthread_create kernel");
 			goto exit_kernel;
 		}
+	}
+
+	/* Load possible session(s). */
+	start_load_session_thread();
 
+	if (is_root && !opt_no_kernel) {
 		ret = pthread_join(kernel_thread, &status);
 		if (ret != 0) {
 			PERROR("pthread_join");