X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Flib%2Flttng-ctl%2Flttng-ctl.c;h=3863aa1ceb9de16836d4edc6c55d908fd289e08f;hp=6c8ad411a3ab7de446f8a8bdda20c4b552dad6b6;hb=5288612f2dc35805e861d0648bf75304c91bfeee;hpb=67ef15b7484912e08bcea1f68d8076b5b8772c12 diff --git a/src/lib/lttng-ctl/lttng-ctl.c b/src/lib/lttng-ctl/lttng-ctl.c index 6c8ad411a..3863aa1ce 100644 --- a/src/lib/lttng-ctl/lttng-ctl.c +++ b/src/lib/lttng-ctl/lttng-ctl.c @@ -32,12 +32,14 @@ #include #include #include +#include #include #include "filter/filter-ast.h" #include "filter/filter-parser.h" #include "filter/filter-bytecode.h" #include "filter/memstream.h" +#include "lttng-ctl-helper.h" #ifdef DEBUG static const int print_xml = 1; @@ -73,176 +75,11 @@ 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; -} - /* * Copy string from src to dst and enforce null terminated byte. */ -static void copy_string(char *dst, const char *src, size_t len) +LTTNG_HIDDEN +void lttng_ctl_copy_string(char *dst, const char *src, size_t len) { if (src && dst) { strncpy(dst, src, len); @@ -258,17 +95,14 @@ static void copy_string(char *dst, const char *src, size_t len) * * If domain is unknown, default domain will be the kernel. */ -static void copy_lttng_domain(struct lttng_domain *dst, struct lttng_domain *src) +LTTNG_HIDDEN +void lttng_ctl_copy_lttng_domain(struct lttng_domain *dst, + struct lttng_domain *src) { if (src && dst) { switch (src->type) { case LTTNG_DOMAIN_KERNEL: case LTTNG_DOMAIN_UST: - /* - case LTTNG_DOMAIN_UST_EXEC_NAME: - case LTTNG_DOMAIN_UST_PID: - case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN: - */ memcpy(dst, src, sizeof(struct lttng_domain)); break; default: @@ -463,8 +297,8 @@ static int set_session_daemon_path(void) } if ((uid == 0) || in_tgroup) { - copy_string(sessiond_sock_path, DEFAULT_GLOBAL_CLIENT_UNIX_SOCK, - sizeof(sessiond_sock_path)); + lttng_ctl_copy_string(sessiond_sock_path, + DEFAULT_GLOBAL_CLIENT_UNIX_SOCK, sizeof(sessiond_sock_path)); } if (uid != 0) { @@ -485,7 +319,7 @@ static int set_session_daemon_path(void) * With GNU C >= 2.1, snprintf returns the required size (excluding closing null) */ ret = snprintf(sessiond_sock_path, sizeof(sessiond_sock_path), - DEFAULT_HOME_CLIENT_UNIX_SOCK, getenv("HOME")); + DEFAULT_HOME_CLIENT_UNIX_SOCK, utils_get_home_dir()); if ((ret < 0) || (ret >= sizeof(sessiond_sock_path))) { goto error; } @@ -506,6 +340,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; @@ -549,7 +388,8 @@ static int disconnect_sessiond(void) * * Return size of data (only payload, not header) or a negative error code. */ -static int ask_sessiond_varlen(struct lttcomm_session_msg *lsm, +LTTNG_HIDDEN +int lttng_ctl_ask_sessiond_varlen(struct lttcomm_session_msg *lsm, void *vardata, size_t varlen, void **buf) { int ret; @@ -626,16 +466,6 @@ end: return ret; } -/* - * Ask the session daemon a specific command and put the data into buf. - * - * Return size of data (only payload, not header) or a negative error code. - */ -static int ask_sessiond(struct lttcomm_session_msg *lsm, void **buf) -{ - return ask_sessiond_varlen(lsm, NULL, 0, buf); -} - /* * Create lttng handle and return pointer. * The returned pointer will be NULL in case of malloc() error. @@ -656,11 +486,11 @@ struct lttng_handle *lttng_create_handle(const char *session_name, } /* Copy session name */ - copy_string(handle->session_name, session_name, + lttng_ctl_copy_string(handle->session_name, session_name, sizeof(handle->session_name)); /* Copy lttng domain */ - copy_lttng_domain(&handle->domain, domain); + lttng_ctl_copy_lttng_domain(&handle->domain, domain); end: return handle; @@ -688,13 +518,13 @@ int lttng_register_consumer(struct lttng_handle *handle, } lsm.cmd_type = LTTNG_REGISTER_CONSUMER; - copy_string(lsm.session.name, handle->session_name, + lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); - copy_lttng_domain(&lsm.domain, &handle->domain); + lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); - copy_string(lsm.u.reg.path, socket_path, sizeof(lsm.u.reg.path)); + lttng_ctl_copy_string(lsm.u.reg.path, socket_path, sizeof(lsm.u.reg.path)); - return ask_sessiond(&lsm, NULL); + return lttng_ctl_ask_sessiond(&lsm, NULL); } /* @@ -711,9 +541,10 @@ int lttng_start_tracing(const char *session_name) lsm.cmd_type = LTTNG_START_TRACE; - copy_string(lsm.session.name, session_name, sizeof(lsm.session.name)); + lttng_ctl_copy_string(lsm.session.name, session_name, + sizeof(lsm.session.name)); - return ask_sessiond(&lsm, NULL); + return lttng_ctl_ask_sessiond(&lsm, NULL); } /* @@ -730,9 +561,10 @@ static int _lttng_stop_tracing(const char *session_name, int wait) lsm.cmd_type = LTTNG_STOP_TRACE; - copy_string(lsm.session.name, session_name, sizeof(lsm.session.name)); + lttng_ctl_copy_string(lsm.session.name, session_name, + sizeof(lsm.session.name)); - ret = ask_sessiond(&lsm, NULL); + ret = lttng_ctl_ask_sessiond(&lsm, NULL); if (ret < 0 && ret != -LTTNG_ERR_TRACE_ALREADY_STOPPED) { goto error; } @@ -809,17 +641,17 @@ int lttng_add_context(struct lttng_handle *handle, lsm.cmd_type = LTTNG_ADD_CONTEXT; /* Copy channel name */ - copy_string(lsm.u.context.channel_name, channel_name, + lttng_ctl_copy_string(lsm.u.context.channel_name, channel_name, sizeof(lsm.u.context.channel_name)); - copy_lttng_domain(&lsm.domain, &handle->domain); + lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); memcpy(&lsm.u.context.ctx, ctx, sizeof(struct lttng_event_context)); - copy_string(lsm.session.name, handle->session_name, + lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); - return ask_sessiond(&lsm, NULL); + return lttng_ctl_ask_sessiond(&lsm, NULL); } /* @@ -841,14 +673,14 @@ int lttng_enable_event(struct lttng_handle *handle, /* If no channel name, we put the default name */ if (channel_name == NULL) { - copy_string(lsm.u.enable.channel_name, DEFAULT_CHANNEL_NAME, + lttng_ctl_copy_string(lsm.u.enable.channel_name, DEFAULT_CHANNEL_NAME, sizeof(lsm.u.enable.channel_name)); } else { - copy_string(lsm.u.enable.channel_name, channel_name, + lttng_ctl_copy_string(lsm.u.enable.channel_name, channel_name, sizeof(lsm.u.enable.channel_name)); } - copy_lttng_domain(&lsm.domain, &handle->domain); + lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); if (ev->name[0] != '\0') { lsm.cmd_type = LTTNG_ENABLE_EVENT; @@ -857,10 +689,10 @@ int lttng_enable_event(struct lttng_handle *handle, } memcpy(&lsm.u.enable.event, ev, sizeof(lsm.u.enable.event)); - copy_string(lsm.session.name, handle->session_name, + lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); - return ask_sessiond(&lsm, NULL); + return lttng_ctl_ask_sessiond(&lsm, NULL); } /* @@ -969,7 +801,7 @@ int lttng_enable_event_with_filter(struct lttng_handle *handle, lsm.cmd_type = LTTNG_ENABLE_EVENT_WITH_FILTER; /* Copy channel name */ - copy_string(lsm.u.enable.channel_name, channel_name, + lttng_ctl_copy_string(lsm.u.enable.channel_name, channel_name, sizeof(lsm.u.enable.channel_name)); /* Copy event name */ if (event) { @@ -979,12 +811,12 @@ int lttng_enable_event_with_filter(struct lttng_handle *handle, lsm.u.enable.bytecode_len = sizeof(ctx->bytecode->b) + bytecode_get_len(&ctx->bytecode->b); - copy_lttng_domain(&lsm.domain, &handle->domain); + lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); - copy_string(lsm.session.name, handle->session_name, + lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); - ret = ask_sessiond_varlen(&lsm, &ctx->bytecode->b, + ret = lttng_ctl_ask_sessiond_varlen(&lsm, &ctx->bytecode->b, lsm.u.enable.bytecode_len, NULL); filter_bytecode_free(ctx); @@ -1024,26 +856,27 @@ int lttng_disable_event(struct lttng_handle *handle, const char *name, memset(&lsm, 0, sizeof(lsm)); if (channel_name) { - copy_string(lsm.u.disable.channel_name, channel_name, + lttng_ctl_copy_string(lsm.u.disable.channel_name, channel_name, sizeof(lsm.u.disable.channel_name)); } else { - copy_string(lsm.u.disable.channel_name, DEFAULT_CHANNEL_NAME, + lttng_ctl_copy_string(lsm.u.disable.channel_name, DEFAULT_CHANNEL_NAME, sizeof(lsm.u.disable.channel_name)); } - copy_lttng_domain(&lsm.domain, &handle->domain); + lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); if (name != NULL) { - copy_string(lsm.u.disable.name, name, sizeof(lsm.u.disable.name)); + lttng_ctl_copy_string(lsm.u.disable.name, name, + sizeof(lsm.u.disable.name)); lsm.cmd_type = LTTNG_DISABLE_EVENT; } else { lsm.cmd_type = LTTNG_DISABLE_ALL_EVENT; } - copy_string(lsm.session.name, handle->session_name, + lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); - return ask_sessiond(&lsm, NULL); + return lttng_ctl_ask_sessiond(&lsm, NULL); } /* @@ -1068,12 +901,12 @@ int lttng_enable_channel(struct lttng_handle *handle, lsm.cmd_type = LTTNG_ENABLE_CHANNEL; - copy_lttng_domain(&lsm.domain, &handle->domain); + lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); - copy_string(lsm.session.name, handle->session_name, + lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); - return ask_sessiond(&lsm, NULL); + return lttng_ctl_ask_sessiond(&lsm, NULL); } /* @@ -1093,15 +926,15 @@ int lttng_disable_channel(struct lttng_handle *handle, const char *name) lsm.cmd_type = LTTNG_DISABLE_CHANNEL; - copy_string(lsm.u.disable.channel_name, name, + lttng_ctl_copy_string(lsm.u.disable.channel_name, name, sizeof(lsm.u.disable.channel_name)); - copy_lttng_domain(&lsm.domain, &handle->domain); + lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); - copy_string(lsm.session.name, handle->session_name, + lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); - return ask_sessiond(&lsm, NULL); + return lttng_ctl_ask_sessiond(&lsm, NULL); } /* @@ -1121,9 +954,9 @@ int lttng_list_tracepoints(struct lttng_handle *handle, } lsm.cmd_type = LTTNG_LIST_TRACEPOINTS; - copy_lttng_domain(&lsm.domain, &handle->domain); + lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); - ret = ask_sessiond(&lsm, (void **) events); + ret = lttng_ctl_ask_sessiond(&lsm, (void **) events); if (ret < 0) { return ret; } @@ -1148,9 +981,9 @@ int lttng_list_tracepoint_fields(struct lttng_handle *handle, } lsm.cmd_type = LTTNG_LIST_TRACEPOINT_FIELDS; - copy_lttng_domain(&lsm.domain, &handle->domain); + lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); - ret = ask_sessiond(&lsm, (void **) fields); + ret = lttng_ctl_ask_sessiond(&lsm, (void **) fields); if (ret < 0) { return ret; } @@ -1186,18 +1019,18 @@ int lttng_create_session(const char *name, const char *url) memset(&lsm, 0, sizeof(lsm)); lsm.cmd_type = LTTNG_CREATE_SESSION; - copy_string(lsm.session.name, name, sizeof(lsm.session.name)); + 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; } lsm.u.uri.size = size; - ret = ask_sessiond_varlen(&lsm, uris, sizeof(struct lttng_uri) * size, - NULL); + ret = lttng_ctl_ask_sessiond_varlen(&lsm, uris, + sizeof(struct lttng_uri) * size, NULL); free(uris); return ret; @@ -1217,9 +1050,10 @@ int lttng_destroy_session(const char *session_name) lsm.cmd_type = LTTNG_DESTROY_SESSION; - copy_string(lsm.session.name, session_name, sizeof(lsm.session.name)); + lttng_ctl_copy_string(lsm.session.name, session_name, + sizeof(lsm.session.name)); - return ask_sessiond(&lsm, NULL); + return lttng_ctl_ask_sessiond(&lsm, NULL); } /* @@ -1234,7 +1068,7 @@ int lttng_list_sessions(struct lttng_session **sessions) struct lttcomm_session_msg lsm; lsm.cmd_type = LTTNG_LIST_SESSIONS; - ret = ask_sessiond(&lsm, (void**) sessions); + ret = lttng_ctl_ask_sessiond(&lsm, (void**) sessions); if (ret < 0) { return ret; } @@ -1260,9 +1094,10 @@ int lttng_list_domains(const char *session_name, lsm.cmd_type = LTTNG_LIST_DOMAINS; - copy_string(lsm.session.name, session_name, sizeof(lsm.session.name)); + lttng_ctl_copy_string(lsm.session.name, session_name, + sizeof(lsm.session.name)); - ret = ask_sessiond(&lsm, (void**) domains); + ret = lttng_ctl_ask_sessiond(&lsm, (void**) domains); if (ret < 0) { return ret; } @@ -1287,12 +1122,12 @@ int lttng_list_channels(struct lttng_handle *handle, } lsm.cmd_type = LTTNG_LIST_CHANNELS; - copy_string(lsm.session.name, handle->session_name, + lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); - copy_lttng_domain(&lsm.domain, &handle->domain); + lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); - ret = ask_sessiond(&lsm, (void**) channels); + ret = lttng_ctl_ask_sessiond(&lsm, (void**) channels); if (ret < 0) { return ret; } @@ -1318,14 +1153,14 @@ int lttng_list_events(struct lttng_handle *handle, } lsm.cmd_type = LTTNG_LIST_EVENTS; - copy_string(lsm.session.name, handle->session_name, + lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); - copy_string(lsm.u.list.channel_name, channel_name, + lttng_ctl_copy_string(lsm.u.list.channel_name, channel_name, sizeof(lsm.u.list.channel_name)); - copy_lttng_domain(&lsm.domain, &handle->domain); + lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); - ret = ask_sessiond(&lsm, (void**) events); + ret = lttng_ctl_ask_sessiond(&lsm, (void**) events); if (ret < 0) { return ret; } @@ -1365,11 +1200,11 @@ int lttng_calibrate(struct lttng_handle *handle, } lsm.cmd_type = LTTNG_CALIBRATE; - copy_lttng_domain(&lsm.domain, &handle->domain); + lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); memcpy(&lsm.u.calibrate, calibrate, sizeof(lsm.u.calibrate)); - return ask_sessiond(&lsm, NULL); + return lttng_ctl_ask_sessiond(&lsm, NULL); } /* @@ -1478,19 +1313,19 @@ int lttng_set_consumer_url(struct lttng_handle *handle, lsm.cmd_type = LTTNG_SET_CONSUMER_URI; - copy_string(lsm.session.name, handle->session_name, + lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); - copy_lttng_domain(&lsm.domain, &handle->domain); + 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; } lsm.u.uri.size = size; - ret = ask_sessiond_varlen(&lsm, uris, sizeof(struct lttng_uri) * size, - NULL); + ret = lttng_ctl_ask_sessiond_varlen(&lsm, uris, + sizeof(struct lttng_uri) * size, NULL); free(uris); return ret; @@ -1532,8 +1367,8 @@ static int set_health_socket_path(void) } if ((uid == 0) || in_tgroup) { - copy_string(health_sock_path, DEFAULT_GLOBAL_HEALTH_UNIX_SOCK, - sizeof(health_sock_path)); + lttng_ctl_copy_string(health_sock_path, + DEFAULT_GLOBAL_HEALTH_UNIX_SOCK, sizeof(health_sock_path)); } if (uid != 0) { @@ -1543,7 +1378,7 @@ static int set_health_socket_path(void) * 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 = getenv("HOME"); + home = utils_get_home_dir(); if (home == NULL) { /* Fallback in /tmp .. */ home = "/tmp"; @@ -1636,17 +1471,17 @@ 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; } memset(&lsm, 0, sizeof(lsm)); lsm.cmd_type = LTTNG_CREATE_SESSION; - copy_string(lsm.session.name, name, sizeof(lsm.session.name)); + 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; @@ -1670,8 +1505,8 @@ int _lttng_create_session_ext(const char *name, const char *url, } } - ret = ask_sessiond_varlen(&lsm, uris, sizeof(struct lttng_uri) * size, - NULL); + ret = lttng_ctl_ask_sessiond_varlen(&lsm, uris, + sizeof(struct lttng_uri) * size, NULL); error: free(uris); @@ -1694,14 +1529,16 @@ int lttng_data_pending(const char *session_name) lsm.cmd_type = LTTNG_DATA_PENDING; - copy_string(lsm.session.name, session_name, sizeof(lsm.session.name)); + lttng_ctl_copy_string(lsm.session.name, session_name, + sizeof(lsm.session.name)); - ret = ask_sessiond(&lsm, NULL); + ret = lttng_ctl_ask_sessiond(&lsm, NULL); /* - * The ask_sessiond function negate the return code if it's not LTTNG_OK so - * getting -1 means that the reply ret_code was 1 thus meaning that the - * data is available. Yes it is hackish but for now this is the only way. + * The lttng_ctl_ask_sessiond function negate the return code if it's not + * LTTNG_OK so getting -1 means that the reply ret_code was 1 thus meaning + * that the data is available. Yes it is hackish but for now this is the + * only way. */ if (ret == -1) { ret = 1;