From 15e376636cbda79bdd8a71d0a1bec892d9997738 Mon Sep 17 00:00:00 2001 From: =?utf8?q?J=C3=A9r=C3=A9mie=20Galarneau?= Date: Mon, 16 Oct 2017 15:40:42 -0400 Subject: [PATCH] lttng-ctl: send userspace probe location on enable_event MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Signed-off-by: Francis Deslauriers Signed-off-by: Jérémie Galarneau --- src/common/sessiond-comm/sessiond-comm.h | 6 +- src/lib/lttng-ctl/lttng-ctl.c | 104 +++++++++++++++-------- 2 files changed, 73 insertions(+), 37 deletions(-) diff --git a/src/common/sessiond-comm/sessiond-comm.h b/src/common/sessiond-comm/sessiond-comm.h index 2cd66f46f..62224bd75 100644 --- 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 197e52e8f..7df8d6de7 100644 --- a/src/lib/lttng-ctl/lttng-ctl.c +++ b/src/lib/lttng-ctl/lttng-ctl.c @@ -30,6 +30,7 @@ #include #include +#include #include #include #include @@ -41,6 +42,7 @@ #include #include #include +#include #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: -- 2.34.1