Fix: don't quiet the consumer if opt_quiet is not set

[lttng-tools.git] / src / bin / lttng-sessiond / main.c

diff --git a/src/bin/lttng-sessiond/main.c b/src/bin/lttng-sessiond/main.c
index 659b2f67f00bf51c834adf41f88b0915cb4f8681..052e32e0c32ec2fb8bfe2a17e71afa0487ebf868 100644 (file)
--- a/src/bin/lttng-sessiond/main.c
+++ b/src/bin/lttng-sessiond/main.c
@@ -68,6 +68,7 @@
 #include "testpoint.h"
 #include "ust-thread.h"
 #include "jul-thread.h"
+#include "save.h"
 
 #define CONSUMERD_FILE "lttng-consumerd"
 
@@ -79,7 +80,6 @@ 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 pid_t ppid;          /* Parent PID for --sig-parent option */
 static pid_t child_ppid;    /* Internal parent PID use with daemonize. */
 static char *rundir;
@@ -205,8 +205,10 @@ static pthread_t jul_reg_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,6 +286,9 @@ 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";
 
 /*
@@ -2228,9 +2233,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 +2724,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 +2783,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:
@@ -3037,6 +3047,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 +3073,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 +3144,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 +3155,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 +3164,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 +3197,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 +3619,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;