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));
return -LTTNG_ERR_INVALID;
}
+ memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_START_TRACE;
lttng_ctl_copy_string(lsm.session.name, session_name,
return -LTTNG_ERR_INVALID;
}
+ memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_STOP_TRACE;
lttng_ctl_copy_string(lsm.session.name, session_name,
goto end;
}
- _MSG("Waiting for data availability");
- fflush(stdout);
-
/* Check for data availability */
do {
data_ret = lttng_data_pending(session_name);
*/
if (data_ret) {
usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME);
- _MSG(".");
- fflush(stdout);
}
} while (data_ret != 0);
- MSG("");
-
end:
error:
return ret;
int lttng_enable_event(struct lttng_handle *handle,
struct lttng_event *ev, const char *channel_name)
{
- struct lttcomm_session_msg lsm;
-
- if (handle == NULL || ev == NULL) {
- return -LTTNG_ERR_INVALID;
- }
-
- memset(&lsm, 0, sizeof(lsm));
-
- /* If no channel name, send empty string. */
- if (channel_name == NULL) {
- lttng_ctl_copy_string(lsm.u.enable.channel_name, "",
- sizeof(lsm.u.enable.channel_name));
- } else {
- lttng_ctl_copy_string(lsm.u.enable.channel_name, channel_name,
- sizeof(lsm.u.enable.channel_name));
- }
-
- lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
-
- if (ev->name[0] != '\0') {
- lsm.cmd_type = LTTNG_ENABLE_EVENT;
- } else {
- lsm.cmd_type = LTTNG_ENABLE_ALL_EVENT;
- }
- memcpy(&lsm.u.enable.event, ev, sizeof(lsm.u.enable.event));
-
- lttng_ctl_copy_string(lsm.session.name, handle->session_name,
- sizeof(lsm.session.name));
-
- return lttng_ctl_ask_sessiond(&lsm, NULL);
+ return lttng_enable_event_with_exclusions(handle, ev, channel_name,
+ NULL, 0, NULL);
}
/*
struct lttng_event *event, const char *channel_name,
const char *filter_expression)
{
- struct lttcomm_session_msg lsm;
- struct filter_parser_ctx *ctx;
- FILE *fmem;
- int ret = 0;
+ return lttng_enable_event_with_exclusions(handle, event, channel_name,
+ filter_expression, 0, NULL);
+}
- if (!filter_expression) {
- /*
- * Fall back to normal event enabling if no filter
- * specified.
- */
- return lttng_enable_event(handle, event, channel_name);
- }
+/*
+ * Depending on the event, return a newly allocated JUL filter expression or
+ * NULL if not applicable.
+ *
+ * An event with NO loglevel and the name is * will return NULL.
+ */
+static char *set_jul_filter(const char *filter, struct lttng_event *ev)
+{
+ int err;
+ char *jul_filter = NULL;
- /*
- * Empty filter string will always be rejected by the parser
- * anyway, so treat this corner-case early to eliminate
- * lttng_fmemopen error for 0-byte allocation.
- */
- if (handle == NULL || filter_expression[0] == '\0') {
- return -LTTNG_ERR_INVALID;
- }
+ assert(ev);
- /*
- * casting const to non-const, as the underlying function will
- * use it in read-only mode.
- */
- fmem = lttng_fmemopen((void *) filter_expression,
- strlen(filter_expression), "r");
- if (!fmem) {
- fprintf(stderr, "Error opening memory as stream\n");
- return -LTTNG_ERR_FILTER_NOMEM;
- }
- ctx = filter_parser_ctx_alloc(fmem);
- if (!ctx) {
- fprintf(stderr, "Error allocating parser\n");
- ret = -LTTNG_ERR_FILTER_NOMEM;
- goto alloc_error;
- }
- ret = filter_parser_ctx_append_ast(ctx);
- if (ret) {
- fprintf(stderr, "Parse error\n");
- ret = -LTTNG_ERR_FILTER_INVAL;
- goto parse_error;
- }
- ret = filter_visitor_set_parent(ctx);
- if (ret) {
- fprintf(stderr, "Set parent error\n");
- ret = -LTTNG_ERR_FILTER_INVAL;
- goto parse_error;
- }
- if (print_xml) {
- ret = filter_visitor_print_xml(ctx, stdout, 0);
- if (ret) {
- fflush(stdout);
- fprintf(stderr, "XML print error\n");
- ret = -LTTNG_ERR_FILTER_INVAL;
- goto parse_error;
+ /* Don't add filter for the '*' event. */
+ if (ev->name[0] != '*') {
+ if (filter) {
+ err = asprintf(&jul_filter, "%s && logger_name == \"%s\"", filter,
+ ev->name);
+ } else {
+ err = asprintf(&jul_filter, "logger_name == \"%s\"", ev->name);
+ }
+ if (err < 0) {
+ PERROR("asprintf");
+ goto end;
}
}
- dbg_printf("Generating IR... ");
- fflush(stdout);
- ret = filter_visitor_ir_generate(ctx);
- if (ret) {
- fprintf(stderr, "Generate IR error\n");
- ret = -LTTNG_ERR_FILTER_INVAL;
- goto parse_error;
+ /* Add loglevel filtering if any for the JUL domain. */
+ if (ev->loglevel_type != LTTNG_EVENT_LOGLEVEL_ALL) {
+ char *op;
+
+ if (ev->loglevel_type == LTTNG_EVENT_LOGLEVEL_RANGE) {
+ op = ">=";
+ } else {
+ op = "==";
+ }
+
+ if (filter) {
+ err = asprintf(&jul_filter, "%s && int_loglevel %s %d", filter, op,
+ ev->loglevel);
+ } else {
+ err = asprintf(&jul_filter, "int_loglevel %s %d", op,
+ ev->loglevel);
+ }
+ if (err < 0) {
+ PERROR("asprintf");
+ free(jul_filter);
+ jul_filter = NULL;
+ goto end;
+ }
}
- dbg_printf("done\n");
- dbg_printf("Validating IR... ");
- fflush(stdout);
- ret = filter_visitor_ir_check_binary_op_nesting(ctx);
- if (ret) {
- ret = -LTTNG_ERR_FILTER_INVAL;
- goto parse_error;
+end:
+ return jul_filter;
+}
+
+/*
+ * Enable event(s) for a channel, possibly with exclusions and a filter.
+ * If no event name is specified, all events are enabled.
+ * If no channel name is specified, the default name is used.
+ * If filter expression is not NULL, the filter is set for the event.
+ * If exclusion count is not zero, the exclusions are set for the event.
+ * Returns size of returned session payload data or a negative error code.
+ */
+int lttng_enable_event_with_exclusions(struct lttng_handle *handle,
+ struct lttng_event *ev, const char *channel_name,
+ const char *filter_expression,
+ int exclusion_count, char **exclusion_list)
+{
+ struct lttcomm_session_msg lsm;
+ char *varlen_data, *jul_filter = NULL;
+ int ret = 0;
+ struct filter_parser_ctx *ctx = NULL;
+ FILE *fmem = NULL;
+
+ if (handle == NULL || ev == NULL) {
+ return -LTTNG_ERR_INVALID;
}
- dbg_printf("done\n");
- dbg_printf("Generating bytecode... ");
- fflush(stdout);
- ret = filter_visitor_bytecode_generate(ctx);
- if (ret) {
- fprintf(stderr, "Generate bytecode error\n");
- ret = -LTTNG_ERR_FILTER_INVAL;
- goto parse_error;
+ /* Empty filter string will always be rejected by the parser
+ * anyway, so treat this corner-case early to eliminate
+ * lttng_fmemopen error for 0-byte allocation.
+ */
+ if (filter_expression && filter_expression[0] == '\0') {
+ return -LTTNG_ERR_INVALID;
}
- dbg_printf("done\n");
- dbg_printf("Size of bytecode generated: %u bytes.\n",
- bytecode_get_len(&ctx->bytecode->b));
memset(&lsm, 0, sizeof(lsm));
- lsm.cmd_type = LTTNG_ENABLE_EVENT_WITH_FILTER;
-
/* If no channel name, send empty string. */
if (channel_name == NULL) {
lttng_ctl_copy_string(lsm.u.enable.channel_name, "",
sizeof(lsm.u.enable.channel_name));
}
- /* Copy event name */
- if (event) {
- memcpy(&lsm.u.enable.event, event, sizeof(lsm.u.enable.event));
+ if (ev->name[0] != '\0') {
+ lsm.cmd_type = LTTNG_ENABLE_EVENT;
+ } else {
+ lsm.cmd_type = LTTNG_ENABLE_ALL_EVENT;
}
- lsm.u.enable.bytecode_len = sizeof(ctx->bytecode->b)
- + bytecode_get_len(&ctx->bytecode->b);
-
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,
sizeof(lsm.session.name));
+ lsm.u.enable.exclusion_count = exclusion_count;
+ lsm.u.enable.bytecode_len = 0;
- ret = lttng_ctl_ask_sessiond_varlen(&lsm, &ctx->bytecode->b,
- lsm.u.enable.bytecode_len, NULL);
+ /*
+ * 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) {
+ goto ask_sessiond;
+ }
- filter_bytecode_free(ctx);
- filter_ir_free(ctx);
- filter_parser_ctx_free(ctx);
- if (fclose(fmem) != 0) {
- perror("fclose");
+ /*
+ * 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
+ */
+
+ /* Parse filter expression */
+ if (filter_expression != NULL || handle->domain.type == LTTNG_DOMAIN_JUL) {
+ if (handle->domain.type == LTTNG_DOMAIN_JUL) {
+ /* Setup JUL filter if needed. */
+ filter_expression = set_jul_filter(filter_expression, ev);
+ if (!filter_expression) {
+ goto ask_sessiond;
+ }
+ }
+
+ /*
+ * casting const to non-const, as the underlying function will
+ * use it in read-only mode.
+ */
+ fmem = lttng_fmemopen((void *) filter_expression,
+ strlen(filter_expression), "r");
+ if (!fmem) {
+ fprintf(stderr, "Error opening memory as stream\n");
+ free(jul_filter);
+ return -LTTNG_ERR_FILTER_NOMEM;
+ }
+ ctx = filter_parser_ctx_alloc(fmem);
+ if (!ctx) {
+ fprintf(stderr, "Error allocating parser\n");
+ ret = -LTTNG_ERR_FILTER_NOMEM;
+ goto filter_alloc_error;
+ }
+ ret = filter_parser_ctx_append_ast(ctx);
+ if (ret) {
+ fprintf(stderr, "Parse error\n");
+ ret = -LTTNG_ERR_FILTER_INVAL;
+ goto parse_error;
+ }
+ ret = filter_visitor_set_parent(ctx);
+ if (ret) {
+ fprintf(stderr, "Set parent error\n");
+ ret = -LTTNG_ERR_FILTER_INVAL;
+ goto parse_error;
+ }
+ if (print_xml) {
+ ret = filter_visitor_print_xml(ctx, stdout, 0);
+ if (ret) {
+ fflush(stdout);
+ fprintf(stderr, "XML print error\n");
+ ret = -LTTNG_ERR_FILTER_INVAL;
+ goto parse_error;
+ }
+ }
+
+ dbg_printf("Generating IR... ");
+ fflush(stdout);
+ ret = filter_visitor_ir_generate(ctx);
+ if (ret) {
+ fprintf(stderr, "Generate IR error\n");
+ ret = -LTTNG_ERR_FILTER_INVAL;
+ goto parse_error;
+ }
+ dbg_printf("done\n");
+
+ dbg_printf("Validating IR... ");
+ fflush(stdout);
+ ret = filter_visitor_ir_check_binary_op_nesting(ctx);
+ if (ret) {
+ ret = -LTTNG_ERR_FILTER_INVAL;
+ goto parse_error;
+ }
+ dbg_printf("done\n");
+
+ dbg_printf("Generating bytecode... ");
+ fflush(stdout);
+ ret = filter_visitor_bytecode_generate(ctx);
+ if (ret) {
+ fprintf(stderr, "Generate bytecode error\n");
+ ret = -LTTNG_ERR_FILTER_INVAL;
+ goto parse_error;
+ }
+ dbg_printf("done\n");
+ dbg_printf("Size of bytecode generated: %u bytes.\n",
+ bytecode_get_len(&ctx->bytecode->b));
+
+ lsm.u.enable.bytecode_len = sizeof(ctx->bytecode->b)
+ + bytecode_get_len(&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 + lsm.u.enable.expression_len,
+ NULL);
+ free(varlen_data);
+
+varlen_alloc_error:
+ if (filter_expression) {
+ filter_bytecode_free(ctx);
+ filter_ir_free(ctx);
+ filter_parser_ctx_free(ctx);
+ if (fclose(fmem) != 0) {
+ perror("fclose");
+ }
}
+ free(jul_filter);
return ret;
parse_error:
filter_bytecode_free(ctx);
filter_ir_free(ctx);
filter_parser_ctx_free(ctx);
-alloc_error:
+filter_alloc_error:
if (fclose(fmem) != 0) {
perror("fclose");
}
+ free(jul_filter);
+ return ret;
+
+ask_sessiond:
+ ret = lttng_ctl_ask_sessiond(&lsm, NULL);
return ret;
}
return -LTTNG_ERR_INVALID;
}
+ memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_LIST_TRACEPOINTS;
lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
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);
return -LTTNG_ERR_INVALID;
}
+ memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_DESTROY_SESSION;
lttng_ctl_copy_string(lsm.session.name, session_name,
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) {
return -LTTNG_ERR_INVALID;
}
+ memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_LIST_DOMAINS;
lttng_ctl_copy_string(lsm.session.name, session_name,
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));
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));
return -LTTNG_ERR_INVALID;
}
+ memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_CALIBRATE;
lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
return -LTTNG_ERR_INVALID;
}
+ memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_DATA_PENDING;
lttng_ctl_copy_string(lsm.session.name, session_name,
lsm.cmd_type = LTTNG_CREATE_SESSION_LIVE;
lttng_ctl_copy_string(lsm.session.name, name, sizeof(lsm.session.name));
- size = uri_parse_str_urls(url, NULL, &uris);
- if (size < 0) {
- ret = -LTTNG_ERR_INVALID;
- goto end;
- }
+ if (url) {
+ size = uri_parse_str_urls(url, NULL, &uris);
+ if (size <= 0) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
- /* file:// is not accepted for live session. */
- if (uris[0].dtype == LTTNG_DST_PATH) {
- ret = -LTTNG_ERR_INVALID;
- goto end;
+ /* file:// is not accepted for live session. */
+ if (uris[0].dtype == LTTNG_DST_PATH) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
+ } else {
+ size = 0;
}
lsm.u.session_live.nb_uri = size;
projects / lttng-tools.git / blobdiff