*
* Linux Trace Toolkit Control Library
*
- * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
+ * Copyright (C) 2011 EfficiOS Inc.
* Copyright (C) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
*
* SPDX-License-Identifier: LGPL-2.1-only
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
+#include <stdint.h>
#include <string.h>
#include <unistd.h>
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.
*
return ret;
}
-static int check_enough_available_memory(size_t num_bytes_requested_per_cpu)
+static enum lttng_error_code check_enough_available_memory(
+ uint64_t num_bytes_requested_per_cpu)
{
int ret;
long num_cpu;
- size_t best_mem_info;
- size_t num_bytes_requested_total;
+ uint64_t best_mem_info;
+ uint64_t num_bytes_requested_total;
/*
* Get the number of CPU currently online to compute the amount of
*/
num_cpu = sysconf(_SC_NPROCESSORS_ONLN);
if (num_cpu == -1) {
- goto error;
+ ret = LTTNG_ERR_FATAL;
+ goto end;
}
- num_bytes_requested_total = num_bytes_requested_per_cpu * num_cpu;
+ if (num_bytes_requested_per_cpu > UINT64_MAX / (uint64_t) num_cpu) {
+ /* Overflow */
+ ret = LTTNG_ERR_OVERFLOW;
+ goto end;
+ }
+
+ num_bytes_requested_total =
+ num_bytes_requested_per_cpu * (uint64_t) num_cpu;
/*
* Try to get the `MemAvail` field of `/proc/meminfo`. This is the most
goto success;
}
-error:
- return -1;
+ /* No valid source of information. */
+ ret = LTTNG_ERR_NOMEM;
+ goto end;
+
success:
- return best_mem_info >= num_bytes_requested_total;
+ if (best_mem_info >= num_bytes_requested_total) {
+ ret = LTTNG_OK;
+ } else {
+ ret = LTTNG_ERR_NOMEM;
+ }
+end:
+ return ret;
}
/*
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) {
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));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
+
COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
- lttng_ctl_copy_string(lsm.u.reg.path, socket_path,
- sizeof(lsm.u.reg.path));
+ ret = lttng_strncpy(lsm.u.reg.path, socket_path,
+ sizeof(lsm.u.reg.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;
}
/*
*/
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) {
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;
}
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;
+ }
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);
}
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;
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)
{
struct lttng_channel *channel = NULL;
- struct lttng_channel_extended *extended = NULL;
if (!domain) {
- goto error;
+ goto end;
}
/* Validate domain. */
case LTTNG_BUFFER_PER_PID:
break;
default:
- goto error;
+ goto end;
}
break;
case LTTNG_DOMAIN_KERNEL:
if (domain->buf_type != LTTNG_BUFFER_GLOBAL) {
- goto error;
+ goto end;
}
break;
default:
- goto error;
+ goto end;
}
- channel = zmalloc(sizeof(*channel));
+ channel = lttng_channel_create_internal();
if (!channel) {
- goto error;
- }
-
- extended = zmalloc(sizeof(*extended));
- if (!extended) {
- goto error;
+ goto end;
}
- channel->attr.extended.ptr = extended;
-
lttng_channel_set_default_attr(domain, &channel->attr);
+end:
return channel;
-error:
- free(channel);
- free(extended);
- return NULL;
}
void lttng_channel_destroy(struct lttng_channel *channel)
int lttng_enable_channel(struct lttng_handle *handle,
struct lttng_channel *in_chan)
{
+ enum lttng_error_code ret_code;
+ int ret;
+ struct lttng_dynamic_buffer buffer;
struct lttcomm_session_msg lsm;
- size_t total_buffer_size_needed_per_cpu = 0;
+ uint64_t total_buffer_size_needed_per_cpu = 0;
+ struct lttng_channel *channel = NULL;
+
+ lttng_dynamic_buffer_init(&buffer);
/* NULL arguments are forbidden. No default values. */
if (handle == NULL || in_chan == NULL) {
- return -LTTNG_ERR_INVALID;
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
}
- memset(&lsm, 0, sizeof(lsm));
- memcpy(&lsm.u.channel.chan, in_chan, sizeof(lsm.u.channel.chan));
- lsm.u.channel.chan.attr.extended.ptr = NULL;
+ /*
+ * Verify that the amount of memory required to create the requested
+ * buffer is available on the system at the moment.
+ */
+ if (in_chan->attr.num_subbuf >
+ UINT64_MAX / in_chan->attr.subbuf_size) {
+ /* Overflow */
+ ret = -LTTNG_ERR_OVERFLOW;
+ goto end;
+ }
- if (!in_chan->attr.extended.ptr) {
- struct lttng_channel *channel;
- struct lttng_channel_extended *extended;
+ total_buffer_size_needed_per_cpu =
+ in_chan->attr.num_subbuf * in_chan->attr.subbuf_size;
+ ret_code = check_enough_available_memory(
+ total_buffer_size_needed_per_cpu);
+ if (ret_code != LTTNG_OK) {
+ ret = -ret_code;
+ goto end;
+ }
- channel = lttng_channel_create(&handle->domain);
- if (!channel) {
- return -LTTNG_ERR_NOMEM;
- }
+ /* Copy the channel for easier manipulation. */
+ channel = lttng_channel_copy(in_chan);
+ if (!channel) {
+ ret = -LTTNG_ERR_NOMEM;
+ goto end;
+ }
- /*
- * Create a new channel in order to use default extended
- * attribute values.
- */
- extended = (struct lttng_channel_extended *)
- channel->attr.extended.ptr;
- memcpy(&lsm.u.channel.extended, extended, sizeof(*extended));
- lttng_channel_destroy(channel);
- } else {
- struct lttng_channel_extended *extended;
+ /* Populate the channel extended attribute if necessary. */
+ if (!channel->attr.extended.ptr) {
+ struct lttng_channel_extended *extended =
+ zmalloc(sizeof(*extended));
- extended = (struct lttng_channel_extended *)
- in_chan->attr.extended.ptr;
- memcpy(&lsm.u.channel.extended, extended, sizeof(*extended));
+ if (!extended) {
+ ret = -LTTNG_ERR_NOMEM;
+ goto end;
+ }
+ lttng_channel_set_default_extended_attr(
+ &handle->domain, extended);
+ channel->attr.extended.ptr = extended;
}
- /*
- * Verify that the amount of memory required to create the requested
- * buffer is available on the system at the moment.
- */
- total_buffer_size_needed_per_cpu = lsm.u.channel.chan.attr.num_subbuf *
- lsm.u.channel.chan.attr.subbuf_size;
- if (!check_enough_available_memory(total_buffer_size_needed_per_cpu)) {
- return -LTTNG_ERR_NOMEM;
- }
+ /* Prepare the payload */
+ memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_ENABLE_CHANNEL;
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_channel_serialize(channel, &buffer);
+ if (ret) {
+ ret = -LTTNG_ERR_FATAL;
+ goto end;
+ }
+
+ lsm.u.channel.length = buffer.size;
+
+ ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header(
+ &lsm, buffer.data, buffer.size, NULL);
+end:
+ lttng_channel_destroy(channel);
+ lttng_dynamic_buffer_reset(&buffer);
+ 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;
+ }
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;
}
/*
enum lttng_error_code ret_code;
ret_code = lttng_destroy_session_ext(session_name, NULL);
- return ret_code == LTTNG_OK ? ret_code : -ret_code;
+ return ret_code == LTTNG_OK ? 0 : -ret_code;
}
/*
memset(&lsm, 0, sizeof(lsm));
lsm.cmd_type = LTTNG_LIST_SESSIONS;
+ /*
+ * Initialize out_sessions to NULL so it is initialized when
+ * lttng_list_sessions returns 0, thus allowing *out_sessions to
+ * be subsequently freed.
+ */
+ *out_sessions = NULL;
ret = lttng_ctl_ask_sessiond(&lsm, (void**) &sessions);
if (ret <= 0) {
goto end;
if (ret % session_size) {
ret = -LTTNG_ERR_UNK;
free(sessions);
- *out_sessions = NULL;
goto end;
}
session_count = (size_t) ret / session_size;
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;
}
/*
int lttng_list_channels(struct lttng_handle *handle,
struct lttng_channel **channels)
{
- int ret;
- size_t channel_count, i;
- const size_t channel_size = sizeof(struct lttng_channel) +
- sizeof(struct lttng_channel_extended);
+ int ret, total_payload_received;
struct lttcomm_session_msg lsm;
- void *extended_at;
+ char *reception_buffer = NULL;
+ size_t cmd_header_len = 0;
+ struct lttcomm_list_command_header *cmd_header = NULL;
+ struct lttng_dynamic_buffer tmp_buffer;
+
+ lttng_dynamic_buffer_init(&tmp_buffer);
if (handle == NULL) {
ret = -LTTNG_ERR_INVALID;
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;
+ }
COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
- ret = lttng_ctl_ask_sessiond(&lsm, (void**) channels);
+ ret = lttng_ctl_ask_sessiond_fds_varlen(&lsm, NULL, 0, NULL, 0,
+ (void **) &reception_buffer, (void **) &cmd_header,
+ &cmd_header_len);
if (ret < 0) {
goto end;
}
- if (ret % channel_size) {
- ret = -LTTNG_ERR_UNK;
- free(*channels);
- *channels = NULL;
+ total_payload_received = ret;
+
+ if (cmd_header_len != sizeof(*cmd_header)) {
+ ret = -LTTNG_ERR_FATAL;
+ goto end;
+ }
+
+ if (!cmd_header) {
+ ret = LTTNG_ERR_UNK;
goto end;
}
- channel_count = (size_t) ret / channel_size;
- /* Set extended info pointers */
- extended_at = ((void *) *channels) +
- channel_count * sizeof(struct lttng_channel);
- for (i = 0; i < channel_count; i++) {
- struct lttng_channel *chan = &(*channels)[i];
+ if (cmd_header->count > INT_MAX) {
+ ret = -LTTNG_ERR_OVERFLOW;
+ goto end;
+ }
- chan->attr.extended.ptr = extended_at;
- extended_at += sizeof(struct lttng_channel_extended);
+ {
+ enum lttng_error_code ret_code;
+ const struct lttng_buffer_view events_view =
+ lttng_buffer_view_init(reception_buffer, 0,
+ total_payload_received);
+
+ ret_code = lttng_channels_create_and_flatten_from_buffer(
+ &events_view, cmd_header->count, channels);
+ if (ret_code != LTTNG_OK) {
+ ret = -ret_code;
+ goto end;
+ }
}
- ret = (int) channel_count;
+ ret = (int) cmd_header->count;
end:
+ free(cmd_header);
+ free(reception_buffer);
return ret;
}
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));
+ 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,
*/
int lttng_set_tracing_group(const char *name)
{
+ char *new_group;
if (name == NULL) {
return -LTTNG_ERR_INVALID;
}
- if (asprintf(&tracing_group, "%s", name) < 0) {
+ if (asprintf(&new_group, "%s", name) < 0) {
return -LTTNG_ERR_FATAL;
}
+ free(tracing_group);
+ tracing_group = new_group;
+ new_group = NULL;
+
return 0;
}
return;
}
+ /* Save the pointer for later use */
extended = (struct lttng_channel_extended *) attr->extended.ptr;
memset(attr, 0, sizeof(struct lttng_channel_attr));
attr->subbuf_size = default_get_kernel_channel_subbuf_size();
attr->num_subbuf = DEFAULT_KERNEL_CHANNEL_SUBBUF_NUM;
attr->output = DEFAULT_KERNEL_CHANNEL_OUTPUT;
- if (extended) {
- extended->monitor_timer_interval =
- DEFAULT_KERNEL_CHANNEL_MONITOR_TIMER;
- extended->blocking_timeout =
- DEFAULT_KERNEL_CHANNEL_BLOCKING_TIMEOUT;
- }
break;
case LTTNG_DOMAIN_UST:
switch (domain->buf_type) {
DEFAULT_UST_UID_CHANNEL_SWITCH_TIMER;
attr->read_timer_interval =
DEFAULT_UST_UID_CHANNEL_READ_TIMER;
- if (extended) {
- extended->monitor_timer_interval =
- DEFAULT_UST_UID_CHANNEL_MONITOR_TIMER;
- extended->blocking_timeout =
- DEFAULT_UST_UID_CHANNEL_BLOCKING_TIMEOUT;
- }
break;
case LTTNG_BUFFER_PER_PID:
default:
DEFAULT_UST_PID_CHANNEL_SWITCH_TIMER;
attr->read_timer_interval =
DEFAULT_UST_PID_CHANNEL_READ_TIMER;
- if (extended) {
- extended->monitor_timer_interval =
- DEFAULT_UST_PID_CHANNEL_MONITOR_TIMER;
- extended->blocking_timeout =
- DEFAULT_UST_PID_CHANNEL_BLOCKING_TIMEOUT;
- }
break;
}
default:
break;
}
+ if (extended) {
+ lttng_channel_set_default_extended_attr(domain, extended);
+ }
+
+ /* Reassign the extended pointer. */
attr->extended.ptr = extended;
}
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));
+ 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) {
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) {