X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Flib%2Flttng-ctl%2Flttng-ctl.c;h=c9fb293be1ed74411d20238ec7f94663a613041e;hp=ba0c4c8269a301d31c0183c02592f0d77e363b8e;hb=18eace3ba4aeaa6b869c8ad9ec1273381b4cbdee;hpb=95b9bd903e097fa120f5815604d6765f7b0f2596 diff --git a/src/lib/lttng-ctl/lttng-ctl.c b/src/lib/lttng-ctl/lttng-ctl.c index ba0c4c826..c9fb293be 100644 --- a/src/lib/lttng-ctl/lttng-ctl.c +++ b/src/lib/lttng-ctl/lttng-ctl.c @@ -31,19 +31,20 @@ #include #include #include +#include #include -#include "filter-ast.h" -#include "filter-parser.h" -#include "filter-bytecode.h" -#include "memstream.h" +#include "filter/filter-ast.h" +#include "filter/filter-parser.h" +#include "filter/filter-bytecode.h" +#include "filter/memstream.h" #ifdef DEBUG -const int print_xml = 1; +static const int print_xml = 1; #define dbg_printf(fmt, args...) \ printf("[debug liblttng-ctl] " fmt, ## args) #else -const int print_xml = 0; +static const int print_xml = 0; #define dbg_printf(fmt, args...) \ do { \ /* do nothing but check printf format */ \ @@ -68,12 +69,138 @@ static int connected; * Those two variables are used by error.h to silent or control the verbosity of * error message. They are global to the library so application linking with it * are able to compile correctly and also control verbosity of the library. - * - * Note that it is *not* possible to silent ERR() and PERROR() macros. */ int lttng_opt_quiet; int lttng_opt_verbose; +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) +{ + int ret; + 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] == '/') { + 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) { + /* 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); + } + + /* 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; + } + + if (data_uris) { + memcpy(&tmp_uris[idx], data_uris, sizeof(struct lttng_uri)); + } + + *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. */ @@ -108,7 +235,6 @@ static void copy_lttng_domain(struct lttng_domain *dst, struct lttng_domain *src break; default: memset(dst, 0, sizeof(struct lttng_domain)); - dst->type = LTTNG_DOMAIN_KERNEL; break; } } @@ -125,12 +251,17 @@ static int send_session_msg(struct lttcomm_session_msg *lsm) int ret; if (!connected) { - ret = -ENOTCONN; + ret = -LTTNG_ERR_NO_SESSIOND; goto end; } + DBG("LSM cmd type : %d", lsm->cmd_type); + ret = lttcomm_send_creds_unix_sock(sessiond_socket, lsm, sizeof(struct lttcomm_session_msg)); + if (ret < 0) { + ret = -LTTNG_ERR_FATAL; + } end: return ret; @@ -147,15 +278,19 @@ static int send_session_varlen(void *data, size_t len) int ret; if (!connected) { - ret = -ENOTCONN; + ret = -LTTNG_ERR_NO_SESSIOND; goto end; } + if (!data || !len) { ret = 0; goto end; } ret = lttcomm_send_unix_sock(sessiond_socket, data, len); + if (ret < 0) { + ret = -LTTNG_ERR_FATAL; + } end: return ret; @@ -172,11 +307,14 @@ static int recv_data_sessiond(void *buf, size_t len) int ret; if (!connected) { - ret = -ENOTCONN; + ret = -LTTNG_ERR_NO_SESSIOND; goto end; } ret = lttcomm_recv_unix_sock(sessiond_socket, buf, len); + if (ret < 0) { + ret = -LTTNG_ERR_FATAL; + } end: return ret; @@ -247,13 +385,13 @@ static int try_connect_sessiond(const char *sock_path) ret = access(sock_path, F_OK); if (ret < 0) { /* Not alive */ - return -1; + goto error; } ret = lttcomm_connect_unix_sock(sock_path); if (ret < 0) { /* Not alive */ - return -1; + goto error; } ret = lttcomm_close_unix_sock(ret); @@ -262,13 +400,17 @@ static int try_connect_sessiond(const char *sock_path) } return 0; + +error: + return -1; } /* - * Set sessiond socket path by putting it in the global - * sessiond_sock_path variable. - * Returns 0 on success, - * -ENOMEM on failure (the sessiond socket path is somehow too long) + * Set sessiond socket path by putting it in the global sessiond_sock_path + * variable. + * + * Returns 0 on success, negative value on failure (the sessiond socket path + * is somehow too long or ENOMEM). */ static int set_session_daemon_path(void) { @@ -306,11 +448,14 @@ static int set_session_daemon_path(void) ret = snprintf(sessiond_sock_path, sizeof(sessiond_sock_path), DEFAULT_HOME_CLIENT_UNIX_SOCK, getenv("HOME")); if ((ret < 0) || (ret >= sizeof(sessiond_sock_path))) { - return -ENOMEM; + goto error; } } end: return 0; + +error: + return -1; } /* @@ -324,19 +469,22 @@ static int connect_sessiond(void) ret = set_session_daemon_path(); if (ret < 0) { - return -1; /* set_session_daemon_path() returns -ENOMEM */ + goto error; } /* Connect to the sesssion daemon */ ret = lttcomm_connect_unix_sock(sessiond_sock_path); if (ret < 0) { - return ret; + goto error; } sessiond_socket = ret; connected = 1; return 0; + +error: + return -1; } /* @@ -363,9 +511,7 @@ 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, - void *vardata, - size_t varlen, - void **buf) + void *vardata, size_t varlen, void **buf) { int ret; size_t size; @@ -374,28 +520,32 @@ static int ask_sessiond_varlen(struct lttcomm_session_msg *lsm, ret = connect_sessiond(); if (ret < 0) { + ret = -LTTNG_ERR_NO_SESSIOND; goto end; } /* Send command to session daemon */ ret = send_session_msg(lsm); if (ret < 0) { + /* Ret value is a valid lttng error code. */ goto end; } /* Send var len data */ ret = send_session_varlen(vardata, varlen); if (ret < 0) { + /* Ret value is a valid lttng error code. */ goto end; } /* Get header from data transmission */ ret = recv_data_sessiond(&llm, sizeof(llm)); if (ret < 0) { + /* Ret value is a valid lttng error code. */ goto end; } /* Check error code if OK */ - if (llm.ret_code != LTTCOMM_OK) { + if (llm.ret_code != LTTNG_OK) { ret = -llm.ret_code; goto end; } @@ -424,7 +574,7 @@ static int ask_sessiond_varlen(struct lttcomm_session_msg *lsm, * this point, an error is returned and data is freed. */ if (buf == NULL) { - ret = -1; + ret = -LTTNG_ERR_INVALID; free(data); goto end; } @@ -454,11 +604,15 @@ static int ask_sessiond(struct lttcomm_session_msg *lsm, void **buf) struct lttng_handle *lttng_create_handle(const char *session_name, struct lttng_domain *domain) { - struct lttng_handle *handle; + struct lttng_handle *handle = NULL; + + if (domain == NULL) { + goto end; + } handle = malloc(sizeof(struct lttng_handle)); if (handle == NULL) { - perror("malloc handle"); + PERROR("malloc handle"); goto end; } @@ -492,6 +646,10 @@ int lttng_register_consumer(struct lttng_handle *handle, { struct lttcomm_session_msg lsm; + if (handle == NULL || socket_path == NULL) { + return -LTTNG_ERR_INVALID; + } + lsm.cmd_type = LTTNG_REGISTER_CONSUMER; copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); @@ -511,7 +669,7 @@ int lttng_start_tracing(const char *session_name) struct lttcomm_session_msg lsm; if (session_name == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } lsm.cmd_type = LTTNG_START_TRACE; @@ -522,29 +680,79 @@ int lttng_start_tracing(const char *session_name) } /* - * Stop tracing for all traces of the session. - * Returns size of returned session payload data or a negative error code. + * Stop tracing for all traces of the session. */ -int lttng_stop_tracing(const char *session_name) +static int _lttng_stop_tracing(const char *session_name, int wait) { + int ret, data_ret; struct lttcomm_session_msg lsm; if (session_name == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } lsm.cmd_type = LTTNG_STOP_TRACE; copy_string(lsm.session.name, session_name, sizeof(lsm.session.name)); - return ask_sessiond(&lsm, NULL); + ret = ask_sessiond(&lsm, NULL); + if (ret < 0 && ret != -LTTNG_ERR_TRACE_ALREADY_STOPPED) { + goto error; + } + + if (!wait) { + goto end; + } + + _MSG("Waiting for data availability"); + + /* Check for data availability */ + do { + data_ret = lttng_data_pending(session_name); + if (data_ret < 0) { + /* Return the data available call error. */ + ret = data_ret; + goto error; + } + + /* + * Data sleep time before retrying (in usec). Don't sleep if the call + * returned value indicates availability. + */ + if (data_ret) { + usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME); + _MSG("."); + } + } while (data_ret != 0); + + MSG(""); + +end: +error: + return ret; +} + +/* + * Stop tracing and wait for data availability. + */ +int lttng_stop_tracing(const char *session_name) +{ + return _lttng_stop_tracing(session_name, 1); +} + +/* + * Stop tracing but _don't_ wait for data availability. + */ +int lttng_stop_tracing_no_wait(const char *session_name) +{ + return _lttng_stop_tracing(session_name, 0); } /* - * Add context to event and/or channel. - * If event_name is NULL, the context is applied to all events of the channel. - * If channel_name is NULL, a lookup of the event's channel is done. - * If both are NULL, the context is applied to all events of all channels. + * Add context to a channel. + * + * If the given channel is NULL, add the contexts to all channels. + * The event_name param is ignored. * * Returns the size of the returned payload data or a negative error code. */ @@ -556,7 +764,7 @@ int lttng_add_context(struct lttng_handle *handle, /* Safety check. Both are mandatory */ if (handle == NULL || ctx == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } memset(&lsm, 0, sizeof(lsm)); @@ -566,9 +774,6 @@ int lttng_add_context(struct lttng_handle *handle, /* Copy channel name */ copy_string(lsm.u.context.channel_name, channel_name, sizeof(lsm.u.context.channel_name)); - /* Copy event name */ - copy_string(lsm.u.context.event_name, event_name, - sizeof(lsm.u.context.event_name)); copy_lttng_domain(&lsm.domain, &handle->domain); @@ -592,7 +797,7 @@ int lttng_enable_event(struct lttng_handle *handle, struct lttcomm_session_msg lsm; if (handle == NULL || ev == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } memset(&lsm, 0, sizeof(lsm)); @@ -622,13 +827,13 @@ int lttng_enable_event(struct lttng_handle *handle, } /* - * set filter for an event + * Set filter for an event + * * Return negative error value on error. * Return size of returned session payload data if OK. */ - int lttng_set_event_filter(struct lttng_handle *handle, - const char *event_name, const char *channel_name, + struct lttng_event *event, const char *channel_name, const char *filter_expression) { struct lttcomm_session_msg lsm; @@ -638,7 +843,7 @@ int lttng_set_event_filter(struct lttng_handle *handle, /* Safety check. */ if (handle == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } if (!filter_expression) { @@ -653,24 +858,24 @@ int lttng_set_event_filter(struct lttng_handle *handle, strlen(filter_expression), "r"); if (!fmem) { fprintf(stderr, "Error opening memory as stream\n"); - return -ENOMEM; + return -LTTNG_ERR_FILTER_NOMEM; } ctx = filter_parser_ctx_alloc(fmem); if (!ctx) { fprintf(stderr, "Error allocating parser\n"); - ret = -ENOMEM; + ret = -LTTNG_ERR_FILTER_NOMEM; goto alloc_error; } ret = filter_parser_ctx_append_ast(ctx); if (ret) { fprintf(stderr, "Parse error\n"); - ret = -EINVAL; + ret = -LTTNG_ERR_FILTER_INVAL; goto parse_error; } ret = filter_visitor_set_parent(ctx); if (ret) { fprintf(stderr, "Set parent error\n"); - ret = -EINVAL; + ret = -LTTNG_ERR_FILTER_INVAL; goto parse_error; } if (print_xml) { @@ -678,7 +883,7 @@ int lttng_set_event_filter(struct lttng_handle *handle, if (ret) { fflush(stdout); fprintf(stderr, "XML print error\n"); - ret = -EINVAL; + ret = -LTTNG_ERR_FILTER_INVAL; goto parse_error; } } @@ -688,7 +893,7 @@ int lttng_set_event_filter(struct lttng_handle *handle, ret = filter_visitor_ir_generate(ctx); if (ret) { fprintf(stderr, "Generate IR error\n"); - ret = -EINVAL; + ret = -LTTNG_ERR_FILTER_INVAL; goto parse_error; } dbg_printf("done\n"); @@ -697,7 +902,7 @@ int lttng_set_event_filter(struct lttng_handle *handle, fflush(stdout); ret = filter_visitor_ir_check_binary_op_nesting(ctx); if (ret) { - ret = -EINVAL; + ret = -LTTNG_ERR_FILTER_INVAL; goto parse_error; } dbg_printf("done\n"); @@ -707,7 +912,7 @@ int lttng_set_event_filter(struct lttng_handle *handle, ret = filter_visitor_bytecode_generate(ctx); if (ret) { fprintf(stderr, "Generate bytecode error\n"); - ret = -EINVAL; + ret = -LTTNG_ERR_FILTER_INVAL; goto parse_error; } dbg_printf("done\n"); @@ -722,8 +927,10 @@ int lttng_set_event_filter(struct lttng_handle *handle, copy_string(lsm.u.filter.channel_name, channel_name, sizeof(lsm.u.filter.channel_name)); /* Copy event name */ - copy_string(lsm.u.filter.event_name, event_name, - sizeof(lsm.u.filter.event_name)); + if (event) { + memcpy(&lsm.u.enable.event, event, sizeof(lsm.u.enable.event)); + } + lsm.u.filter.bytecode_len = sizeof(ctx->bytecode->b) + bytecode_get_len(&ctx->bytecode->b); @@ -766,7 +973,7 @@ int lttng_disable_event(struct lttng_handle *handle, const char *name, struct lttcomm_session_msg lsm; if (handle == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } memset(&lsm, 0, sizeof(lsm)); @@ -807,7 +1014,7 @@ int lttng_enable_channel(struct lttng_handle *handle, * NULL arguments are forbidden. No default values. */ if (handle == NULL || chan == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } memset(&lsm, 0, sizeof(lsm)); @@ -834,7 +1041,7 @@ int lttng_disable_channel(struct lttng_handle *handle, const char *name) /* Safety check. Both are mandatory */ if (handle == NULL || name == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } memset(&lsm, 0, sizeof(lsm)); @@ -865,7 +1072,7 @@ int lttng_list_tracepoints(struct lttng_handle *handle, struct lttcomm_session_msg lsm; if (handle == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } lsm.cmd_type = LTTNG_LIST_TRACEPOINTS; @@ -892,7 +1099,7 @@ int lttng_list_tracepoint_fields(struct lttng_handle *handle, struct lttcomm_session_msg lsm; if (handle == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } lsm.cmd_type = LTTNG_LIST_TRACEPOINT_FIELDS; @@ -912,60 +1119,39 @@ int lttng_list_tracepoint_fields(struct lttng_handle *handle, */ const char *lttng_strerror(int code) { - /* lttcomm error codes range from -LTTCOMM_OK down to -LTTCOMM_NR */ - if (code > -LTTCOMM_OK) { - return "Ended with errors"; - } - - return lttcomm_get_readable_code(code); -} - -/* - * Create a brand new session using name and path. - * Returns size of returned session payload data or a negative error code. - */ -int lttng_create_session(const char *name, const char *path) -{ - struct lttcomm_session_msg lsm; - - lsm.cmd_type = LTTNG_CREATE_SESSION; - copy_string(lsm.session.name, name, sizeof(lsm.session.name)); - copy_string(lsm.session.path, path, sizeof(lsm.session.path)); - - return ask_sessiond(&lsm, NULL); + return error_get_str(code); } /* - * Create a new tracing session using a name, URIs and a consumer enable flag. + * Create a brand new session using name and url for destination. + * + * Returns LTTNG_OK on success or a negative error code. */ -int lttng_create_session_uri(const char *name, struct lttng_uri *ctrl_uri, - struct lttng_uri *data_uri, unsigned int enable_consumer) +int lttng_create_session(const char *name, const char *url) { + ssize_t size; struct lttcomm_session_msg lsm; + struct lttng_uri *uris = NULL; - /* Name and ctrl_uri are mandatory */ - if (name == NULL || ctrl_uri == NULL) { - return -1; + if (name == NULL) { + return -LTTNG_ERR_INVALID; } - lsm.cmd_type = LTTNG_CREATE_SESSION_URI; + memset(&lsm, 0, sizeof(lsm)); + lsm.cmd_type = LTTNG_CREATE_SESSION; copy_string(lsm.session.name, name, sizeof(lsm.session.name)); - /* Anything bigger than zero, the consumer(s) will be enabled */ - lsm.u.create_uri.enable_consumer = enable_consumer; - memcpy(&lsm.u.create_uri.ctrl_uri, ctrl_uri, - sizeof(lsm.u.create_uri.ctrl_uri)); - if (data_uri) { - /* - * The only possible scenario where data_uri is NULL is for a local - * consumer where the output is at a specified path name on the - * filesystem. - */ - memcpy(&lsm.u.create_uri.data_uri, data_uri, - sizeof(lsm.u.create_uri.data_uri)); + + /* There should never be a data URL */ + size = parse_str_urls_to_uri(url, NULL, &uris); + if (size < 0) { + return -LTTNG_ERR_INVALID; } - return ask_sessiond(&lsm, NULL); + lsm.u.uri.size = size; + + return ask_sessiond_varlen(&lsm, uris, sizeof(struct lttng_uri) * size, + NULL); } /* @@ -977,7 +1163,7 @@ int lttng_destroy_session(const char *session_name) struct lttcomm_session_msg lsm; if (session_name == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } lsm.cmd_type = LTTNG_DESTROY_SESSION; @@ -1020,7 +1206,7 @@ int lttng_list_domains(const char *session_name, struct lttcomm_session_msg lsm; if (session_name == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } lsm.cmd_type = LTTNG_LIST_DOMAINS; @@ -1048,7 +1234,7 @@ int lttng_list_channels(struct lttng_handle *handle, struct lttcomm_session_msg lsm; if (handle == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } lsm.cmd_type = LTTNG_LIST_CHANNELS; @@ -1079,7 +1265,7 @@ int lttng_list_events(struct lttng_handle *handle, /* Safety check. An handle and channel name are mandatory */ if (handle == NULL || channel_name == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } lsm.cmd_type = LTTNG_LIST_EVENTS; @@ -1106,11 +1292,11 @@ int lttng_list_events(struct lttng_handle *handle, int lttng_set_tracing_group(const char *name) { if (name == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } if (asprintf(&tracing_group, "%s", name) < 0) { - return -ENOMEM; + return -LTTNG_ERR_FATAL; } return 0; @@ -1126,7 +1312,7 @@ int lttng_calibrate(struct lttng_handle *handle, /* Safety check. NULL pointer are forbidden */ if (handle == NULL || calibrate == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } lsm.cmd_type = LTTNG_CALIBRATE; @@ -1157,7 +1343,7 @@ void lttng_channel_set_default_attr(struct lttng_domain *domain, attr->switch_timer_interval = DEFAULT_CHANNEL_SWITCH_TIMER; attr->read_timer_interval = DEFAULT_CHANNEL_READ_TIMER; - attr->subbuf_size = DEFAULT_KERNEL_CHANNEL_SUBBUF_SIZE; + attr->subbuf_size = default_get_kernel_channel_subbuf_size(); attr->num_subbuf = DEFAULT_KERNEL_CHANNEL_SUBBUF_NUM; attr->output = DEFAULT_KERNEL_CHANNEL_OUTPUT; break; @@ -1171,7 +1357,7 @@ void lttng_channel_set_default_attr(struct lttng_domain *domain, attr->switch_timer_interval = DEFAULT_CHANNEL_SWITCH_TIMER; attr->read_timer_interval = DEFAULT_CHANNEL_READ_TIMER; - attr->subbuf_size = DEFAULT_UST_CHANNEL_SUBBUF_SIZE; + attr->subbuf_size = default_get_ust_channel_subbuf_size(); attr->num_subbuf = DEFAULT_UST_CHANNEL_SUBBUF_NUM; attr->output = DEFAULT_UST_CHANNEL_OUTPUT; break; @@ -1198,8 +1384,11 @@ int lttng_session_daemon_alive(void) } if (strlen(sessiond_sock_path) == 0) { - /* No socket path set. Weird error */ - return -1; + /* + * No socket path set. Weird error which means the constructor was not + * called. + */ + assert(0); } ret = try_connect_sessiond(sessiond_sock_path); @@ -1213,27 +1402,38 @@ int lttng_session_daemon_alive(void) } /* - * Set URI for a consumer for a session and domain. + * Set URL for a consumer for a session and domain. * * Return 0 on success, else a negative value. */ -int lttng_set_consumer_uri(struct lttng_handle *handle, struct lttng_uri *uri) +int lttng_set_consumer_url(struct lttng_handle *handle, + const char *control_url, const char *data_url) { + ssize_t size; struct lttcomm_session_msg lsm; + struct lttng_uri *uris = NULL; - if (handle == NULL || uri == NULL) { - return -1; + if (handle == NULL || (control_url == NULL && data_url == NULL)) { + return -LTTNG_ERR_INVALID; } + memset(&lsm, 0, sizeof(lsm)); + lsm.cmd_type = LTTNG_SET_CONSUMER_URI; copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); copy_lttng_domain(&lsm.domain, &handle->domain); - memcpy(&lsm.u.uri, uri, sizeof(lsm.u.uri)); + size = parse_str_urls_to_uri(control_url, data_url, &uris); + if (size < 0) { + return -LTTNG_ERR_INVALID; + } - return ask_sessiond(&lsm, NULL); + lsm.u.uri.size = size; + + return ask_sessiond_varlen(&lsm, uris, sizeof(struct lttng_uri) * size, + NULL); } /* @@ -1246,7 +1446,7 @@ int lttng_enable_consumer(struct lttng_handle *handle) struct lttcomm_session_msg lsm; if (handle == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } lsm.cmd_type = LTTNG_ENABLE_CONSUMER; @@ -1268,7 +1468,7 @@ int lttng_disable_consumer(struct lttng_handle *handle) struct lttcomm_session_msg lsm; if (handle == NULL) { - return -1; + return -LTTNG_ERR_INVALID; } lsm.cmd_type = LTTNG_DISABLE_CONSUMER; @@ -1330,11 +1530,9 @@ static int set_health_socket_path(void) /* * Check session daemon health for a specific health component. * - * Return 0 if health is OK or else 1 if BAD. A return value of -1 indicate - * that the control library was not able to connect to the session daemon - * health socket. + * Return 0 if health is OK or else 1 if BAD. * - * Any other positive value is an lttcomm error which can be translate with + * 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) @@ -1346,7 +1544,7 @@ int lttng_health_check(enum lttng_health_component c) /* Connect to the sesssion daemon */ sock = lttcomm_connect_unix_sock(health_sock_path); if (sock < 0) { - ret = -1; + ret = -LTTNG_ERR_NO_SESSIOND; goto error; } @@ -1355,11 +1553,13 @@ int lttng_health_check(enum lttng_health_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; } @@ -1372,6 +1572,94 @@ 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 + * the lttng client. + * + * We need the date and time for the trace path subdirectory for the case where + * the user does NOT define one using either -o or -U. Using the normal + * lttng_create_session API call, we have no clue on the session daemon side if + * the URL was generated automatically by the client or define by the user. + * + * So this function "wrapper" is hidden from the public API, takes the datetime + * string and appends it if necessary to the URI subdirectory before sending it + * to the session daemon. + * + * With this extra function, the lttng_create_session call behavior is not + * changed and the timestamp is appended to the URI on the session daemon side + * if necessary. + */ +int _lttng_create_session_ext(const char *name, const char *url, + const char *datetime) +{ + int ret; + ssize_t size; + struct lttcomm_session_msg lsm; + struct lttng_uri *uris = 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)); + + /* There should never be a data URL */ + size = parse_str_urls_to_uri(url, NULL, &uris); + if (size < 0) { + return -LTTNG_ERR_INVALID; + } + + lsm.u.uri.size = size; + + if (size > 0 && uris[0].dtype != LTTNG_DST_PATH && strlen(uris[0].subdir) == 0) { + ret = snprintf(uris[0].subdir, sizeof(uris[0].subdir), "%s-%s", name, + datetime); + if (ret < 0) { + PERROR("snprintf uri subdir"); + return -LTTNG_ERR_FATAL; + } + } + + return ask_sessiond_varlen(&lsm, uris, sizeof(struct lttng_uri) * size, + NULL); +} + +/* + * For a given session name, this call checks if the data is ready to be read + * or is still being extracted by the consumer(s) hence not ready to be used by + * any readers. + */ +int lttng_data_pending(const char *session_name) +{ + int ret; + struct lttcomm_session_msg lsm; + + if (session_name == NULL) { + return -LTTNG_ERR_INVALID; + } + + lsm.cmd_type = LTTNG_DATA_PENDING; + + copy_string(lsm.session.name, session_name, sizeof(lsm.session.name)); + + ret = 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. + */ + if (ret == -1) { + ret = 1; + } + + return ret; +} + /* * lib constructor */ @@ -1382,3 +1670,11 @@ static void __attribute__((constructor)) init() /* Set socket for health check */ (void) set_health_socket_path(); } + +/* + * lib destructor + */ +static void __attribute__((destructor)) lttng_ctl_exit() +{ + free(tracing_group); +}