/*
* Fill lttng_channel array of all channels.
*/
-static void list_lttng_channels(enum lttng_domain_type domain,
+static ssize_t list_lttng_channels(enum lttng_domain_type domain,
struct ltt_session *session, struct lttng_channel *channels,
struct lttcomm_channel_extended *chan_exts)
{
- int i = 0, ret;
+ int i = 0, ret = 0;
struct ltt_kernel_channel *kchan;
DBG("Listing channels for session %s", session->name);
&iter.iter, uchan, node.node) {
uint64_t discarded_events = 0, lost_packets = 0;
- strncpy(channels[i].name, uchan->name, LTTNG_SYMBOL_NAME_LEN);
+ if (lttng_strncpy(channels[i].name, uchan->name,
+ LTTNG_SYMBOL_NAME_LEN)) {
+ break;
+ }
channels[i].attr.overwrite = uchan->attr.overwrite;
channels[i].attr.subbuf_size = uchan->attr.subbuf_size;
channels[i].attr.num_subbuf = uchan->attr.num_subbuf;
}
end:
- return;
+ if (ret < 0) {
+ return -LTTNG_ERR_FATAL;
+ } else {
+ return LTTNG_OK;
+ }
}
static void increment_extended_len(const char *filter_expression,
DBG2("Setting trace directory path from URI to %s", uri->dst.path);
memset(consumer->dst.trace_path, 0,
sizeof(consumer->dst.trace_path));
- strncpy(consumer->dst.trace_path, uri->dst.path,
- sizeof(consumer->dst.trace_path));
+ /* Explicit length checks for strcpy and strcat. */
+ if (strlen(uri->dst.path) + strlen(default_trace_dir)
+ >= sizeof(consumer->dst.trace_path)) {
+ ret = LTTNG_ERR_FATAL;
+ goto error;
+ }
+ strcpy(consumer->dst.trace_path, uri->dst.path);
/* Append default trace dir */
- strncat(consumer->dst.trace_path, default_trace_dir,
- sizeof(consumer->dst.trace_path) -
- strlen(consumer->dst.trace_path) - 1);
+ strcat(consumer->dst.trace_path, default_trace_dir);
/* Flag consumer as local. */
consumer->type = CONSUMER_DST_LOCAL;
break;
/*
* Connect to the relayd using URI and send the socket to the right consumer.
+ *
+ * The consumer socket lock must be held by the caller.
*/
static int send_consumer_relayd_socket(enum lttng_domain_type domain,
unsigned int session_id, struct lttng_uri *relayd_uri,
/* Connect to relayd and make version check if uri is the control. */
ret = create_connect_relayd(relayd_uri, &rsock, consumer);
if (ret != LTTNG_OK) {
- goto error;
+ goto relayd_comm_error;
}
assert(rsock);
*/
close_sock:
- (void) relayd_close(rsock);
- free(rsock);
-
-error:
if (ret != LTTNG_OK) {
/*
* The consumer output for this session should not be used anymore
*/
consumer->enabled = 0;
}
+ (void) relayd_close(rsock);
+ free(rsock);
+
+relayd_comm_error:
return ret;
}
* Send both relayd sockets to a specific consumer and domain. This is a
* helper function to facilitate sending the information to the consumer for a
* session.
+ *
+ * The consumer socket lock must be held by the caller.
*/
static int send_consumer_relayd_sockets(enum lttng_domain_type domain,
unsigned int session_id, struct consumer_output *consumer,
attr->attr.switch_timer_interval = 0;
}
- /*
- * The ringbuffer (both in user space and kernel) behave badly in overwrite
- * mode and with less than 2 subbuf so block it right away and send back an
- * invalid attribute error.
- */
- if (attr->attr.overwrite && attr->attr.num_subbuf < 2) {
- ret = LTTNG_ERR_INVALID;
- goto error;
- }
-
switch (domain->type) {
case LTTNG_DOMAIN_KERNEL:
{
int wpipe, bool internal_event)
{
int ret, channel_created = 0;
- struct lttng_channel *attr;
+ struct lttng_channel *attr = NULL;
assert(session);
assert(event);
ret = LTTNG_ERR_FATAL;
goto error;
}
- strncpy(attr->name, channel_name, sizeof(attr->name));
+ if (lttng_strncpy(attr->name, channel_name,
+ sizeof(attr->name))) {
+ ret = LTTNG_ERR_INVALID;
+ goto error;
+ }
ret = cmd_enable_channel(session, domain, attr, wpipe);
if (ret != LTTNG_OK) {
- free(attr);
goto error;
}
- free(attr);
-
channel_created = 1;
}
ret = LTTNG_ERR_FATAL;
goto error;
}
- strncpy(attr->name, channel_name, sizeof(attr->name));
+ if (lttng_strncpy(attr->name, channel_name,
+ sizeof(attr->name))) {
+ ret = LTTNG_ERR_INVALID;
+ goto error;
+ }
ret = cmd_enable_channel(session, domain, attr, wpipe);
if (ret != LTTNG_OK) {
- free(attr);
goto error;
}
- free(attr);
/* Get the newly created channel reference back */
uchan = trace_ust_find_channel_by_name(
free(filter_expression);
free(filter);
free(exclusion);
+ free(attr);
rcu_read_unlock();
return ret;
}
if (ksession && ksession->active) {
DBG("Stop kernel tracing");
- /* Flush metadata if exist */
+ ret = kernel_stop_session(ksession);
+ if (ret < 0) {
+ ret = LTTNG_ERR_KERN_STOP_FAIL;
+ goto error;
+ }
+
+ kernel_wait_quiescent(kernel_tracer_fd);
+
+ /* Flush metadata after stopping (if exists) */
if (ksession->metadata_stream_fd >= 0) {
ret = kernel_metadata_flush_buffer(ksession->metadata_stream_fd);
if (ret < 0) {
}
}
- /* Flush all buffers before stopping */
+ /* Flush all buffers after stopping */
cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) {
ret = kernel_flush_buffer(kchan);
if (ret < 0) {
}
}
- ret = kernel_stop_session(ksession);
- if (ret < 0) {
- ret = LTTNG_ERR_KERN_STOP_FAIL;
- goto error;
- }
-
- kernel_wait_quiescent(kernel_tracer_fd);
-
ksession->active = 0;
}
return ret;
}
-/*
- * Command LTTNG_CALIBRATE processed by the client thread.
- */
-int cmd_calibrate(enum lttng_domain_type domain,
- struct lttng_calibrate *calibrate)
-{
- int ret;
-
- switch (domain) {
- case LTTNG_DOMAIN_KERNEL:
- {
- struct lttng_kernel_calibrate kcalibrate;
-
- switch (calibrate->type) {
- case LTTNG_CALIBRATE_FUNCTION:
- default:
- /* Default and only possible calibrate option. */
- kcalibrate.type = LTTNG_KERNEL_CALIBRATE_KRETPROBE;
- break;
- }
-
- ret = kernel_calibrate(kernel_tracer_fd, &kcalibrate);
- if (ret < 0) {
- ret = LTTNG_ERR_KERN_ENABLE_FAIL;
- goto error;
- }
- break;
- }
- case LTTNG_DOMAIN_UST:
- {
- struct lttng_ust_calibrate ucalibrate;
-
- switch (calibrate->type) {
- case LTTNG_CALIBRATE_FUNCTION:
- default:
- /* Default and only possible calibrate option. */
- ucalibrate.type = LTTNG_UST_CALIBRATE_TRACEPOINT;
- break;
- }
-
- ret = ust_app_calibrate_glb(&ucalibrate);
- if (ret < 0) {
- ret = LTTNG_ERR_UST_CALIBRATE_FAIL;
- goto error;
- }
- break;
- }
- default:
- ret = LTTNG_ERR_UND;
- goto error;
- }
-
- ret = LTTNG_OK;
-
-error:
- return ret;
-}
-
/*
* Command LTTNG_REGISTER_CONSUMER processed by the client thread.
*/
channel_exts = ((void *) *channels) +
(nb_chan * sizeof(struct lttng_channel));
- list_lttng_channels(domain, session, *channels, channel_exts);
+ ret = list_lttng_channels(domain, session, *channels, channel_exts);
+ if (ret != LTTNG_OK) {
+ free(*channels);
+ *channels = NULL;
+ goto end;
+ }
} else {
*channels = NULL;
}
DBG("Cmd snapshot add output for session %s", session->name);
/*
- * Permission denied to create an output if the session is not
- * set in no output mode.
+ * Can't create an output if the session is not set in no-output mode.
*/
if (session->output_traces) {
- ret = LTTNG_ERR_EPERM;
+ ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
goto error;
}
* set in no output mode.
*/
if (session->output_traces) {
- ret = LTTNG_ERR_EPERM;
+ ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
goto error;
}
* set in no output mode.
*/
if (session->output_traces) {
- ret = -LTTNG_ERR_EPERM;
- goto error;
+ ret = -LTTNG_ERR_NOT_SNAPSHOT_SESSION;
+ goto end;
}
if (session->snapshot.nb_output == 0) {
ret = 0;
- goto error;
+ goto end;
}
list = zmalloc(session->snapshot.nb_output * sizeof(*list));
if (!list) {
ret = -LTTNG_ERR_NOMEM;
- goto error;
+ goto end;
}
/* Copy list from session to the new list object. */
assert(output->consumer);
list[idx].id = output->id;
list[idx].max_size = output->max_size;
- strncpy(list[idx].name, output->name, sizeof(list[idx].name));
+ if (lttng_strncpy(list[idx].name, output->name,
+ sizeof(list[idx].name))) {
+ ret = -LTTNG_ERR_INVALID;
+ goto error;
+ }
if (output->consumer->type == CONSUMER_DST_LOCAL) {
- strncpy(list[idx].ctrl_url, output->consumer->dst.trace_path,
- sizeof(list[idx].ctrl_url));
+ if (lttng_strncpy(list[idx].ctrl_url,
+ output->consumer->dst.trace_path,
+ sizeof(list[idx].ctrl_url))) {
+ ret = -LTTNG_ERR_INVALID;
+ goto error;
+ }
} else {
/* Control URI. */
ret = uri_to_str_url(&output->consumer->dst.net.control,
list = NULL;
ret = session->snapshot.nb_output;
error:
- free(list);
rcu_read_unlock();
+ free(list);
+end:
return ret;
}
* Return 0 if the metadata can be generated, a LTTNG_ERR code otherwise.
*/
static
-int check_metadata_regenerate_support(struct ltt_session *session)
+int check_regenerate_metadata_support(struct ltt_session *session)
{
int ret;
}
static
-int ust_metadata_regenerate(struct ltt_ust_session *usess)
+int clear_metadata_file(int fd)
+{
+ int ret;
+
+ ret = lseek(fd, 0, SEEK_SET);
+ if (ret < 0) {
+ PERROR("lseek");
+ goto end;
+ }
+
+ ret = ftruncate(fd, 0);
+ if (ret < 0) {
+ PERROR("ftruncate");
+ goto end;
+ }
+
+end:
+ return ret;
+}
+
+static
+int ust_regenerate_metadata(struct ltt_ust_session *usess)
{
int ret = 0;
struct buffer_reg_uid *uid_reg = NULL;
memset(registry->metadata, 0, registry->metadata_alloc_len);
registry->metadata_len = 0;
registry->metadata_version++;
+ if (registry->metadata_fd > 0) {
+ /* Clear the metadata file's content. */
+ ret = clear_metadata_file(registry->metadata_fd);
+ if (ret) {
+ pthread_mutex_unlock(®istry->lock);
+ goto end;
+ }
+ }
+
ret = ust_metadata_session_statedump(registry, NULL,
registry->major, registry->minor);
if (ret) {
}
/*
- * Command LTTNG_METADATA_REGENERATE from the lttng-ctl library.
+ * Command LTTNG_REGENERATE_METADATA from the lttng-ctl library.
*
* Ask the consumer to truncate the existing metadata file(s) and
* then regenerate the metadata. Live and per-pid sessions are not
*
* Return 0 on success or else a LTTNG_ERR code.
*/
-int cmd_metadata_regenerate(struct ltt_session *session)
+int cmd_regenerate_metadata(struct ltt_session *session)
{
int ret;
assert(session);
- ret = check_metadata_regenerate_support(session);
+ ret = check_regenerate_metadata_support(session);
if (ret) {
goto end;
}
if (session->kernel_session) {
- ret = kernctl_session_metadata_regenerate(
+ ret = kernctl_session_regenerate_metadata(
session->kernel_session->fd);
if (ret < 0) {
ERR("Failed to regenerate the kernel metadata");
}
if (session->ust_session) {
- ret = ust_metadata_regenerate(session->ust_session);
+ ret = ust_regenerate_metadata(session->ust_session);
if (ret < 0) {
ERR("Failed to regenerate the UST metadata");
goto end;
return ret;
}
+/*
+ * Command LTTNG_REGENERATE_STATEDUMP from the lttng-ctl library.
+ *
+ * Ask the tracer to regenerate a new statedump.
+ *
+ * Return 0 on success or else a LTTNG_ERR code.
+ */
+int cmd_regenerate_statedump(struct ltt_session *session)
+{
+ int ret;
+
+ assert(session);
+
+ if (!session->active) {
+ ret = LTTNG_ERR_SESSION_NOT_STARTED;
+ goto end;
+ }
+ ret = 0;
+
+ if (session->kernel_session) {
+ ret = kernctl_session_regenerate_statedump(
+ session->kernel_session->fd);
+ /*
+ * Currently, the statedump in kernel can only fail if out
+ * of memory.
+ */
+ if (ret < 0) {
+ if (ret == -ENOMEM) {
+ ret = LTTNG_ERR_REGEN_STATEDUMP_NOMEM;
+ } else {
+ ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL;
+ }
+ ERR("Failed to regenerate the kernel statedump");
+ goto end;
+ }
+ }
+
+ if (session->ust_session) {
+ ret = ust_app_regenerate_statedump_all(session->ust_session);
+ /*
+ * Currently, the statedump in UST always returns 0.
+ */
+ if (ret < 0) {
+ ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL;
+ ERR("Failed to regenerate the UST statedump");
+ goto end;
+ }
+ }
+ DBG("Cmd regenerate statedump for session %s", session->name);
+ ret = LTTNG_OK;
+
+end:
+ return ret;
+}
/*
* Send relayd sockets from snapshot output to consumer. Ignore request if the
case EINVAL:
ret = LTTNG_ERR_INVALID;
break;
- case ENODATA:
- ret = LTTNG_ERR_SNAPSHOT_NODATA;
- break;
default:
ret = LTTNG_ERR_SNAPSHOT_FAIL;
break;
* set in no output mode.
*/
if (session->output_traces) {
- ret = LTTNG_ERR_EPERM;
+ ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION;
goto error;
}
/* Use temporary name. */
if (*output->name != '\0') {
- strncpy(tmp_output.name, output->name,
- sizeof(tmp_output.name));
+ if (lttng_strncpy(tmp_output.name, output->name,
+ sizeof(tmp_output.name))) {
+ ret = LTTNG_ERR_INVALID;
+ rcu_read_unlock();
+ goto error;
+ }
}
tmp_output.nb_snapshot = session->snapshot.nb_snapshot;