X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Flib%2Flttng-ctl%2Flttng-ctl.c;h=ef288726a23b1c97779097d4e0ce9bddbf00589c;hp=6cc04efc939359a139c900867a71778db776bd77;hb=f73fabfda365d22e7dd180fb1614e37c446fbd9e;hpb=af87c45a6179026e263c3a9eb251ccf8ec9537e7 diff --git a/src/lib/lttng-ctl/lttng-ctl.c b/src/lib/lttng-ctl/lttng-ctl.c index 6cc04efc9..ef288726a 100644 --- a/src/lib/lttng-ctl/lttng-ctl.c +++ b/src/lib/lttng-ctl/lttng-ctl.c @@ -5,22 +5,22 @@ * * Copyright (C) 2011 David Goulet * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; only - * version 2.1 of the License. + * This library is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License, version 2.1 only, + * as published by the Free Software Foundation. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #define _GNU_SOURCE +#include #include #include #include @@ -31,16 +31,178 @@ #include #include #include +#include #include +#include "filter-ast.h" +#include "filter-parser.h" +#include "filter-bytecode.h" +#include "memstream.h" + +#ifdef DEBUG +const int print_xml = 1; +#define dbg_printf(fmt, args...) \ + printf("[debug liblttng-ctl] " fmt, ## args) +#else +const int print_xml = 0; +#define dbg_printf(fmt, args...) \ +do { \ + /* do nothing but check printf format */ \ + if (0) \ + printf("[debug liblttnctl] " fmt, ## args); \ +} while (0) +#endif + + /* 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; static int connected; +/* Global */ + +/* + * 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. */ @@ -64,18 +226,18 @@ static void 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: - dst->type = LTTNG_DOMAIN_KERNEL; - break; + 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: + memset(dst, 0, sizeof(struct lttng_domain)); + break; } } } @@ -83,8 +245,8 @@ static void copy_lttng_domain(struct lttng_domain *dst, struct lttng_domain *src /* * Send lttcomm_session_msg to the session daemon. * - * On success, return 0 - * On error, return error code + * On success, returns the number of bytes sent (>=0) + * On error, returns -1 */ static int send_session_msg(struct lttcomm_session_msg *lsm) { @@ -95,6 +257,8 @@ static int send_session_msg(struct lttcomm_session_msg *lsm) goto end; } + DBG("LSM cmd type : %d", lsm->cmd_type); + ret = lttcomm_send_creds_unix_sock(sessiond_socket, lsm, sizeof(struct lttcomm_session_msg)); @@ -102,11 +266,37 @@ end: return ret; } +/* + * Send var len data to the session daemon. + * + * On success, returns the number of bytes sent (>=0) + * On error, returns -1 + */ +static int send_session_varlen(void *data, size_t len) +{ + int ret; + + if (!connected) { + ret = -ENOTCONN; + goto end; + } + + if (!data || !len) { + ret = 0; + goto end; + } + + ret = lttcomm_send_unix_sock(sessiond_socket, data, len); + +end: + return ret; +} + /* * Receive data from the sessiond socket. * - * On success, return 0 - * On error, return recv() error code + * On success, returns the number of bytes received (>=0) + * On error, returns -1 (recvmsg() error) or -ENOTCONN */ static int recv_data_sessiond(void *buf, size_t len) { @@ -124,7 +314,7 @@ end: } /* - * Check if the specified group name exist. + * Check if we are in the specified group. * * If yes return 1, else return -1. */ @@ -137,11 +327,8 @@ static int check_tracing_group(const char *grp_name) /* Get GID of group 'tracing' */ grp_tracing = getgrnam(grp_name); - if (grp_tracing == NULL) { - /* NULL means not found also. getgrnam(3) */ - if (errno != 0) { - perror("getgrnam"); - } + if (!grp_tracing) { + /* If grp_tracing is NULL, the group does not exist. */ goto end; } @@ -155,11 +342,11 @@ static int check_tracing_group(const char *grp_name) /* Alloc group list of the right size */ grp_list = malloc(grp_list_size * sizeof(gid_t)); if (!grp_list) { - ret = -1; + perror("malloc"); goto end; } grp_id = getgroups(grp_list_size, grp_list); - if (grp_id < -1) { + if (grp_id < 0) { perror("getgroups"); goto free_list; } @@ -209,8 +396,10 @@ static int try_connect_sessiond(const char *sock_path) } /* - * Set sessiond socket path by putting it in the global sessiond_sock_path - * variable. + * 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) */ static int set_session_daemon_path(void) { @@ -225,35 +414,33 @@ static int set_session_daemon_path(void) in_tgroup = check_tracing_group(tracing_group); } - if (uid == 0) { - /* Root */ - copy_string(sessiond_sock_path, - DEFAULT_GLOBAL_CLIENT_UNIX_SOCK, - sizeof(sessiond_sock_path)); - } else if (in_tgroup) { - /* Tracing group */ - copy_string(sessiond_sock_path, - DEFAULT_GLOBAL_CLIENT_UNIX_SOCK, + if ((uid == 0) || in_tgroup) { + copy_string(sessiond_sock_path, DEFAULT_GLOBAL_CLIENT_UNIX_SOCK, sizeof(sessiond_sock_path)); + } - ret = try_connect_sessiond(sessiond_sock_path); - if (ret < 0) { - /* Global session daemon not available */ - if (snprintf(sessiond_sock_path, sizeof(sessiond_sock_path), - DEFAULT_HOME_CLIENT_UNIX_SOCK, - getenv("HOME")) < 0) { - return -ENOMEM; + if (uid != 0) { + if (in_tgroup) { + /* Tracing group */ + ret = try_connect_sessiond(sessiond_sock_path); + if (ret >= 0) { + goto end; } + /* Global session daemon not available... */ } - } else { - /* Not in tracing group and not root, default */ - if (snprintf(sessiond_sock_path, PATH_MAX, - DEFAULT_HOME_CLIENT_UNIX_SOCK, - getenv("HOME")) < 0) { + /* ...or not in tracing group (and not root), default */ + + /* + * 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) + */ + 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; } } - +end: return 0; } @@ -268,7 +455,7 @@ static int connect_sessiond(void) ret = set_session_daemon_path(); if (ret < 0) { - return ret; + return -1; /* set_session_daemon_path() returns -ENOMEM */ } /* Connect to the sesssion daemon */ @@ -284,7 +471,8 @@ static int connect_sessiond(void) } /* - * Clean disconnect the session daemon. + * Clean disconnect from the session daemon. + * On success, return 0. On error, return -1. */ static int disconnect_sessiond(void) { @@ -301,10 +489,12 @@ static int disconnect_sessiond(void) /* * Ask the session daemon a specific command and put the data into buf. + * Takes extra var. len. data as input to send to the session daemon. * * Return size of data (only payload, not header) or a negative error code. */ -static int ask_sessiond(struct lttcomm_session_msg *lsm, void **buf) +static int ask_sessiond_varlen(struct lttcomm_session_msg *lsm, + void *vardata, size_t varlen, void **buf) { int ret; size_t size; @@ -321,6 +511,11 @@ static int ask_sessiond(struct lttcomm_session_msg *lsm, void **buf) if (ret < 0) { goto end; } + /* Send var len data */ + ret = send_session_varlen(vardata, varlen); + if (ret < 0) { + goto end; + } /* Get header from data transmission */ ret = recv_data_sessiond(&llm, sizeof(llm)); @@ -329,7 +524,7 @@ static int ask_sessiond(struct lttcomm_session_msg *lsm, void **buf) } /* Check error code if OK */ - if (llm.ret_code != LTTCOMM_OK) { + if (llm.ret_code != LTTNG_OK) { ret = -llm.ret_code; goto end; } @@ -371,8 +566,19 @@ 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. */ struct lttng_handle *lttng_create_handle(const char *session_name, struct lttng_domain *domain) @@ -408,6 +614,7 @@ void lttng_destroy_handle(struct lttng_handle *handle) /* * Register an outside consumer. + * Returns size of returned session payload data or a negative error code. */ int lttng_register_consumer(struct lttng_handle *handle, const char *socket_path) @@ -425,7 +632,8 @@ int lttng_register_consumer(struct lttng_handle *handle, } /* - * Start tracing for all trace of the session. + * Start tracing for all traces of the session. + * Returns size of returned session payload data or a negative error code. */ int lttng_start_tracing(const char *session_name) { @@ -443,7 +651,8 @@ int lttng_start_tracing(const char *session_name) } /* - * Stop tracing for all trace of the session. + * Stop tracing for all traces of the session. + * Returns size of returned session payload data or a negative error code. */ int lttng_stop_tracing(const char *session_name) { @@ -461,7 +670,10 @@ int lttng_stop_tracing(const char *session_name) } /* - * Add context to event or/and channel. + * 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. * * Returns the size of the returned payload data or a negative error code. */ @@ -476,6 +688,8 @@ int lttng_add_context(struct lttng_handle *handle, return -1; } + memset(&lsm, 0, sizeof(lsm)); + lsm.cmd_type = LTTNG_ADD_CONTEXT; /* Copy channel name */ @@ -496,7 +710,10 @@ int lttng_add_context(struct lttng_handle *handle, } /* - * Enable event + * Enable event(s) for a channel. + * If no event name is specified, all events are enabled. + * If no channel name is specified, the default 'channel0' is used. + * Returns size of returned session payload data or a negative error code. */ int lttng_enable_event(struct lttng_handle *handle, struct lttng_event *ev, const char *channel_name) @@ -507,6 +724,8 @@ int lttng_enable_event(struct lttng_handle *handle, return -1; } + memset(&lsm, 0, sizeof(lsm)); + /* If no channel name, we put the default name */ if (channel_name == NULL) { copy_string(lsm.u.enable.channel_name, DEFAULT_CHANNEL_NAME, @@ -532,7 +751,143 @@ int lttng_enable_event(struct lttng_handle *handle, } /* - * Disable event of a channel and domain. + * 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, + const char *filter_expression) +{ + struct lttcomm_session_msg lsm; + struct filter_parser_ctx *ctx; + FILE *fmem; + int ret = 0; + + /* Safety check. */ + if (handle == NULL) { + return -1; + } + + if (!filter_expression) { + return 0; + } + + /* + * 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 -ENOMEM; + } + ctx = filter_parser_ctx_alloc(fmem); + if (!ctx) { + fprintf(stderr, "Error allocating parser\n"); + ret = -ENOMEM; + goto alloc_error; + } + ret = filter_parser_ctx_append_ast(ctx); + if (ret) { + fprintf(stderr, "Parse error\n"); + ret = -EINVAL; + goto parse_error; + } + ret = filter_visitor_set_parent(ctx); + if (ret) { + fprintf(stderr, "Set parent error\n"); + ret = -EINVAL; + 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 = -EINVAL; + goto parse_error; + } + } + + dbg_printf("Generating IR... "); + fflush(stdout); + ret = filter_visitor_ir_generate(ctx); + if (ret) { + fprintf(stderr, "Generate IR error\n"); + ret = -EINVAL; + 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 = -EINVAL; + 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 = -EINVAL; + goto parse_error; + } + 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_SET_FILTER; + + /* Copy channel name */ + 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)); + lsm.u.filter.bytecode_len = sizeof(ctx->bytecode->b) + + bytecode_get_len(&ctx->bytecode->b); + + copy_lttng_domain(&lsm.domain, &handle->domain); + + copy_string(lsm.session.name, handle->session_name, + sizeof(lsm.session.name)); + + ret = ask_sessiond_varlen(&lsm, &ctx->bytecode->b, + lsm.u.filter.bytecode_len, NULL); + + filter_bytecode_free(ctx); + filter_ir_free(ctx); + filter_parser_ctx_free(ctx); + if (fclose(fmem) != 0) { + perror("fclose"); + } + 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"); + } + return ret; +} + +/* + * Disable event(s) of a channel and domain. + * If no event name is specified, all events are disabled. + * If no channel name is specified, the default 'channel0' is used. + * Returns size of returned session payload data or a negative error code. */ int lttng_disable_event(struct lttng_handle *handle, const char *name, const char *channel_name) @@ -543,6 +898,8 @@ int lttng_disable_event(struct lttng_handle *handle, const char *name, return -1; } + memset(&lsm, 0, sizeof(lsm)); + if (channel_name) { copy_string(lsm.u.disable.channel_name, channel_name, sizeof(lsm.u.disable.channel_name)); @@ -567,7 +924,8 @@ int lttng_disable_event(struct lttng_handle *handle, const char *name, } /* - * Enable channel per domain + * Enable channel per domain + * Returns size of returned session payload data or a negative error code. */ int lttng_enable_channel(struct lttng_handle *handle, struct lttng_channel *chan) @@ -581,6 +939,8 @@ int lttng_enable_channel(struct lttng_handle *handle, return -1; } + memset(&lsm, 0, sizeof(lsm)); + memcpy(&lsm.u.channel.chan, chan, sizeof(lsm.u.channel.chan)); lsm.cmd_type = LTTNG_ENABLE_CHANNEL; @@ -594,7 +954,8 @@ int lttng_enable_channel(struct lttng_handle *handle, } /* - * All tracing will be stopped for registered events of the channel. + * All tracing will be stopped for registered events of the channel. + * Returns size of returned session payload data or a negative error code. */ int lttng_disable_channel(struct lttng_handle *handle, const char *name) { @@ -605,6 +966,8 @@ int lttng_disable_channel(struct lttng_handle *handle, const char *name) return -1; } + memset(&lsm, 0, sizeof(lsm)); + lsm.cmd_type = LTTNG_DISABLE_CHANNEL; copy_string(lsm.u.disable.channel_name, name, @@ -619,10 +982,10 @@ int lttng_disable_channel(struct lttng_handle *handle, const char *name) } /* - * List all available tracepoints of domain. - * - * Return the size (bytes) of the list and set the events array. - * On error, return negative value. + * Lists all available tracepoints of domain. + * Sets the contents of the events array. + * Returns the number of lttng_event entries in events; + * on error, returns a negative value. */ int lttng_list_tracepoints(struct lttng_handle *handle, struct lttng_event **events) @@ -646,33 +1009,76 @@ int lttng_list_tracepoints(struct lttng_handle *handle, } /* - * Return a human readable string of code + * Lists all available tracepoint fields of domain. + * Sets the contents of the event field array. + * Returns the number of lttng_event_field entries in events; + * on error, returns a negative value. */ -const char *lttng_strerror(int code) +int lttng_list_tracepoint_fields(struct lttng_handle *handle, + struct lttng_event_field **fields) { - if (code > -LTTCOMM_OK) { - return "Ended with errors"; + int ret; + struct lttcomm_session_msg lsm; + + if (handle == NULL) { + return -1; } - return lttcomm_get_readable_code(code); + lsm.cmd_type = LTTNG_LIST_TRACEPOINT_FIELDS; + copy_lttng_domain(&lsm.domain, &handle->domain); + + ret = ask_sessiond(&lsm, (void **) fields); + if (ret < 0) { + return ret; + } + + return ret / sizeof(struct lttng_event_field); +} + +/* + * Returns a human readable string describing + * the error code (a negative value). + */ +const char *lttng_strerror(int code) +{ + return error_get_str(code); } /* - * Create a brand new session using name. + * 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(const char *name, const char *path) +int lttng_create_session(const char *name, const char *url) { + ssize_t size; struct lttcomm_session_msg lsm; + struct lttng_uri *uris = NULL; + + if (name == NULL) { + return -1; + } + + memset(&lsm, 0, sizeof(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); + /* 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; + + return ask_sessiond_varlen(&lsm, uris, sizeof(struct lttng_uri) * size, + NULL); } /* * Destroy session using name. + * Returns size of returned session payload data or a negative error code. */ int lttng_destroy_session(const char *session_name) { @@ -691,9 +1097,9 @@ int lttng_destroy_session(const char *session_name) /* * Ask the session daemon for all available sessions. - * - * Return number of session. - * On error, return negative value. + * Sets the contents of the sessions array. + * Returns the number of lttng_session entries in sessions; + * on error, returns a negative value. */ int lttng_list_sessions(struct lttng_session **sessions) { @@ -710,7 +1116,10 @@ int lttng_list_sessions(struct lttng_session **sessions) } /* - * List domain of a session. + * Ask the session daemon for all available domains of a session. + * Sets the contents of the domains array. + * Returns the number of lttng_domain entries in domains; + * on error, returns a negative value. */ int lttng_list_domains(const char *session_name, struct lttng_domain **domains) @@ -735,7 +1144,10 @@ int lttng_list_domains(const char *session_name, } /* - * List channels of a session + * Ask the session daemon for all available channels of a session. + * Sets the contents of the channels array. + * Returns the number of lttng_channel entries in channels; + * on error, returns a negative value. */ int lttng_list_channels(struct lttng_handle *handle, struct lttng_channel **channels) @@ -762,7 +1174,10 @@ int lttng_list_channels(struct lttng_handle *handle, } /* - * List events of a session channel. + * Ask the session daemon for all available events of a session channel. + * Sets the contents of the events array. + * Returns the number of lttng_event entries in events; + * on error, returns a negative value. */ int lttng_list_events(struct lttng_handle *handle, const char *channel_name, struct lttng_event **events) @@ -792,8 +1207,9 @@ int lttng_list_events(struct lttng_handle *handle, } /* - * Set tracing group variable with name. This function allocate memory pointed - * by tracing_group. + * Sets the tracing_group variable with name. + * This function allocates memory pointed to by tracing_group. + * On success, returns 0, on error, returns -1 (null name) or -ENOMEM. */ int lttng_set_tracing_group(const char *name) { @@ -831,6 +1247,7 @@ int lttng_calibrate(struct lttng_handle *handle, /* * Set default channel attributes. + * If either or both of the arguments are null, attr content is zeroe'd. */ void lttng_channel_set_default_attr(struct lttng_domain *domain, struct lttng_channel_attr *attr) @@ -840,6 +1257,8 @@ void lttng_channel_set_default_attr(struct lttng_domain *domain, return; } + memset(attr, 0, sizeof(struct lttng_channel_attr)); + switch (domain->type) { case LTTNG_DOMAIN_KERNEL: attr->overwrite = DEFAULT_CHANNEL_OVERWRITE; @@ -865,8 +1284,7 @@ void lttng_channel_set_default_attr(struct lttng_domain *domain, attr->output = DEFAULT_UST_CHANNEL_OUTPUT; break; default: - /* Default behavior */ - memset(attr, 0, sizeof(struct lttng_channel_attr)); + /* Default behavior: leave set to 0. */ break; } } @@ -875,7 +1293,7 @@ void lttng_channel_set_default_attr(struct lttng_domain *domain, * Check if session daemon is alive. * * Return 1 if alive or 0 if not. - * On error return -1 + * On error returns a negative value. */ int lttng_session_daemon_alive(void) { @@ -902,6 +1320,242 @@ int lttng_session_daemon_alive(void) return 1; } +/* + * Set URL for a consumer for a session and domain. + * + * Return 0 on success, else a negative value. + */ +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 || (control_url == NULL && data_url == NULL)) { + return -1; + } + + 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); + + size = parse_str_urls_to_uri(control_url, data_url, &uris); + if (size < 0) { + return LTTNG_ERR_INVALID; + } + + lsm.u.uri.size = size; + + return ask_sessiond_varlen(&lsm, uris, sizeof(struct lttng_uri) * size, + NULL); +} + +/* + * Enable consumer for a session and domain. + * + * Return 0 on success, else a negative value. + */ +int lttng_enable_consumer(struct lttng_handle *handle) +{ + struct lttcomm_session_msg lsm; + + if (handle == NULL) { + return -1; + } + + lsm.cmd_type = LTTNG_ENABLE_CONSUMER; + + copy_string(lsm.session.name, handle->session_name, + sizeof(lsm.session.name)); + copy_lttng_domain(&lsm.domain, &handle->domain); + + return ask_sessiond(&lsm, NULL); +} + +/* + * Disable consumer for a session and domain. + * + * Return 0 on success, else a negative value. + */ +int lttng_disable_consumer(struct lttng_handle *handle) +{ + struct lttcomm_session_msg lsm; + + if (handle == NULL) { + return -1; + } + + lsm.cmd_type = LTTNG_DISABLE_CONSUMER; + + copy_string(lsm.session.name, handle->session_name, + sizeof(lsm.session.name)); + copy_lttng_domain(&lsm.domain, &handle->domain); + + return ask_sessiond(&lsm, NULL); +} + +/* + * 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 ret; + 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) { + copy_string(health_sock_path, DEFAULT_GLOBAL_HEALTH_UNIX_SOCK, + sizeof(health_sock_path)); + } + + if (uid != 0) { + /* + * 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"); + 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. A return value of -1 indicate + * that the control library was not able to connect to the session daemon + * health socket. + * + * Any other positive value is an lttcomm error which can be translate 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 = -1; + goto error; + } + + msg.cmd = LTTNG_HEALTH_CHECK; + msg.component = c; + + ret = lttcomm_send_unix_sock(sock, (void *)&msg, sizeof(msg)); + if (ret < 0) { + goto close_error; + } + + ret = lttcomm_recv_unix_sock(sock, (void *)&reply, sizeof(reply)); + if (ret < 0) { + goto close_error; + } + + ret = reply.ret_code; + +close_error: + close(sock); + +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 -1; + } + + memset(&lsm, 0, sizeof(lsm)); + + lsm.cmd_type = LTTNG_CREATE_SESSION; + if (!strncmp(name, DEFAULT_SESSION_NAME, strlen(DEFAULT_SESSION_NAME))) { + ret = snprintf(lsm.session.name, sizeof(lsm.session.name), "%s-%s", + name, datetime); + if (ret < 0) { + PERROR("snprintf session name datetime"); + return -1; + } + } else { + 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 (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 -1; + } + } + + return ask_sessiond_varlen(&lsm, uris, sizeof(struct lttng_uri) * size, + NULL); +} + /* * lib constructor */ @@ -909,4 +1563,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(); }