X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Flib%2Flttng-ctl%2Flttng-ctl.c;h=536d41baa2bc4848b334405afa598a210dc5422e;hp=5811d84df29078889f1dc31061ca1a1aa833e5ad;hb=c7e35b037773dbbfe10178c946ba44feefb226e1;hpb=cac3069d663ba0887b2abf4f114974ae3c0feb91 diff --git a/src/lib/lttng-ctl/lttng-ctl.c b/src/lib/lttng-ctl/lttng-ctl.c index 5811d84df..536d41baa 100644 --- a/src/lib/lttng-ctl/lttng-ctl.c +++ b/src/lib/lttng-ctl/lttng-ctl.c @@ -34,6 +34,7 @@ #include #include #include +#include #include "filter/filter-ast.h" #include "filter/filter-parser.h" @@ -59,7 +60,6 @@ do { \ /* Socket to session daemon for communication */ static int sessiond_socket; static char sessiond_sock_path[PATH_MAX]; -static char health_sock_path[PATH_MAX]; /* Variables */ static char *tracing_group; @@ -74,172 +74,7 @@ static int connected; */ int lttng_opt_quiet; int lttng_opt_verbose; - -/* - * Compare two URL destination. - * - * Return 0 is equal else is not equal. - */ -static int compare_destination(struct lttng_uri *ctrl, struct lttng_uri *data) -{ - int ret; - - assert(ctrl); - assert(data); - - switch (ctrl->dtype) { - case LTTNG_DST_IPV4: - ret = strncmp(ctrl->dst.ipv4, data->dst.ipv4, sizeof(ctrl->dst.ipv4)); - break; - case LTTNG_DST_IPV6: - ret = strncmp(ctrl->dst.ipv6, data->dst.ipv6, sizeof(ctrl->dst.ipv6)); - break; - default: - ret = -1; - break; - } - - return ret; -} - -static void set_default_url_attr(struct lttng_uri *uri, - enum lttng_stream_type stype) -{ - uri->stype = stype; - if (uri->dtype != LTTNG_DST_PATH && uri->port == 0) { - uri->port = (stype == LTTNG_STREAM_CONTROL) ? - DEFAULT_NETWORK_CONTROL_PORT : DEFAULT_NETWORK_DATA_PORT; - } -} - -/* - * Parse a string URL and creates URI(s) returning the size of the populated - * array. - */ -static ssize_t parse_str_urls_to_uri(const char *ctrl_url, const char *data_url, - struct lttng_uri **uris) -{ - unsigned int equal = 1, idx = 0; - /* Add the "file://" size to the URL maximum size */ - char url[PATH_MAX + 7]; - ssize_t size_ctrl = 0, size_data = 0, size; - struct lttng_uri *ctrl_uris = NULL, *data_uris = NULL; - struct lttng_uri *tmp_uris = NULL; - - /* No URL(s) is allowed. This means that the consumer will be disabled. */ - if (ctrl_url == NULL && data_url == NULL) { - return 0; - } - - /* Check if URLs are equal and if so, only use the control URL */ - if (ctrl_url && data_url) { - equal = !strcmp(ctrl_url, data_url); - } - - /* - * Since we allow the str_url to be a full local filesystem path, we are - * going to create a valid file:// URL if it's the case. - * - * Check if first character is a '/' or else reject the URL. - */ - if (ctrl_url && ctrl_url[0] == '/') { - int ret; - - ret = snprintf(url, sizeof(url), "file://%s", ctrl_url); - if (ret < 0) { - PERROR("snprintf file url"); - goto parse_error; - } - ctrl_url = url; - } - - /* Parse the control URL if there is one */ - if (ctrl_url) { - size_ctrl = uri_parse(ctrl_url, &ctrl_uris); - if (size_ctrl < 1) { - ERR("Unable to parse the URL %s", ctrl_url); - goto parse_error; - } - - /* At this point, we know there is at least one URI in the array */ - set_default_url_attr(&ctrl_uris[0], LTTNG_STREAM_CONTROL); - - if (ctrl_uris[0].dtype == LTTNG_DST_PATH && data_url) { - ERR("Can not have a data URL when destination is file://"); - goto error; - } - - /* URL are not equal but the control URL uses a net:// protocol */ - if (size_ctrl == 2) { - if (!equal) { - ERR("Control URL uses the net:// protocol and the data URL is " - "different. Not allowed."); - goto error; - } else { - set_default_url_attr(&ctrl_uris[1], LTTNG_STREAM_DATA); - /* - * The data_url and ctrl_url are equal and the ctrl_url - * contains a net:// protocol so we just skip the data part. - */ - data_url = NULL; - } - } - } - - if (data_url) { - int ret; - - /* We have to parse the data URL in this case */ - size_data = uri_parse(data_url, &data_uris); - if (size_data < 1) { - ERR("Unable to parse the URL %s", data_url); - goto error; - } else if (size_data == 2) { - ERR("Data URL can not be set with the net[4|6]:// protocol"); - goto error; - } - - set_default_url_attr(&data_uris[0], LTTNG_STREAM_DATA); - - ret = compare_destination(&ctrl_uris[0], &data_uris[0]); - if (ret != 0) { - ERR("Control and data destination mismatch"); - goto error; - } - } - - /* Compute total size */ - size = size_ctrl + size_data; - - tmp_uris = zmalloc(sizeof(struct lttng_uri) * size); - if (tmp_uris == NULL) { - PERROR("zmalloc uris"); - goto error; - } - - if (ctrl_uris) { - /* It's possible the control URIs array contains more than one URI */ - memcpy(tmp_uris, ctrl_uris, sizeof(struct lttng_uri) * size_ctrl); - ++idx; - free(ctrl_uris); - } - - if (data_uris) { - memcpy(&tmp_uris[idx], data_uris, sizeof(struct lttng_uri)); - free(data_uris); - } - - *uris = tmp_uris; - - return size; - -error: - free(ctrl_uris); - free(data_uris); - free(tmp_uris); -parse_error: - return -1; -} +int lttng_opt_mi; /* * Copy string from src to dst and enforce null terminated byte. @@ -269,6 +104,7 @@ void lttng_ctl_copy_lttng_domain(struct lttng_domain *dst, switch (src->type) { case LTTNG_DOMAIN_KERNEL: case LTTNG_DOMAIN_UST: + case LTTNG_DOMAIN_JUL: memcpy(dst, src, sizeof(struct lttng_domain)); break; default: @@ -363,12 +199,14 @@ end: * * If yes return 1, else return -1. */ -static int check_tracing_group(const char *grp_name) +LTTNG_HIDDEN +int lttng_check_tracing_group(void) { struct group *grp_tracing; /* no free(). See getgrnam(3) */ gid_t *grp_list; int grp_list_size, grp_id, i; int ret = -1; + const char *grp_name = tracing_group; /* Get GID of group 'tracing' */ grp_tracing = getgrnam(grp_name); @@ -459,7 +297,7 @@ static int set_session_daemon_path(void) if (uid != 0) { /* Are we in the tracing group ? */ - in_tgroup = check_tracing_group(tracing_group); + in_tgroup = lttng_check_tracing_group(); } if ((uid == 0) || in_tgroup) { @@ -506,6 +344,11 @@ static int connect_sessiond(void) { int ret; + /* Don't try to connect if already connected. */ + if (connected) { + return 0; + } + ret = set_session_daemon_path(); if (ret < 0) { goto error; @@ -678,6 +521,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)); @@ -700,6 +544,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, @@ -720,6 +565,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, @@ -734,8 +580,6 @@ static int _lttng_stop_tracing(const char *session_name, int wait) goto end; } - _MSG("Waiting for data availability"); - /* Check for data availability */ do { data_ret = lttng_data_pending(session_name); @@ -751,12 +595,9 @@ static int _lttng_stop_tracing(const char *session_name, int wait) */ if (data_ret) { usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME); - _MSG("."); } } while (data_ret != 0); - MSG(""); - end: error: return ret; @@ -801,9 +642,14 @@ int lttng_add_context(struct lttng_handle *handle, lsm.cmd_type = LTTNG_ADD_CONTEXT; - /* Copy channel name */ - lttng_ctl_copy_string(lsm.u.context.channel_name, channel_name, - sizeof(lsm.u.context.channel_name)); + /* If no channel name, send empty string. */ + if (channel_name == NULL) { + lttng_ctl_copy_string(lsm.u.context.channel_name, "", + sizeof(lsm.u.context.channel_name)); + } else { + lttng_ctl_copy_string(lsm.u.context.channel_name, channel_name, + sizeof(lsm.u.context.channel_name)); + } lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); @@ -824,36 +670,8 @@ int lttng_add_context(struct lttng_handle *handle, 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, we put the default name */ - if (channel_name == NULL) { - lttng_ctl_copy_string(lsm.u.enable.channel_name, DEFAULT_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); } /* @@ -866,43 +684,107 @@ int lttng_enable_event_with_filter(struct lttng_handle *handle, 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; + + assert(ev); + + /* 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 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 (handle == NULL || filter_expression[0] == '\0') { - return -LTTNG_ERR_INVALID; + /* 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 || jul_filter) { + char *new_filter; + + err = asprintf(&new_filter, "%s && int_loglevel %s %d", + jul_filter ? jul_filter : filter, op, + ev->loglevel); + if (jul_filter) { + free(jul_filter); + } + jul_filter = new_filter; + } else { + err = asprintf(&jul_filter, "int_loglevel %s %d", op, + ev->loglevel); + } + if (err < 0) { + PERROR("asprintf"); + goto error; + } } + return jul_filter; +error: + free(jul_filter); + return NULL; +} + +/* + * Generate the filter bytecode from a give filter expression string. Put the + * newly allocated parser context in ctxp and populate the lsm object with the + * expression len. + * + * Return 0 on success else a LTTNG_ERR_* code and ctxp is untouched. + */ +static int generate_filter(char *filter_expression, + struct lttcomm_session_msg *lsm, struct filter_parser_ctx **ctxp) +{ + int ret; + struct filter_parser_ctx *ctx = NULL; + FILE *fmem = NULL; + + assert(filter_expression); + assert(lsm); + assert(ctxp); + /* - * casting const to non-const, as the underlying function will - * use it in read-only mode. + * 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; + ret = -LTTNG_ERR_FILTER_NOMEM; + goto error; } ctx = filter_parser_ctx_alloc(fmem); if (!ctx) { fprintf(stderr, "Error allocating parser\n"); ret = -LTTNG_ERR_FILTER_NOMEM; - goto alloc_error; + goto filter_alloc_error; } ret = filter_parser_ctx_append_ast(ctx); if (ret) { @@ -955,47 +837,195 @@ int lttng_enable_event_with_filter(struct lttng_handle *handle, } dbg_printf("done\n"); dbg_printf("Size of bytecode generated: %u bytes.\n", - bytecode_get_len(&ctx->bytecode->b)); + bytecode_get_len(&ctx->bytecode->b)); - memset(&lsm, 0, sizeof(lsm)); + lsm->u.enable.bytecode_len = sizeof(ctx->bytecode->b) + + bytecode_get_len(&ctx->bytecode->b); + lsm->u.enable.expression_len = strlen(filter_expression) + 1; + + /* No need to keep the memory stream. */ + if (fclose(fmem) != 0) { + perror("fclose"); + } + + *ctxp = ctx; + return 0; + +parse_error: + filter_ir_free(ctx); + filter_parser_ctx_free(ctx); +filter_alloc_error: + if (fclose(fmem) != 0) { + perror("fclose"); + } +error: + return ret; +} + +/* + * 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 *original_filter_expression, + int exclusion_count, char **exclusion_list) +{ + struct lttcomm_session_msg lsm; + char *varlen_data; + int ret = 0; + unsigned int free_filter_expression = 0; + struct filter_parser_ctx *ctx = NULL; + /* + * Cast as non-const since we may replace the filter expression + * by a dynamically allocated string. Otherwise, the original + * string is not modified. + */ + char *filter_expression = (char *) original_filter_expression; + + if (handle == NULL || ev == NULL) { + ret = -LTTNG_ERR_INVALID; + goto 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') { + ret = -LTTNG_ERR_INVALID; + goto error; + } - lsm.cmd_type = LTTNG_ENABLE_EVENT_WITH_FILTER; + memset(&lsm, 0, sizeof(lsm)); - /* Copy channel name */ - lttng_ctl_copy_string(lsm.u.enable.channel_name, 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 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)); } - lsm.u.enable.bytecode_len = sizeof(ctx->bytecode->b) - + bytecode_get_len(&ctx->bytecode->b); + if (ev->name[0] != '\0') { + lsm.cmd_type = LTTNG_ENABLE_EVENT; + } else { + 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, sizeof(lsm.session.name)); + 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) { + goto ask_sessiond; + } - ret = lttng_ctl_ask_sessiond_varlen(&lsm, &ctx->bytecode->b, - lsm.u.enable.bytecode_len, NULL); + /* + * 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 + */ - filter_bytecode_free(ctx); - filter_ir_free(ctx); - filter_parser_ctx_free(ctx); - if (fclose(fmem) != 0) { - perror("fclose"); + /* Parse filter expression */ + if (filter_expression != NULL || handle->domain.type == LTTNG_DOMAIN_JUL) { + if (handle->domain.type == LTTNG_DOMAIN_JUL) { + char *jul_filter; + + /* Setup JUL filter if needed. */ + jul_filter = set_jul_filter(filter_expression, ev); + if (!jul_filter) { + if (!filter_expression) { + /* No JUL and no filter, just skip everything below. */ + goto ask_sessiond; + } + } else { + /* + * With a JUL filter, the original filter has been added to it + * thus replace the filter expression. + */ + filter_expression = jul_filter; + free_filter_expression = 1; + } + } + + ret = generate_filter(filter_expression, &lsm, &ctx); + if (ret) { + goto filter_error; + } } - return ret; -parse_error: - filter_bytecode_free(ctx); - filter_ir_free(ctx); - filter_parser_ctx_free(ctx); -alloc_error: - if (fclose(fmem) != 0) { - perror("fclose"); + 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 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); + } + /* 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 (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_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); + +mem_error: + if (filter_expression && ctx) { + filter_bytecode_free(ctx); + filter_ir_free(ctx); + filter_parser_ctx_free(ctx); + } +filter_error: + if (free_filter_expression) { + /* + * The filter expression has been replaced and must be freed as it is + * not the original filter expression received as a parameter. + */ + free(filter_expression); } +error: + /* + * Return directly to the caller and don't ask the sessiond since something + * went wrong in the parsing of data above. + */ + return ret; + +ask_sessiond: + ret = lttng_ctl_ask_sessiond(&lsm, NULL); return ret; } @@ -1016,11 +1046,12 @@ int lttng_disable_event(struct lttng_handle *handle, const char *name, memset(&lsm, 0, sizeof(lsm)); - if (channel_name) { - lttng_ctl_copy_string(lsm.u.disable.channel_name, channel_name, + /* If no channel name, send empty string. */ + if (channel_name == NULL) { + lttng_ctl_copy_string(lsm.u.disable.channel_name, "", sizeof(lsm.u.disable.channel_name)); } else { - lttng_ctl_copy_string(lsm.u.disable.channel_name, DEFAULT_CHANNEL_NAME, + lttng_ctl_copy_string(lsm.u.disable.channel_name, channel_name, sizeof(lsm.u.disable.channel_name)); } @@ -1114,6 +1145,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); @@ -1141,6 +1173,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); @@ -1183,7 +1216,7 @@ int lttng_create_session(const char *name, const char *url) lttng_ctl_copy_string(lsm.session.name, name, sizeof(lsm.session.name)); /* There should never be a data URL */ - size = parse_str_urls_to_uri(url, NULL, &uris); + size = uri_parse_str_urls(url, NULL, &uris); if (size < 0) { return -LTTNG_ERR_INVALID; } @@ -1209,6 +1242,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, @@ -1228,6 +1262,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) { @@ -1253,6 +1288,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, @@ -1282,6 +1318,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)); @@ -1313,6 +1350,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)); @@ -1360,6 +1398,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); @@ -1478,7 +1517,7 @@ int lttng_set_consumer_url(struct lttng_handle *handle, sizeof(lsm.session.name)); lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); - size = parse_str_urls_to_uri(control_url, data_url, &uris); + size = uri_parse_str_urls(control_url, data_url, &uris); if (size < 0) { return -LTTNG_ERR_INVALID; } @@ -1508,104 +1547,6 @@ int lttng_disable_consumer(struct lttng_handle *handle) return -ENOSYS; } -/* - * Set health socket path by putting it in the global health_sock_path - * variable. - * - * Returns 0 on success or assert(0) on ENOMEM. - */ -static int set_health_socket_path(void) -{ - int in_tgroup = 0; /* In tracing group */ - uid_t uid; - const char *home; - - uid = getuid(); - - if (uid != 0) { - /* Are we in the tracing group ? */ - in_tgroup = check_tracing_group(tracing_group); - } - - if ((uid == 0) || in_tgroup) { - lttng_ctl_copy_string(health_sock_path, - DEFAULT_GLOBAL_HEALTH_UNIX_SOCK, sizeof(health_sock_path)); - } - - if (uid != 0) { - int ret; - - /* - * With GNU C < 2.1, snprintf returns -1 if the target buffer is too small; - * With GNU C >= 2.1, snprintf returns the required size (excluding closing null) - */ - home = utils_get_home_dir(); - if (home == NULL) { - /* Fallback in /tmp .. */ - home = "/tmp"; - } - - ret = snprintf(health_sock_path, sizeof(health_sock_path), - DEFAULT_HOME_HEALTH_UNIX_SOCK, home); - if ((ret < 0) || (ret >= sizeof(health_sock_path))) { - /* ENOMEM at this point... just kill the control lib. */ - assert(0); - } - } - - return 0; -} - -/* - * Check session daemon health for a specific health component. - * - * Return 0 if health is OK or else 1 if BAD. - * - * Any other negative value is a lttng error code which can be translated with - * lttng_strerror(). - */ -int lttng_health_check(enum lttng_health_component c) -{ - int sock, ret; - struct lttcomm_health_msg msg; - struct lttcomm_health_data reply; - - /* Connect to the sesssion daemon */ - sock = lttcomm_connect_unix_sock(health_sock_path); - if (sock < 0) { - ret = -LTTNG_ERR_NO_SESSIOND; - goto error; - } - - msg.cmd = LTTNG_HEALTH_CHECK; - msg.component = c; - - ret = lttcomm_send_unix_sock(sock, (void *)&msg, sizeof(msg)); - if (ret < 0) { - ret = -LTTNG_ERR_FATAL; - goto close_error; - } - - ret = lttcomm_recv_unix_sock(sock, (void *)&reply, sizeof(reply)); - if (ret < 0) { - ret = -LTTNG_ERR_FATAL; - goto close_error; - } - - ret = reply.ret_code; - -close_error: - { - int closeret; - - closeret = close(sock); - assert(!closeret); - } - -error: - return ret; -} - /* * This is an extension of create session that is ONLY and SHOULD only be used * by the lttng command line program. It exists to avoid using URI parsing in @@ -1632,7 +1573,7 @@ int _lttng_create_session_ext(const char *name, const char *url, struct lttcomm_session_msg lsm; struct lttng_uri *uris = NULL; - if (name == NULL || datetime == NULL || url == NULL) { + if (name == NULL || datetime == NULL) { return -LTTNG_ERR_INVALID; } @@ -1642,7 +1583,7 @@ int _lttng_create_session_ext(const char *name, const char *url, lttng_ctl_copy_string(lsm.session.name, name, sizeof(lsm.session.name)); /* There should never be a data URL */ - size = parse_str_urls_to_uri(url, NULL, &uris); + size = uri_parse_str_urls(url, NULL, &uris); if (size < 0) { ret = -LTTNG_ERR_INVALID; goto error; @@ -1688,6 +1629,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, @@ -1708,6 +1650,90 @@ int lttng_data_pending(const char *session_name) return ret; } +/* + * Create a session exclusively used for snapshot. + * + * Returns LTTNG_OK on success or a negative error code. + */ +int lttng_create_session_snapshot(const char *name, const char *snapshot_url) +{ + int ret; + ssize_t size; + struct lttcomm_session_msg lsm; + struct lttng_uri *uris = NULL; + + if (name == NULL) { + return -LTTNG_ERR_INVALID; + } + + memset(&lsm, 0, sizeof(lsm)); + + lsm.cmd_type = LTTNG_CREATE_SESSION_SNAPSHOT; + lttng_ctl_copy_string(lsm.session.name, name, sizeof(lsm.session.name)); + + size = uri_parse_str_urls(snapshot_url, NULL, &uris); + if (size < 0) { + return -LTTNG_ERR_INVALID; + } + + lsm.u.uri.size = size; + + ret = lttng_ctl_ask_sessiond_varlen(&lsm, uris, + sizeof(struct lttng_uri) * size, NULL); + + free(uris); + return ret; +} + +/* + * Create a session exclusively used for live. + * + * Returns LTTNG_OK on success or a negative error code. + */ +int lttng_create_session_live(const char *name, const char *url, + unsigned int timer_interval) +{ + int ret; + ssize_t size; + struct lttcomm_session_msg lsm; + struct lttng_uri *uris = NULL; + + if (name == NULL) { + return -LTTNG_ERR_INVALID; + } + + memset(&lsm, 0, sizeof(lsm)); + + lsm.cmd_type = LTTNG_CREATE_SESSION_LIVE; + lttng_ctl_copy_string(lsm.session.name, name, sizeof(lsm.session.name)); + + 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; + } + } else { + size = 0; + } + + lsm.u.session_live.nb_uri = size; + lsm.u.session_live.timer_interval = timer_interval; + + ret = lttng_ctl_ask_sessiond_varlen(&lsm, uris, + sizeof(struct lttng_uri) * size, NULL); + +end: + free(uris); + return ret; +} + /* * lib constructor */ @@ -1715,8 +1741,6 @@ static void __attribute__((constructor)) init() { /* Set default session group */ lttng_set_tracing_group(DEFAULT_TRACING_GROUP); - /* Set socket for health check */ - (void) set_health_socket_path(); } /*