Send filter expression string to session daemon

[lttng-tools.git] / src / lib / lttng-ctl / lttng-ctl.c

diff --git a/src/lib/lttng-ctl/lttng-ctl.c b/src/lib/lttng-ctl/lttng-ctl.c
index 9a2160533ee909a5b5efb3c924d96b56484a99b0..8e2593db125acb4f30c0a7e7b076395b685682f3 100644 (file)
--- a/src/lib/lttng-ctl/lttng-ctl.c
+++ b/src/lib/lttng-ctl/lttng-ctl.c
@@ -520,6 +520,7 @@ int lttng_register_consumer(struct lttng_handle *handle,
                return -LTTNG_ERR_INVALID;
        }
 
+       memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_REGISTER_CONSUMER;
        lttng_ctl_copy_string(lsm.session.name, handle->session_name,
                        sizeof(lsm.session.name));
@@ -542,6 +543,7 @@ int lttng_start_tracing(const char *session_name)
                return -LTTNG_ERR_INVALID;
        }
 
+       memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_START_TRACE;
 
        lttng_ctl_copy_string(lsm.session.name, session_name,
@@ -562,6 +564,7 @@ static int _lttng_stop_tracing(const char *session_name, int wait)
                return -LTTNG_ERR_INVALID;
        }
 
+       memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_STOP_TRACE;
 
        lttng_ctl_copy_string(lsm.session.name, session_name,
@@ -733,23 +736,13 @@ int lttng_enable_event_with_exclusions(struct lttng_handle *handle,
                                sizeof(lsm.u.enable.channel_name));
        }
 
