lttng-ctl: send userspace probe location on enable_event

Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>

diff --git a/src/common/sessiond-comm/sessiond-comm.h b/src/common/sessiond-comm/sessiond-comm.h
index 2cd66f46fc77abd46b15b94781f4f299329502c3..62224bd75db8cf24f5e3ece8739eed6a51b6363e 100644 (file)
--- a/src/common/sessiond-comm/sessiond-comm.h
+++ b/src/common/sessiond-comm/sessiond-comm.h
@@ -261,13 +261,15 @@ struct lttcomm_session_msg {
                        uint32_t expression_len;
                        /* Length of following bytecode for filter. */
                        uint32_t bytecode_len;
-                       /* exclusion data */
+                       /* Exclusion count (fixed-size strings). */
                        uint32_t exclusion_count;
+                       /* Userspace probe location size. */
+                       uint32_t userspace_probe_location_len;
                        /*
                         * After this structure, the following variable-length
                         * items are transmitted:
                         * - char exclusion_names[LTTNG_SYMBOL_NAME_LEN][exclusion_count]
-                        * - unsigned char filter_expression[expression_len]
+                        * - char filter_expression[expression_len]
                         * - unsigned char filter_bytecode[bytecode_len]
                         */
                } LTTNG_PACKED enable;

diff --git a/src/lib/lttng-ctl/lttng-ctl.c b/src/lib/lttng-ctl/lttng-ctl.c
index 197e52e8f7a1d6befe81a03ed07541a69c4dc631..7df8d6de7d2dae5f3da1c299fab160ec76d6808a 100644 (file)
--- a/src/lib/lttng-ctl/lttng-ctl.c
+++ b/src/lib/lttng-ctl/lttng-ctl.c
@@ -30,6 +30,7 @@
 #include <unistd.h>
 
 #include <common/common.h>
+#include <common/compat/string.h>
 #include <common/defaults.h>
 #include <common/sessiond-comm/sessiond-comm.h>
 #include <common/uri.h>
@@ -41,6 +42,7 @@
 #include <lttng/endpoint.h>
 #include <lttng/channel-internal.h>
 #include <lttng/event-internal.h>
+#include <lttng/userspace-probe-internal.h>
 
 #include "filter/filter-ast.h"
 #include "filter/filter-parser.h"
@@ -1026,8 +1028,9 @@ int lttng_enable_event_with_exclusions(struct lttng_handle *handle,
                int exclusion_count, char **exclusion_list)
 {
        struct lttcomm_session_msg lsm;
-       char *varlen_data;
-       int ret = 0;
+       struct lttng_dynamic_buffer send_buffer;
+       int ret = 0, i, fd_to_send = -1;
+       bool send_fd = false;
        unsigned int free_filter_expression = 0;
        struct filter_parser_ctx *ctx = NULL;
        /*
@@ -1078,22 +1081,11 @@ int lttng_enable_event_with_exclusions(struct lttng_handle *handle,
        lsm.u.enable.exclusion_count = exclusion_count;
        lsm.u.enable.bytecode_len = 0;
 
-       /*
-        * For the JUL domain, a filter is enforced except for the enable all
-        * event. This is done to avoid having the event in all sessions thus
-        * filtering by logger name.
-        */
-       if (exclusion_count == 0 && filter_expression == NULL &&
-                       (handle->domain.type != LTTNG_DOMAIN_JUL &&
-                               handle->domain.type != LTTNG_DOMAIN_LOG4J &&
-                               handle->domain.type != LTTNG_DOMAIN_PYTHON)) {
-               goto ask_sessiond;
-       }
-
        /*
         * We have either a filter or some exclusions, so we need to set up
         * a variable-length memory block from where to send the data.
         */
+       lttng_dynamic_buffer_init(&send_buffer);
 
        /* Parse filter expression. */
        if (filter_expression != NULL || handle->domain.type == LTTNG_DOMAIN_JUL
@@ -1131,41 +1123,82 @@ int lttng_enable_event_with_exclusions(struct lttng_handle *handle,
                }
        }
 
-       varlen_data = zmalloc(lsm.u.enable.bytecode_len
+       ret = lttng_dynamic_buffer_set_capacity(&send_buffer,
+                       lsm.u.enable.bytecode_len
                        + lsm.u.enable.expression_len
                        + LTTNG_SYMBOL_NAME_LEN * exclusion_count);
-       if (!varlen_data) {
+       if (ret) {
                ret = -LTTNG_ERR_EXCLUSION_NOMEM;
                goto mem_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 - 1);
+       for (i = 0; i < exclusion_count; i++) {
+               size_t exclusion_len;
+
+               exclusion_len = lttng_strnlen(*(exclusion_list + i),
+                               LTTNG_SYMBOL_NAME_LEN);
+               if (exclusion_len == LTTNG_SYMBOL_NAME_LEN) {
+                       /* Exclusion is not NULL-terminated. */
+                       ret = -LTTNG_ERR_INVALID;
+                       goto mem_error;
+               }
+
+               ret = lttng_dynamic_buffer_append(&send_buffer,
+                               *(exclusion_list + i),
+                               LTTNG_SYMBOL_NAME_LEN);
+               if (ret) {
+                       goto mem_error;
+               }
        }
+
        /* 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);
+       if (filter_expression) {
+               ret = lttng_dynamic_buffer_append(&send_buffer,
+                               filter_expression, lsm.u.enable.expression_len);
+               if (ret) {
+                       goto mem_error;
+               }
        }
        /* Add filter bytecode next. */
        if (ctx && 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_dynamic_buffer_append(&send_buffer,
+                               &ctx->bytecode->b, lsm.u.enable.bytecode_len);
+               if (ret) {
+                       goto mem_error;
+               }
        }
+       if (ev->extended.ptr) {
+               struct lttng_event_extended *ev_ext =
+                       (struct lttng_event_extended *) ev->extended.ptr;
+
+               if (ev_ext->probe_location) {
+                       /*
+                        * lttng_userspace_probe_location_serialize returns the
+                        * number of bytes that was appended to the buffer.
+                        */
+                       ret = lttng_userspace_probe_location_serialize(
+                               ev_ext->probe_location, &send_buffer,
+                               &fd_to_send);
+                       if (ret) {
+                               goto mem_error;
+                       }
 
-       ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header(&lsm, varlen_data,
-                       (LTTNG_SYMBOL_NAME_LEN * lsm.u.enable.exclusion_count) +
-                       lsm.u.enable.bytecode_len + lsm.u.enable.expression_len,
-                       NULL);
-       free(varlen_data);
+                       send_fd = fd_to_send >= 0;
+                       /*
+                        * Set the size of the userspace probe location element
+                        * of the buffer so that the receiving side knows where
+                        * to split it.
+                        */
+                       lsm.u.enable.userspace_probe_location_len = ret;
+               }
+       }
+
+       ret = lttng_ctl_ask_sessiond_fds_varlen(&lsm,
+                       send_fd ? &fd_to_send : NULL,
+                       send_fd ? 1 : 0,
+                       send_buffer.size ? send_buffer.data : NULL,
+                       send_buffer.size, NULL, NULL, 0);
 
 mem_error:
        if (filter_expression && ctx) {
@@ -1187,6 +1220,7 @@ error:
         * Return directly to the caller and don't ask the sessiond since
         * something went wrong in the parsing of data above.
         */
+       lttng_dynamic_buffer_reset(&send_buffer);
        return ret;
 
 ask_sessiond: