X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Flib%2Flttng-ctl%2Flttng-ctl.c;h=4e49120732da5f5753e7322c5e60d99163e5881c;hp=bbff088e098107ebd64b171116f767a1f7126079;hb=ab5be9fa2eb5ba9600a82cd18fd3cfcbac69169a;hpb=28ab59d0baef178a8629ec9fb517ba75efb46ea8 diff --git a/src/lib/lttng-ctl/lttng-ctl.c b/src/lib/lttng-ctl/lttng-ctl.c index bbff088e0..4e4912073 100644 --- a/src/lib/lttng-ctl/lttng-ctl.c +++ b/src/lib/lttng-ctl/lttng-ctl.c @@ -4,20 +4,10 @@ * Linux Trace Toolkit Control Library * * Copyright (C) 2011 David Goulet - * Copyright (C) 2016 - Jérémie Galarneau + * Copyright (C) 2016 Jérémie Galarneau * - * 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. + * SPDX-License-Identifier: LGPL-2.1-only * - * 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 */ #define _LGPL_SOURCE @@ -45,6 +35,8 @@ #include #include #include +#include +#include #include "filter/filter-ast.h" #include "filter/filter-parser.h" @@ -66,9 +58,16 @@ do { \ } while (0) #endif +#define COPY_DOMAIN_PACKED(dst, src) \ +do { \ + struct lttng_domain _tmp_domain; \ + \ + lttng_ctl_copy_lttng_domain(&_tmp_domain, &src); \ + dst = _tmp_domain; \ +} while (0) /* Socket to session daemon for communication */ -static int sessiond_socket; +static int sessiond_socket = -1; static char sessiond_sock_path[PATH_MAX]; /* Variables */ @@ -423,17 +422,12 @@ error: /* * Connect to the LTTng session daemon. * - * On success, return 0. On error, return -1. + * On success, return the socket's file descriptor. On error, return -1. */ -static int connect_sessiond(void) +LTTNG_HIDDEN 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; @@ -445,15 +439,18 @@ static int connect_sessiond(void) goto error; } - sessiond_socket = ret; - connected = 1; - - return 0; + return ret; error: return -1; } +static void reset_global_sessiond_connection_state(void) +{ + sessiond_socket = -1; + connected = 0; +} + /* * Clean disconnect from the session daemon. * @@ -465,8 +462,7 @@ static int disconnect_sessiond(void) if (connected) { ret = lttcomm_close_unix_sock(sessiond_socket); - sessiond_socket = 0; - connected = 0; + reset_global_sessiond_connection_state(); } return ret; @@ -541,6 +537,9 @@ int lttng_ctl_ask_sessiond_fds_varlen(struct lttcomm_session_msg *lsm, if (ret < 0) { ret = -LTTNG_ERR_NO_SESSIOND; goto end; + } else { + sessiond_socket = ret; + connected = 1; } /* Send command to session daemon */ @@ -652,7 +651,7 @@ int lttng_register_consumer(struct lttng_handle *handle, lsm.cmd_type = LTTNG_REGISTER_CONSUMER; lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); - lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); + COPY_DOMAIN_PACKED(lsm.domain, handle->domain); lttng_ctl_copy_string(lsm.u.reg.path, socket_path, sizeof(lsm.u.reg.path)); @@ -723,7 +722,7 @@ static int _lttng_stop_tracing(const char *session_name, int wait) * call returned value indicates availability. */ if (data_ret) { - usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME); + usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME_US); } } while (data_ret != 0); @@ -783,7 +782,7 @@ int lttng_add_context(struct lttng_handle *handle, sizeof(lsm.u.context.channel_name)); } - lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); + COPY_DOMAIN_PACKED(lsm.domain, handle->domain); lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); @@ -1078,7 +1077,11 @@ int lttng_enable_event_with_exclusions(struct lttng_handle *handle, unsigned int free_filter_expression = 0; struct filter_parser_ctx *ctx = NULL; - memset(&send_buffer, 0, sizeof(send_buffer)); + /* + * 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. + */ + lttng_dynamic_buffer_init(&send_buffer); /* * Cast as non-const since we may replace the filter expression @@ -1119,8 +1122,7 @@ int lttng_enable_event_with_exclusions(struct lttng_handle *handle, lttng_ctl_copy_string(ev->name, "*", sizeof(ev->name)); } - lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); - /* FIXME: copying non-packed struct to packed struct. */ + COPY_DOMAIN_PACKED(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, @@ -1128,12 +1130,6 @@ int lttng_enable_event_with_exclusions(struct lttng_handle *handle, lsm.u.enable.exclusion_count = exclusion_count; lsm.u.enable.bytecode_len = 0; - /* - * 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. - */ - lttng_dynamic_buffer_init(&send_buffer); - /* Parse filter expression. */ if (filter_expression != NULL || handle->domain.type == LTTNG_DOMAIN_JUL || handle->domain.type == LTTNG_DOMAIN_LOG4J @@ -1319,8 +1315,7 @@ int lttng_disable_event_ext(struct lttng_handle *handle, lsm.cmd_type = LTTNG_DISABLE_EVENT; - lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); - /* FIXME: copying non-packed struct to packed struct. */ + COPY_DOMAIN_PACKED(lsm.domain, handle->domain); memcpy(&lsm.u.disable.event, ev, sizeof(lsm.u.disable.event)); lttng_ctl_copy_string(lsm.session.name, handle->session_name, @@ -1566,7 +1561,7 @@ int lttng_enable_channel(struct lttng_handle *handle, } lsm.cmd_type = LTTNG_ENABLE_CHANNEL; - lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); + COPY_DOMAIN_PACKED(lsm.domain, handle->domain); lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); @@ -1594,59 +1589,7 @@ int lttng_disable_channel(struct lttng_handle *handle, const char *name) lttng_ctl_copy_string(lsm.u.disable.channel_name, name, sizeof(lsm.u.disable.channel_name)); - lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); - - lttng_ctl_copy_string(lsm.session.name, handle->session_name, - sizeof(lsm.session.name)); - - return lttng_ctl_ask_sessiond(&lsm, NULL); -} - -/* - * Add PID to session tracker. - * Return 0 on success else a negative LTTng error code. - */ -int lttng_track_pid(struct lttng_handle *handle, int pid) -{ - struct lttcomm_session_msg lsm; - - /* NULL arguments are forbidden. No default values. */ - if (handle == NULL) { - return -LTTNG_ERR_INVALID; - } - - memset(&lsm, 0, sizeof(lsm)); - - lsm.cmd_type = LTTNG_TRACK_PID; - lsm.u.pid_tracker.pid = pid; - - lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); - - lttng_ctl_copy_string(lsm.session.name, handle->session_name, - sizeof(lsm.session.name)); - - return lttng_ctl_ask_sessiond(&lsm, NULL); -} - -/* - * Remove PID from session tracker. - * Return 0 on success else a negative LTTng error code. - */ -int lttng_untrack_pid(struct lttng_handle *handle, int pid) -{ - struct lttcomm_session_msg lsm; - - /* NULL arguments are forbidden. No default values. */ - if (handle == NULL) { - return -LTTNG_ERR_INVALID; - } - - memset(&lsm, 0, sizeof(lsm)); - - lsm.cmd_type = LTTNG_UNTRACK_PID; - lsm.u.pid_tracker.pid = pid; - - lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); + COPY_DOMAIN_PACKED(lsm.domain, handle->domain); lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); @@ -1672,7 +1615,7 @@ int lttng_list_tracepoints(struct lttng_handle *handle, memset(&lsm, 0, sizeof(lsm)); lsm.cmd_type = LTTNG_LIST_TRACEPOINTS; - lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); + COPY_DOMAIN_PACKED(lsm.domain, handle->domain); ret = lttng_ctl_ask_sessiond(&lsm, (void **) events); if (ret < 0) { @@ -1700,7 +1643,7 @@ int lttng_list_tracepoint_fields(struct lttng_handle *handle, memset(&lsm, 0, sizeof(lsm)); lsm.cmd_type = LTTNG_LIST_TRACEPOINT_FIELDS; - lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); + COPY_DOMAIN_PACKED(lsm.domain, handle->domain); ret = lttng_ctl_ask_sessiond(&lsm, (void **) fields); if (ret < 0) { @@ -1832,7 +1775,7 @@ end: /* * Create a new session using name and url for destination. * - * Returns LTTNG_OK on success or a negative error code. + * Return 0 on success else a negative LTTng error code. */ int lttng_create_session(const char *name, const char *url) { @@ -1887,7 +1830,7 @@ end: /* * Create a session exclusively used for snapshot. * - * Returns LTTNG_OK on success or a negative error code. + * Return 0 on success else a negative LTTng error code. */ int lttng_create_session_snapshot(const char *name, const char *snapshot_url) { @@ -1963,7 +1906,7 @@ end: /* * Create a session exclusively used for live. * - * Returns LTTNG_OK on success or a negative error code. + * Return 0 on success else a negative LTTng error code. */ int lttng_create_session_live(const char *name, const char *url, unsigned int timer_interval) @@ -1995,45 +1938,49 @@ end: return ret; } -/* - * Destroy session using name. - * Returns size of returned session payload data or a negative error code. - */ -static -int _lttng_destroy_session(const char *session_name) -{ - struct lttcomm_session_msg lsm; - - if (session_name == NULL) { - return -LTTNG_ERR_INVALID; - } - - memset(&lsm, 0, sizeof(lsm)); - lsm.cmd_type = LTTNG_DESTROY_SESSION; - - lttng_ctl_copy_string(lsm.session.name, session_name, - sizeof(lsm.session.name)); - - return lttng_ctl_ask_sessiond(&lsm, NULL); -} - /* * Stop the session and wait for the data before destroying it + * + * Return 0 on success else a negative LTTng error code. */ int lttng_destroy_session(const char *session_name) { int ret; + enum lttng_error_code ret_code; + enum lttng_destruction_handle_status status; + struct lttng_destruction_handle *handle = NULL; /* - * Stop the tracing and wait for the data. + * Stop the tracing and wait for the data to be + * consumed. */ ret = _lttng_stop_tracing(session_name, 1); if (ret && ret != -LTTNG_ERR_TRACE_ALREADY_STOPPED) { goto end; } - ret = _lttng_destroy_session(session_name); + ret_code = lttng_destroy_session_ext(session_name, &handle); + if (ret_code != LTTNG_OK) { + ret = (int) -ret_code; + goto end; + } + assert(handle); + + /* Block until the completion of the destruction of the session. */ + status = lttng_destruction_handle_wait_for_completion(handle, -1); + if (status != LTTNG_DESTRUCTION_HANDLE_STATUS_COMPLETED) { + ret = -LTTNG_ERR_UNK; + goto end; + } + + status = lttng_destruction_handle_get_result(handle, &ret_code); + if (status != LTTNG_DESTRUCTION_HANDLE_STATUS_OK) { + ret = -LTTNG_ERR_UNK; + goto end; + } + ret = ret_code == LTTNG_OK ? 0 : -ret_code; end: + lttng_destruction_handle_destroy(handle); return ret; } @@ -2042,21 +1989,10 @@ end: */ int lttng_destroy_session_no_wait(const char *session_name) { - int ret; - - /* - * Stop the tracing without waiting for the data. - * The session might already have been stopped, so just - * skip this error. - */ - ret = _lttng_stop_tracing(session_name, 0); - if (ret && ret != -LTTNG_ERR_TRACE_ALREADY_STOPPED) { - goto end; - } + enum lttng_error_code ret_code; - ret = _lttng_destroy_session(session_name); -end: - return ret; + ret_code = lttng_destroy_session_ext(session_name, NULL); + return ret_code == LTTNG_OK ? ret_code : -ret_code; } /* @@ -2079,7 +2015,6 @@ int lttng_list_sessions(struct lttng_session **out_sessions) lsm.cmd_type = LTTNG_LIST_SESSIONS; ret = lttng_ctl_ask_sessiond(&lsm, (void**) &sessions); if (ret <= 0) { - ret = ret == 0 ? -LTTNG_ERR_FATAL : ret; goto end; } if (!sessions) { @@ -2210,7 +2145,7 @@ int lttng_list_channels(struct lttng_handle *handle, lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); - lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); + COPY_DOMAIN_PACKED(lsm.domain, handle->domain); ret = lttng_ctl_ask_sessiond(&lsm, (void**) channels); if (ret < 0) { @@ -2270,7 +2205,7 @@ int lttng_list_events(struct lttng_handle *handle, sizeof(lsm.session.name)); lttng_ctl_copy_string(lsm.u.list.channel_name, channel_name, sizeof(lsm.u.list.channel_name)); - lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); + COPY_DOMAIN_PACKED(lsm.domain, handle->domain); ret = lttng_ctl_ask_sessiond_fds_varlen(&lsm, NULL, 0, NULL, 0, (void **) &reception_buffer, (void **) &cmd_header, @@ -2287,7 +2222,7 @@ int lttng_list_events(struct lttng_handle *handle, /* Set number of events and free command header */ nb_events = cmd_header->nb_events; if (nb_events > INT_MAX) { - ret = -EOVERFLOW; + ret = -LTTNG_ERR_OVERFLOW; goto end; } free(cmd_header); @@ -2797,7 +2732,7 @@ int lttng_set_consumer_url(struct lttng_handle *handle, lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); - lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); + COPY_DOMAIN_PACKED(lsm.domain, handle->domain); size = uri_parse_str_urls(control_url, data_url, &uris); if (size < 0) { @@ -2816,6 +2751,7 @@ int lttng_set_consumer_url(struct lttng_handle *handle, /* * [OBSOLETE] */ +int lttng_enable_consumer(struct lttng_handle *handle); int lttng_enable_consumer(struct lttng_handle *handle) { return -ENOSYS; @@ -2824,6 +2760,7 @@ int lttng_enable_consumer(struct lttng_handle *handle) /* * [OBSOLETE] */ +int lttng_disable_consumer(struct lttng_handle *handle); int lttng_disable_consumer(struct lttng_handle *handle) { return -ENOSYS; @@ -2832,6 +2769,8 @@ int lttng_disable_consumer(struct lttng_handle *handle) /* * [OBSOLETE] */ +int _lttng_create_session_ext(const char *name, const char *url, + const char *datetime); int _lttng_create_session_ext(const char *name, const char *url, const char *datetime) { @@ -2866,6 +2805,10 @@ int lttng_data_pending(const char *session_name) /* Unexpected payload size */ ret = -LTTNG_ERR_INVALID; goto end; + } else if (!pending) { + /* Internal error. */ + ret = -LTTNG_ERR_UNK; + goto end; } ret = (int) *pending; @@ -2875,52 +2818,169 @@ end: } /* - * List PIDs in the tracker. + * List IDs in the tracker. * - * enabled is set to whether the PID tracker is enabled. - * pids is set to an allocated array of PIDs currently tracked. On - * success, pids must be freed by the caller. - * nr_pids is set to the number of entries contained by the pids array. + * tracker_type is the type of tracker. + * ids is set to an allocated array of IDs currently tracked. On + * success, ids and contained ids must be freed/destroy by the caller. + * nr_ids is set to the number of entries contained by the ids array. * * Returns 0 on success, else a negative LTTng error code. */ -int lttng_list_tracker_pids(struct lttng_handle *handle, - int *_enabled, int32_t **_pids, size_t *_nr_pids) +int lttng_list_tracker_ids(struct lttng_handle *handle, + enum lttng_tracker_type tracker_type, + struct lttng_tracker_ids **_ids) { - int ret; - int enabled = 1; + int ret, i; struct lttcomm_session_msg lsm; - size_t nr_pids; - int32_t *pids = NULL; + struct lttcomm_tracker_command_header *cmd_header = NULL; + char *cmd_payload = NULL, *p; + size_t cmd_header_len; + size_t nr_ids = 0; + struct lttng_tracker_ids *ids = NULL; if (handle == NULL) { return -LTTNG_ERR_INVALID; } memset(&lsm, 0, sizeof(lsm)); - lsm.cmd_type = LTTNG_LIST_TRACKER_PIDS; + lsm.cmd_type = LTTNG_LIST_TRACKER_IDS; + lsm.u.id_tracker_list.tracker_type = tracker_type; lttng_ctl_copy_string(lsm.session.name, handle->session_name, sizeof(lsm.session.name)); - lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); + COPY_DOMAIN_PACKED(lsm.domain, handle->domain); + + ret = lttng_ctl_ask_sessiond_fds_varlen(&lsm, NULL, 0, NULL, 0, + (void **) &cmd_payload, (void **) &cmd_header, + &cmd_header_len); + if (ret < 0) { + goto error; + } + + /* Set number of tracker_id and free command header */ + nr_ids = cmd_header->nb_tracker_id; + if (nr_ids > INT_MAX) { + ret = -LTTNG_ERR_OVERFLOW; + goto error; + } + free(cmd_header); + cmd_header = NULL; + + ids = lttng_tracker_ids_create(nr_ids); + if (!ids) { + ret = -LTTNG_ERR_NOMEM; + goto error; + } + + p = cmd_payload; + for (i = 0; i < nr_ids; i++) { + struct lttcomm_tracker_id_header *tracker_id; + struct lttng_tracker_id *id; + enum lttng_tracker_id_status status; + + tracker_id = (struct lttcomm_tracker_id_header *) p; + p += sizeof(struct lttcomm_tracker_id_header); + id = lttng_tracker_ids_get_pointer_of_index(ids, i); + if (!id) { + ret = -LTTNG_ERR_INVALID; + goto error; + } - ret = lttng_ctl_ask_sessiond(&lsm, (void **) &pids); + switch (tracker_id->type) { + case LTTNG_ID_ALL: + status = lttng_tracker_id_set_all(id); + break; + case LTTNG_ID_VALUE: + id->value = tracker_id->u.value; + status = lttng_tracker_id_set_value( + id, tracker_id->u.value); + break; + case LTTNG_ID_STRING: + status = lttng_tracker_id_set_string(id, p); + p += tracker_id->u.var_data_len; + break; + default: + goto error; + } + + if (status != LTTNG_TRACKER_ID_STATUS_OK) { + ret = -LTTNG_ERR_INVALID; + goto error; + } + } + free(cmd_payload); + *_ids = ids; + return 0; + +error: + lttng_tracker_ids_destroy(ids); + free(cmd_payload); + free(cmd_header); + return ret; +} + +/* + * List PIDs in the tracker. + * + * enabled is set to whether the PID tracker is enabled. + * pids is set to an allocated array of PIDs currently tracked. On + * success, pids must be freed by the caller. + * nr_pids is set to the number of entries contained by the pids array. + * + * Returns 0 on success, else a negative LTTng error code. + */ +int lttng_list_tracker_pids(struct lttng_handle *handle, + int *_enabled, int32_t **_pids, size_t *_nr_pids) +{ + struct lttng_tracker_ids *ids = NULL; + unsigned int nr_ids = 0; + int *pids = NULL; + int ret = 0, i; + enum lttng_tracker_id_status status; + const struct lttng_tracker_id *id; + + ret = lttng_list_tracker_ids(handle, LTTNG_TRACKER_PID, &ids); if (ret < 0) { return ret; } - nr_pids = ret / sizeof(int32_t); - if (nr_pids > 0 && !pids) { - return -LTTNG_ERR_UNK; + + status = lttng_tracker_ids_get_count(ids, &nr_ids); + if (status != LTTNG_TRACKER_ID_STATUS_OK) { + ret = -LTTNG_ERR_INVALID; + goto end; } - if (nr_pids == 1 && pids[0] == -1) { - free(pids); - pids = NULL; - enabled = 0; - nr_pids = 0; + + if (nr_ids == 1) { + id = lttng_tracker_ids_get_at_index(ids, 0); + if (id && lttng_tracker_id_get_type(id) == LTTNG_ID_ALL) { + *_enabled = 0; + goto end; + } + } + + *_enabled = 1; + + pids = zmalloc(nr_ids * sizeof(*pids)); + if (!pids) { + ret = -LTTNG_ERR_NOMEM; + goto end; + } + for (i = 0; i < nr_ids; i++) { + id = lttng_tracker_ids_get_at_index(ids, i); + status = lttng_tracker_id_get_value(id, &pids[i]); + if (status != LTTNG_TRACKER_ID_STATUS_OK) { + ret = -LTTNG_ERR_UNK; + goto end; + } } - *_enabled = enabled; *_pids = pids; - *_nr_pids = nr_pids; - return 0; + *_nr_pids = nr_ids; +end: + lttng_tracker_ids_destroy(ids); + if (ret < 0) { + free(pids); + } + return ret; } /* @@ -3057,6 +3117,131 @@ end: return ret; } +static int lttng_track_untrack_id(struct lttng_handle *handle, + enum lttng_tracker_type tracker_type, + const struct lttng_tracker_id *id, + enum lttcomm_sessiond_command cmd) +{ + int ret; + struct lttcomm_session_msg lsm; + const char *var_data = NULL; + size_t var_data_len = 0; + int value; + enum lttng_tracker_id_status status; + + /* NULL arguments are forbidden. No default values. */ + if (handle == NULL) { + goto error; + } + + memset(&lsm, 0, sizeof(lsm)); + + lsm.cmd_type = cmd; + lsm.u.id_tracker.tracker_type = tracker_type; + lsm.u.id_tracker.id_type = lttng_tracker_id_get_type(id); + switch (lsm.u.id_tracker.id_type) { + case LTTNG_ID_ALL: + break; + case LTTNG_ID_VALUE: + status = lttng_tracker_id_get_value(id, &value); + if (status != LTTNG_TRACKER_ID_STATUS_OK) { + goto error; + } + lsm.u.id_tracker.u.value = value; + break; + case LTTNG_ID_STRING: + status = lttng_tracker_id_get_string(id, &var_data); + if (status != LTTNG_TRACKER_ID_STATUS_OK) { + goto error; + } + var_data_len = strlen(var_data) + 1; /* Includes \0. */ + lsm.u.id_tracker.u.var_len = var_data_len; + break; + default: + goto error; + } + + COPY_DOMAIN_PACKED(lsm.domain, handle->domain); + + lttng_ctl_copy_string(lsm.session.name, handle->session_name, + sizeof(lsm.session.name)); + + ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header( + &lsm, (char *) var_data, var_data_len, NULL); + return ret; +error: + return -LTTNG_ERR_INVALID; +} + +/* + * Add ID to session tracker. + * Return 0 on success else a negative LTTng error code. + */ +int lttng_track_id(struct lttng_handle *handle, + enum lttng_tracker_type tracker_type, + const struct lttng_tracker_id *id) +{ + return lttng_track_untrack_id(handle, tracker_type, id, LTTNG_TRACK_ID); +} + +/* + * Remove ID from session tracker. + * Return 0 on success else a negative LTTng error code. + */ +int lttng_untrack_id(struct lttng_handle *handle, + enum lttng_tracker_type tracker_type, + const struct lttng_tracker_id *id) +{ + return lttng_track_untrack_id( + handle, tracker_type, id, LTTNG_UNTRACK_ID); +} + +/* + * Add PID to session tracker. + * Return 0 on success else a negative LTTng error code. + */ +int lttng_track_pid(struct lttng_handle *handle, int pid) +{ + int ret; + struct lttng_tracker_id *id = NULL; + enum lttng_tracker_id_status status; + + id = lttng_tracker_id_create(); + status = lttng_tracker_id_set_value(id, pid); + if (status == LTTNG_TRACKER_ID_STATUS_INVALID) { + ret = -LTTNG_ERR_INVALID; + goto error; + } + + ret = lttng_track_id(handle, LTTNG_TRACKER_PID, id); +error: + lttng_tracker_id_destroy(id); + return ret; +} + +/* + * Remove PID from session tracker. + * Return 0 on success else a negative LTTng error code. + */ +int lttng_untrack_pid(struct lttng_handle *handle, int pid) +{ + int ret; + struct lttng_tracker_id *id = NULL; + enum lttng_tracker_id_status status; + + id = lttng_tracker_id_create(); + status = lttng_tracker_id_set_value(id, pid); + if (status == LTTNG_TRACKER_ID_STATUS_INVALID) { + ret = -LTTNG_ERR_INVALID; + goto error; + } + + ret = lttng_untrack_id(handle, LTTNG_TRACKER_PID, id); +error: + lttng_tracker_id_destroy(id); + return ret; +} + /* * lib constructor. */