#include <lttng/userspace-probe-internal.h>
#include <lttng/session-internal.h>
#include <lttng/session-descriptor-internal.h>
+#include <lttng/destruction-handle.h>
#include "filter/filter-ast.h"
#include "filter/filter-parser.h"
} 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 */
int lttng_opt_verbose;
int lttng_opt_mi;
-/*
- * Copy string from src to dst and enforce null terminated byte.
- */
-LTTNG_HIDDEN
-void lttng_ctl_copy_string(char *dst, const char *src, size_t len)
-{
- if (src && dst) {
- strncpy(dst, src, len);
- /* Enforce the NULL terminated byte */
- dst[len - 1] = '\0';
- } else if (dst) {
- dst[0] = '\0';
- }
-}
-
/*
* Copy domain to lttcomm_session_msg domain.
*
in_tgroup = lttng_check_tracing_group();
}
- if ((uid == 0) || in_tgroup) {
- lttng_ctl_copy_string(sessiond_sock_path,
- DEFAULT_GLOBAL_CLIENT_UNIX_SOCK, sizeof(sessiond_sock_path));
+ if ((uid == 0) || in_tgroup == 1) {
+ const int ret = lttng_strncpy(sessiond_sock_path,
+ DEFAULT_GLOBAL_CLIENT_UNIX_SOCK,
+ sizeof(sessiond_sock_path));
+
+ if (ret) {
+ goto error;
+ }
}
if (uid != 0) {
/*
* 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;
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.
*
if (connected) {
ret = lttcomm_close_unix_sock(sessiond_socket);
- sessiond_socket = 0;
- connected = 0;
+ reset_global_sessiond_connection_state();
}
return ret;
if (ret < 0) {
ret = -LTTNG_ERR_NO_SESSIOND;
goto end;
+ } else {
+ sessiond_socket = ret;
+ connected = 1;
}
/* Send command to session daemon */
struct lttng_handle *lttng_create_handle(const char *session_name,
struct lttng_domain *domain)
{
+ int ret;
struct lttng_handle *handle = NULL;
handle = zmalloc(sizeof(struct lttng_handle));
}
/* Copy session name */
- lttng_ctl_copy_string(handle->session_name, session_name,
- sizeof(handle->session_name));
+ ret = lttng_strncpy(handle->session_name, session_name ? : "",
+ sizeof(handle->session_name));
+ if (ret) {
+ goto error;
+ }
/* Copy lttng domain or leave initialized to 0. */
if (domain) {
end:
return handle;
+error:
+ free(handle);
+ return NULL;
}
/*
int lttng_register_consumer(struct lttng_handle *handle,
const char *socket_path)
{
+ int ret;
struct lttcomm_session_msg lsm;
if (handle == NULL || socket_path == NULL) {
- return -LTTNG_ERR_INVALID;
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
}
memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_REGISTER_CONSUMER;
- lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+ ret = lttng_strncpy(lsm.session.name, handle->session_name,
sizeof(lsm.session.name));
- lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
- lttng_ctl_copy_string(lsm.u.reg.path, socket_path,
- sizeof(lsm.u.reg.path));
+ COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
- return lttng_ctl_ask_sessiond(&lsm, NULL);
+ ret = lttng_strncpy(lsm.u.reg.path, socket_path,
+ sizeof(lsm.u.reg.path));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
+
+ ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+ return ret;
}
/*
*/
int lttng_start_tracing(const char *session_name)
{
+ int ret;
struct lttcomm_session_msg lsm;
if (session_name == NULL) {
- return -LTTNG_ERR_INVALID;
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
}
memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_START_TRACE;
- lttng_ctl_copy_string(lsm.session.name, session_name,
- sizeof(lsm.session.name));
+ ret = lttng_strncpy(lsm.session.name, session_name,
+ sizeof(lsm.session.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
- return lttng_ctl_ask_sessiond(&lsm, NULL);
+ ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+ return ret;
}
/*
struct lttcomm_session_msg lsm;
if (session_name == NULL) {
- return -LTTNG_ERR_INVALID;
+ ret = -LTTNG_ERR_INVALID;
+ goto error;
}
memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_STOP_TRACE;
- lttng_ctl_copy_string(lsm.session.name, session_name,
- sizeof(lsm.session.name));
+ ret = lttng_strncpy(lsm.session.name, session_name,
+ sizeof(lsm.session.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto error;
+ }
ret = lttng_ctl_ask_sessiond(&lsm, NULL);
if (ret < 0 && ret != -LTTNG_ERR_TRACE_ALREADY_STOPPED) {
* 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);
lsm.cmd_type = LTTNG_ADD_CONTEXT;
/* If no channel name, send empty string. */
- if (channel_name == NULL) {
- lttng_ctl_copy_string(lsm.u.context.channel_name, "",
- sizeof(lsm.u.context.channel_name));
- } else {
- lttng_ctl_copy_string(lsm.u.context.channel_name, channel_name,
- sizeof(lsm.u.context.channel_name));
+ ret = lttng_strncpy(lsm.u.context.channel_name, channel_name ?: "",
+ sizeof(lsm.u.context.channel_name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
}
- lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
- lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+ COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
+ ret = lttng_strncpy(lsm.session.name, handle->session_name,
sizeof(lsm.session.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
if (ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT) {
size_t provider_len, ctx_len;
memset(&lsm, 0, sizeof(lsm));
/* If no channel name, send empty string. */
- if (channel_name == NULL) {
- lttng_ctl_copy_string(lsm.u.enable.channel_name, "",
- sizeof(lsm.u.enable.channel_name));
- } else {
- lttng_ctl_copy_string(lsm.u.enable.channel_name, channel_name,
- sizeof(lsm.u.enable.channel_name));
+ ret = lttng_strncpy(lsm.u.enable.channel_name, channel_name ?: "",
+ sizeof(lsm.u.enable.channel_name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto error;
}
lsm.cmd_type = LTTNG_ENABLE_EVENT;
if (ev->name[0] == '\0') {
- /* Enable all events */
- lttng_ctl_copy_string(ev->name, "*", sizeof(ev->name));
+ /* Enable all events. */
+ ret = lttng_strncpy(ev->name, "*", sizeof(ev->name));
+ assert(ret == 0);
}
- 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,
+ ret = lttng_strncpy(lsm.session.name, handle->session_name,
sizeof(lsm.session.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto error;
+ }
+
lsm.u.enable.exclusion_count = exclusion_count;
lsm.u.enable.bytecode_len = 0;
memset(&lsm, 0, sizeof(lsm));
/* If no channel name, send empty string. */
- if (channel_name == NULL) {
- lttng_ctl_copy_string(lsm.u.disable.channel_name, "",
- sizeof(lsm.u.disable.channel_name));
- } else {
- lttng_ctl_copy_string(lsm.u.disable.channel_name, channel_name,
- sizeof(lsm.u.disable.channel_name));
+ ret = lttng_strncpy(lsm.u.disable.channel_name, channel_name ?: "",
+ sizeof(lsm.u.disable.channel_name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto error;
}
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,
+ ret = lttng_strncpy(lsm.session.name, handle->session_name,
sizeof(lsm.session.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto error;
+ }
+
lsm.u.disable.bytecode_len = 0;
/*
int lttng_disable_event(struct lttng_handle *handle, const char *name,
const char *channel_name)
{
+ int ret;
struct lttng_event ev;
memset(&ev, 0, sizeof(ev));
ev.loglevel = -1;
ev.type = LTTNG_EVENT_ALL;
- lttng_ctl_copy_string(ev.name, name, sizeof(ev.name));
- return lttng_disable_event_ext(handle, &ev, channel_name, NULL);
+ ret = lttng_strncpy(ev.name, name ?: "", sizeof(ev.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
+
+ ret = lttng_disable_event_ext(handle, &ev, channel_name, NULL);
+end:
+ return ret;
}
struct lttng_channel *lttng_channel_create(struct lttng_domain *domain)
int lttng_enable_channel(struct lttng_handle *handle,
struct lttng_channel *in_chan)
{
+ int ret;
struct lttcomm_session_msg lsm;
size_t total_buffer_size_needed_per_cpu = 0;
}
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));
+ ret = lttng_strncpy(lsm.session.name, handle->session_name,
+ sizeof(lsm.session.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
- return lttng_ctl_ask_sessiond(&lsm, NULL);
+ ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+ return ret;
}
/*
*/
int lttng_disable_channel(struct lttng_handle *handle, const char *name)
{
+ int ret;
struct lttcomm_session_msg lsm;
/* Safety check. Both are mandatory. */
lsm.cmd_type = LTTNG_DISABLE_CHANNEL;
- lttng_ctl_copy_string(lsm.u.disable.channel_name, name,
+ ret = lttng_strncpy(lsm.u.disable.channel_name, name,
sizeof(lsm.u.disable.channel_name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
- 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));
+ ret = lttng_strncpy(lsm.session.name, handle->session_name,
+ sizeof(lsm.session.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
- return lttng_ctl_ask_sessiond(&lsm, NULL);
+ ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+ return ret;
}
/*
*/
int lttng_track_pid(struct lttng_handle *handle, int pid)
{
+ int ret;
struct lttcomm_session_msg lsm;
/* NULL arguments are forbidden. No default values. */
lsm.cmd_type = LTTNG_TRACK_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,
+ ret = lttng_strncpy(lsm.session.name, handle->session_name,
sizeof(lsm.session.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
- return lttng_ctl_ask_sessiond(&lsm, NULL);
+ ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+ return ret;
}
/*
*/
int lttng_untrack_pid(struct lttng_handle *handle, int pid)
{
+ int ret;
struct lttcomm_session_msg lsm;
/* NULL arguments are forbidden. No default values. */
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));
+ ret = lttng_strncpy(lsm.session.name, handle->session_name,
+ sizeof(lsm.session.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
- return lttng_ctl_ask_sessiond(&lsm, NULL);
+ ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+ return ret;
}
/*
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) {
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) {
/*
* 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)
{
/*
* 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)
{
/*
* 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)
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;
}
*/
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 ? 0 : -ret_code;
}
/*
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) {
int lttng_set_session_shm_path(const char *session_name,
const char *shm_path)
{
+ int ret;
struct lttcomm_session_msg lsm;
if (session_name == NULL) {
memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_SET_SESSION_SHM_PATH;
- lttng_ctl_copy_string(lsm.session.name, session_name,
+ ret = lttng_strncpy(lsm.session.name, session_name,
sizeof(lsm.session.name));
- lttng_ctl_copy_string(lsm.u.set_shm_path.shm_path, shm_path,
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
+
+ ret = lttng_strncpy(lsm.u.set_shm_path.shm_path, shm_path ?: "",
sizeof(lsm.u.set_shm_path.shm_path));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
- return lttng_ctl_ask_sessiond(&lsm, NULL);
+ ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+ return ret;
}
/*
struct lttcomm_session_msg lsm;
if (session_name == NULL) {
- return -LTTNG_ERR_INVALID;
+ ret = -LTTNG_ERR_INVALID;
+ goto error;
}
memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_LIST_DOMAINS;
- lttng_ctl_copy_string(lsm.session.name, session_name,
+ ret = lttng_strncpy(lsm.session.name, session_name,
sizeof(lsm.session.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto error;
+ }
ret = lttng_ctl_ask_sessiond(&lsm, (void**) domains);
if (ret < 0) {
- return ret;
+ goto error;
}
return ret / sizeof(struct lttng_domain);
+error:
+ return ret;
}
/*
memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_LIST_CHANNELS;
- lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+ ret = lttng_strncpy(lsm.session.name, handle->session_name,
sizeof(lsm.session.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
- 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) {
memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_LIST_EVENTS;
- lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+ ret = lttng_strncpy(lsm.session.name, handle->session_name,
sizeof(lsm.session.name));
- lttng_ctl_copy_string(lsm.u.list.channel_name, channel_name,
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
+
+ ret = lttng_strncpy(lsm.u.list.channel_name, channel_name,
sizeof(lsm.u.list.channel_name));
- lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
+
+ 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,
struct lttng_uri *uris = NULL;
if (handle == NULL || (control_url == NULL && data_url == NULL)) {
- return -LTTNG_ERR_INVALID;
+ ret = -LTTNG_ERR_INVALID;
+ goto error;
}
memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_SET_CONSUMER_URI;
- lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+ ret = lttng_strncpy(lsm.session.name, handle->session_name,
sizeof(lsm.session.name));
- lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto error;
+ }
+
+ COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
size = uri_parse_str_urls(control_url, data_url, &uris);
if (size < 0) {
- return -LTTNG_ERR_INVALID;
+ ret = -LTTNG_ERR_INVALID;
+ goto error;
}
lsm.u.uri.size = size;
sizeof(struct lttng_uri) * size, NULL);
free(uris);
+error:
return ret;
}
memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_DATA_PENDING;
- lttng_ctl_copy_string(lsm.session.name, session_name,
+ ret = lttng_strncpy(lsm.session.name, session_name,
sizeof(lsm.session.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
ret = lttng_ctl_ask_sessiond(&lsm, (void **) &pending);
if (ret < 0) {
/* Unexpected payload size */
ret = -LTTNG_ERR_INVALID;
goto end;
+ } else if (!pending) {
+ /* Internal error. */
+ ret = -LTTNG_ERR_UNK;
+ goto end;
}
ret = (int) *pending;
memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_LIST_TRACKER_PIDS;
- lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+ ret = lttng_strncpy(lsm.session.name, handle->session_name,
sizeof(lsm.session.name));
- lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+ if (ret) {
+ return -LTTNG_ERR_INVALID;
+ }
+ COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
ret = lttng_ctl_ask_sessiond(&lsm, (void **) &pids);
if (ret < 0) {
memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_REGENERATE_METADATA;
- lttng_ctl_copy_string(lsm.session.name, session_name,
+ ret = lttng_strncpy(lsm.session.name, session_name,
sizeof(lsm.session.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
ret = lttng_ctl_ask_sessiond(&lsm, NULL);
if (ret < 0) {
memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_REGENERATE_STATEDUMP;
- lttng_ctl_copy_string(lsm.session.name, session_name,
+ ret = lttng_strncpy(lsm.session.name, session_name,
sizeof(lsm.session.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
ret = lttng_ctl_ask_sessiond(&lsm, NULL);
if (ret < 0) {
projects / lttng-tools.git / blobdiff