-       lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
-
-       /* figure out correct command type, based on if we have a filter or exclusions */
-       if (exclusion_count == 0) {
-               if (filter_expression == NULL) {
-                       if (ev->name[0] != '\0') {
-                               lsm.cmd_type = LTTNG_ENABLE_EVENT;
-                       } else {
-                               lsm.cmd_type = LTTNG_ENABLE_ALL_EVENT;
-                       }
-               } else {
-                       lsm.cmd_type = LTTNG_ENABLE_EVENT_WITH_FILTER;
-               }
+       if (ev->name[0] != '\0') {
+               lsm.cmd_type = LTTNG_ENABLE_EVENT;
        } else {
-               lsm.cmd_type = LTTNG_ENABLE_EVENT_WITH_EXCLUSION;
+               lsm.cmd_type = LTTNG_ENABLE_ALL_EVENT;
        }
 
+       lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
        memcpy(&lsm.u.enable.event, ev, sizeof(lsm.u.enable.event));
 
        lttng_ctl_copy_string(lsm.session.name, handle->session_name,
@@ -841,41 +834,43 @@ int lttng_enable_event_with_exclusions(struct lttng_handle *handle,
 
                lsm.u.enable.bytecode_len = sizeof(ctx->bytecode->b)
                                + bytecode_get_len(&ctx->bytecode->b);
-       }
-
-       /* Allocate variable length data */
-       if (lsm.u.enable.exclusion_count != 0) {
-               varlen_data = zmalloc(lsm.u.enable.bytecode_len
-                               + LTTNG_SYMBOL_NAME_LEN * exclusion_count);
-               if (!varlen_data) {
-                       ret = -LTTNG_ERR_EXCLUSION_NOMEM;
-                       goto varlen_alloc_error;
-               }
-               /* Put exclusion names first in the data */
-               while (exclusion_count--) {
-                       strncpy(varlen_data + LTTNG_SYMBOL_NAME_LEN * exclusion_count,
-                                       *(exclusion_list + exclusion_count),
-                                       LTTNG_SYMBOL_NAME_LEN);
-               }
-               /* Add filter bytecode next */
-               if (lsm.u.enable.bytecode_len != 0) {
-                       memcpy(varlen_data + LTTNG_SYMBOL_NAME_LEN * lsm.u.enable.exclusion_count,
-                                       &ctx->bytecode->b,
-                                       lsm.u.enable.bytecode_len);
-               }
-       } else {
-               /* no exclusions - use the already allocated filter bytecode */
-               varlen_data = (char *)(&ctx->bytecode->b);
+               lsm.u.enable.expression_len = strlen(filter_expression) + 1;
+       }
+
+       varlen_data = zmalloc(lsm.u.enable.bytecode_len
+                             + lsm.u.enable.expression_len
+                             + LTTNG_SYMBOL_NAME_LEN * exclusion_count);
+       if (!varlen_data) {
+               ret = -LTTNG_ERR_EXCLUSION_NOMEM;
+               goto varlen_alloc_error;
+       }
+       /* Put exclusion names first in the data */
+       while (exclusion_count--) {
+               strncpy(varlen_data + LTTNG_SYMBOL_NAME_LEN * exclusion_count,
+                       *(exclusion_list + exclusion_count),
+                       LTTNG_SYMBOL_NAME_LEN);
+       }
+       /* Add filter expression next */
+       if (lsm.u.enable.expression_len != 0) {
+               memcpy(varlen_data
+                       + LTTNG_SYMBOL_NAME_LEN * lsm.u.enable.exclusion_count,
+                       filter_expression,
+                       lsm.u.enable.expression_len);
+       }
+       /* Add filter bytecode next */
+       if (lsm.u.enable.bytecode_len != 0) {
+               memcpy(varlen_data
+                       + LTTNG_SYMBOL_NAME_LEN * lsm.u.enable.exclusion_count
+                       + lsm.u.enable.expression_len,
+                       &ctx->bytecode->b,
+                       lsm.u.enable.bytecode_len);
        }
 
        ret = lttng_ctl_ask_sessiond_varlen(&lsm, varlen_data,
-                       LTTNG_SYMBOL_NAME_LEN * lsm.u.enable.exclusion_count
-                                       + lsm.u.enable.bytecode_len,
+                       (LTTNG_SYMBOL_NAME_LEN * lsm.u.enable.exclusion_count) +
+                       lsm.u.enable.bytecode_len + lsm.u.enable.expression_len,
                        NULL);
-
-       if (lsm.u.enable.exclusion_count != 0) {
-               free(varlen_data);
-       }
+       free(varlen_data);
 
 varlen_alloc_error:
        if (filter_expression) {
@@ -1015,6 +1010,7 @@ int lttng_list_tracepoints(struct lttng_handle *handle,
                return -LTTNG_ERR_INVALID;
        }
 
+       memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_LIST_TRACEPOINTS;
        lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
 
@@ -1042,6 +1038,7 @@ int lttng_list_tracepoint_fields(struct lttng_handle *handle,
                return -LTTNG_ERR_INVALID;
        }
 
+       memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_LIST_TRACEPOINT_FIELDS;
        lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
 
@@ -1110,6 +1107,7 @@ int lttng_destroy_session(const char *session_name)
                return -LTTNG_ERR_INVALID;
        }
 
+       memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_DESTROY_SESSION;
 
        lttng_ctl_copy_string(lsm.session.name, session_name,
@@ -1129,6 +1127,7 @@ int lttng_list_sessions(struct lttng_session **sessions)
        int ret;
        struct lttcomm_session_msg lsm;
 
+       memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_LIST_SESSIONS;
        ret = lttng_ctl_ask_sessiond(&lsm, (void**) sessions);
        if (ret < 0) {
@@ -1154,6 +1153,7 @@ int lttng_list_domains(const char *session_name,
                return -LTTNG_ERR_INVALID;
        }
 
+       memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_LIST_DOMAINS;
 
        lttng_ctl_copy_string(lsm.session.name, session_name,
@@ -1183,6 +1183,7 @@ int lttng_list_channels(struct lttng_handle *handle,
                return -LTTNG_ERR_INVALID;
        }
 
+       memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_LIST_CHANNELS;
        lttng_ctl_copy_string(lsm.session.name, handle->session_name,
                        sizeof(lsm.session.name));
@@ -1214,6 +1215,7 @@ int lttng_list_events(struct lttng_handle *handle,
                return -LTTNG_ERR_INVALID;
        }
 
+       memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_LIST_EVENTS;
        lttng_ctl_copy_string(lsm.session.name, handle->session_name,
                        sizeof(lsm.session.name));
@@ -1261,6 +1263,7 @@ int lttng_calibrate(struct lttng_handle *handle,
                return -LTTNG_ERR_INVALID;
        }
 
+       memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_CALIBRATE;
        lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
 
@@ -1491,6 +1494,7 @@ int lttng_data_pending(const char *session_name)
                return -LTTNG_ERR_INVALID;
        }
 
+       memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_DATA_PENDING;
 
        lttng_ctl_copy_string(lsm.session.name, session_name,
@@ -1569,7 +1573,7 @@ int lttng_create_session_live(const char *name, const char *url,
        lttng_ctl_copy_string(lsm.session.name, name, sizeof(lsm.session.name));
 
        size = uri_parse_str_urls(url, NULL, &uris);
-       if (size < 0) {
+       if (size <= 0) {
                ret = -LTTNG_ERR_INVALID;
                goto end;
        }