static pthread_mutex_t relayd_net_seq_idx_lock = PTHREAD_MUTEX_INITIALIZER;
static uint64_t relayd_net_seq_idx;
+static int validate_event_name(const char *);
+static int validate_ust_event_name(const char *);
+static int cmd_enable_event_internal(struct ltt_session *session,
+ struct lttng_domain *domain,
+ char *channel_name, struct lttng_event *event,
+ char *filter_expression,
+ struct lttng_filter_bytecode *filter,
+ struct lttng_event_exclusion *exclusion,
+ int wpipe);
+
/*
* Create a session path used by list_lttng_sessions for the case that the
* session consumer is on the network.
strncpy(tmp_events[i].name, event->name, sizeof(tmp_events[i].name));
tmp_events[i].name[sizeof(tmp_events[i].name) - 1] = '\0';
tmp_events[i].enabled = event->enabled;
- tmp_events[i].loglevel = event->loglevel;
+ tmp_events[i].loglevel = event->loglevel_value;
tmp_events[i].loglevel_type = event->loglevel_type;
i++;
}
uchan = caa_container_of(&node->node, struct ltt_ust_channel, node.node);
- nb_event += lttng_ht_get_count(uchan->events);
-
+ nb_event = lttng_ht_get_count(uchan->events);
if (nb_event == 0) {
ret = nb_event;
goto error;
}
cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
+ if (uevent->internal) {
+ /* This event should remain hidden from clients */
+ nb_event--;
+ continue;
+ }
strncpy(tmp[i].name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN);
tmp[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
tmp[i].enabled = uevent->enabled;
if (nb_event == 0) {
*events = NULL;
- goto syscall;
+ goto end;
}
*events = zmalloc(nb_event * sizeof(struct lttng_event));
strncpy((*events)[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN);
(*events)[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
(*events)[i].enabled = event->enabled;
+ (*events)[i].filter =
+ (unsigned char) !!event->filter_expression;
switch (event->event->instrumentation) {
case LTTNG_KERNEL_TRACEPOINT:
i++;
}
-syscall:
- if (syscall_table) {
- ssize_t new_size;
-
- new_size = syscall_list_channel(kchan, events, nb_event);
- if (new_size < 0) {
- free(events);
- ret = -new_size;
- goto error;
- }
- nb_event = new_size;
- }
-
+end:
return nb_event;
error:
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;
break;
}
case LTTNG_DOMAIN_UST:
+ case LTTNG_DOMAIN_JUL:
+ case LTTNG_DOMAIN_LOG4J:
+ case LTTNG_DOMAIN_PYTHON:
{
struct ltt_ust_channel *uchan;
+ /*
+ * FIXME
+ *
+ * Current agent implementation limitations force us to allow
+ * only one channel at once in "agent" subdomains. Each
+ * subdomain has a default channel name which must be strictly
+ * adhered to.
+ */
+ if (domain->type == LTTNG_DOMAIN_JUL) {
+ if (strncmp(attr->name, DEFAULT_JUL_CHANNEL_NAME,
+ LTTNG_SYMBOL_NAME_LEN)) {
+ ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
+ goto error;
+ }
+ } else if (domain->type == LTTNG_DOMAIN_LOG4J) {
+ if (strncmp(attr->name, DEFAULT_LOG4J_CHANNEL_NAME,
+ LTTNG_SYMBOL_NAME_LEN)) {
+ ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
+ goto error;
+ }
+ } else if (domain->type == LTTNG_DOMAIN_PYTHON) {
+ if (strncmp(attr->name, DEFAULT_PYTHON_CHANNEL_NAME,
+ LTTNG_SYMBOL_NAME_LEN)) {
+ ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
+ goto error;
+ }
+ }
+
chan_ht = usess->domain_global.channels;
uchan = trace_ust_find_channel_by_name(chan_ht, attr->name);
DBG("Disable event command for event \'%s\'", event->name);
event_name = event->name;
+ if (validate_event_name(event_name)) {
+ ret = LTTNG_ERR_INVALID_EVENT_NAME;
+ goto error;
+ }
/* Error out on unhandled search criteria */
if (event->loglevel_type || event->loglevel != -1 || event->enabled
|| event->pid || event->filter || event->exclusion) {
- return LTTNG_ERR_UNK;
+ ret = LTTNG_ERR_UNK;
+ goto error;
}
rcu_read_lock();
*/
if (ksess->has_non_default_channel && channel_name[0] == '\0') {
ret = LTTNG_ERR_NEED_CHANNEL_NAME;
- goto error;
+ goto error_unlock;
}
kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
if (kchan == NULL) {
ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
- goto error;
+ goto error_unlock;
}
switch (event->type) {
case LTTNG_EVENT_ALL:
- ret = event_kernel_disable_event_all(kchan);
- if (ret != LTTNG_OK) {
- goto error;
- }
- break;
- case LTTNG_EVENT_TRACEPOINT: /* fall-through */
+ case LTTNG_EVENT_TRACEPOINT:
case LTTNG_EVENT_SYSCALL:
- if (!strcmp(event_name, "*")) {
- ret = event_kernel_disable_event_type(kchan,
- event->type);
+ case LTTNG_EVENT_PROBE:
+ case LTTNG_EVENT_FUNCTION:
+ case LTTNG_EVENT_FUNCTION_ENTRY:/* fall-through */
+ if (event_name[0] == '\0') {
+ ret = event_kernel_disable_event(kchan,
+ NULL, event->type);
} else {
ret = event_kernel_disable_event(kchan,
- event_name);
+ event_name, event->type);
}
if (ret != LTTNG_OK) {
- goto error;
- }
- break;
- case LTTNG_EVENT_PROBE:
- case LTTNG_EVENT_FUNCTION:
- case LTTNG_EVENT_FUNCTION_ENTRY:
- ret = event_kernel_disable_event(kchan, event_name);
- if (ret != LTTNG_OK) {
- goto error;
+ goto error_unlock;
}
break;
default:
ret = LTTNG_ERR_UNK;
- goto error;
+ goto error_unlock;
}
kernel_wait_quiescent(kernel_tracer_fd);
usess = session->ust_session;
+ if (validate_ust_event_name(event_name)) {
+ ret = LTTNG_ERR_INVALID_EVENT_NAME;
+ goto error_unlock;
+ }
+
/*
* If a non-default channel has been created in the
- * session, explicitely require that -c chan_name needs
+ * session, explicitly require that -c chan_name needs
* to be provided.
*/
if (usess->has_non_default_channel && channel_name[0] == '\0') {
ret = LTTNG_ERR_NEED_CHANNEL_NAME;
- goto error;
+ goto error_unlock;
}
uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
channel_name);
if (uchan == NULL) {
ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
- goto error;
+ goto error_unlock;
}
switch (event->type) {
case LTTNG_EVENT_ALL:
- ret = event_ust_disable_tracepoint(usess, uchan, event_name);
+ /*
+ * An empty event name means that everything
+ * should be disabled.
+ */
+ if (event->name[0] == '\0') {
+ ret = event_ust_disable_all_tracepoints(usess, uchan);
+ } else {
+ ret = event_ust_disable_tracepoint(usess, uchan,
+ event_name);
+ }
if (ret != LTTNG_OK) {
- goto error;
+ goto error_unlock;
}
break;
default:
ret = LTTNG_ERR_UNK;
- goto error;
+ goto error_unlock;
}
DBG3("Disable UST event %s in channel %s completed", event_name,
break;
default:
ret = LTTNG_ERR_UNK;
- goto error;
+ goto error_unlock;
}
agt = trace_ust_find_agent(usess, domain);
if (!agt) {
ret = -LTTNG_ERR_UST_EVENT_NOT_FOUND;
- goto error;
+ goto error_unlock;
}
- /* The wild card * means that everything should be disabled. */
- if (strncmp(event->name, "*", 1) == 0 && strlen(event->name) == 1) {
+ /*
+ * An empty event name means that everything
+ * should be disabled.
+ */
+ if (event->name[0] == '\0') {
ret = event_agent_disable_all(usess, agt);
} else {
ret = event_agent_disable(usess, agt, event_name);
}
if (ret != LTTNG_OK) {
- goto error;
+ goto error_unlock;
}
break;
}
default:
ret = LTTNG_ERR_UND;
- goto error;
+ goto error_unlock;
}
ret = LTTNG_OK;
-error:
+error_unlock:
rcu_read_unlock();
+error:
return ret;
}
return ret;
}
+static inline bool name_starts_with(const char *name, const char *prefix)
+{
+ const size_t max_cmp_len = min(strlen(prefix), LTTNG_SYMBOL_NAME_LEN);
+
+ return !strncmp(name, prefix, max_cmp_len);
+}
+
+/* Perform userspace-specific event name validation */
+static int validate_ust_event_name(const char *name)
+{
+ int ret = 0;
+
+ if (!name) {
+ ret = -1;
+ goto end;
+ }
+
+ /*
+ * Check name against all internal UST event component namespaces used
+ * by the agents.
+ */
+ if (name_starts_with(name, DEFAULT_JUL_EVENT_COMPONENT) ||
+ name_starts_with(name, DEFAULT_LOG4J_EVENT_COMPONENT) ||
+ name_starts_with(name, DEFAULT_PYTHON_EVENT_COMPONENT)) {
+ ret = -1;
+ }
+
+end:
+ return ret;
+}
+
/*
- * Command LTTNG_ENABLE_EVENT processed by the client thread.
- * We own filter, exclusion, and filter_expression.
+ * Internal version of cmd_enable_event() with a supplemental
+ * "internal_event" flag which is used to enable internal events which should
+ * be hidden from clients. Such events are used in the agent implementation to
+ * enable the events through which all "agent" events are funeled.
*/
-int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain,
+static int _cmd_enable_event(struct ltt_session *session,
+ struct lttng_domain *domain,
char *channel_name, struct lttng_event *event,
char *filter_expression,
struct lttng_filter_bytecode *filter,
struct lttng_event_exclusion *exclusion,
- int wpipe)
+ int wpipe, bool internal_event)
{
int ret, channel_created = 0;
struct lttng_channel *attr;
DBG("Enable event command for event \'%s\'", event->name);
+ rcu_read_lock();
+
ret = validate_event_name(event->name);
if (ret) {
goto error;
}
- rcu_read_lock();
-
switch (domain->type) {
case LTTNG_DOMAIN_KERNEL:
{
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;
+ free(attr);
+ goto error;
+ }
ret = cmd_enable_channel(session, domain, attr, wpipe);
if (ret != LTTNG_OK) {
event->type = LTTNG_EVENT_TRACEPOINT; /* Hack */
ret = event_kernel_enable_event(kchan, event,
filter_expression, filter);
+ /* We have passed ownership */
+ filter_expression = NULL;
+ filter = NULL;
if (ret != LTTNG_OK) {
if (channel_created) {
/* Let's not leak a useless channel. */
event->type = LTTNG_EVENT_SYSCALL; /* Hack */
ret = event_kernel_enable_event(kchan, event,
filter_expression_a, filter_a);
+ /* We have passed ownership */
+ filter_expression_a = NULL;
+ filter_a = NULL;
if (ret != LTTNG_OK) {
- free(filter_expression_a);
- free(filter_a);
goto error;
}
break;
case LTTNG_EVENT_TRACEPOINT:
ret = event_kernel_enable_event(kchan, event,
filter_expression, filter);
+ /* We have passed ownership */
+ filter_expression = NULL;
+ filter = NULL;
if (ret != LTTNG_OK) {
if (channel_created) {
/* Let's not leak a useless channel. */
case LTTNG_EVENT_SYSCALL:
ret = event_kernel_enable_event(kchan, event,
filter_expression, filter);
+ /* We have passed ownership */
+ filter_expression = NULL;
+ filter = NULL;
if (ret != LTTNG_OK) {
goto error;
}
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;
+ free(attr);
+ goto error;
+ }
ret = cmd_enable_channel(session, domain, attr, wpipe);
if (ret != LTTNG_OK) {
assert(uchan);
}
+ if (uchan->domain != LTTNG_DOMAIN_UST && !internal_event) {
+ /*
+ * Don't allow users to add UST events to channels which
+ * are assigned to a userspace subdomain (JUL, Log4J,
+ * Python, etc.).
+ */
+ ret = LTTNG_ERR_INVALID_CHANNEL_DOMAIN;
+ goto error;
+ }
+
+ if (!internal_event) {
+ /*
+ * Ensure the event name is not reserved for internal
+ * use.
+ */
+ ret = validate_ust_event_name(event->name);
+ if (ret) {
+ WARN("Userspace event name %s failed validation.",
+ event->name ?
+ event->name : "NULL");
+ ret = LTTNG_ERR_INVALID_EVENT_NAME;
+ goto error;
+ }
+ }
+
/* At this point, the session and channel exist on the tracer */
ret = event_ust_enable_tracepoint(usess, uchan, event,
- filter_expression, filter, exclusion);
+ filter_expression, filter, exclusion,
+ internal_event);
/* We have passed ownership */
filter_expression = NULL;
filter = NULL;
exclusion = NULL;
- if (ret != LTTNG_OK) {
+ if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
+ goto already_enabled;
+ } else if (ret != LTTNG_OK) {
goto error;
}
break;
if (!agt) {
agt = agent_create(domain->type);
if (!agt) {
- ret = -LTTNG_ERR_NOMEM;
+ ret = LTTNG_ERR_NOMEM;
goto error;
}
agent_add(agt, usess->agents);
memset(&uevent, 0, sizeof(uevent));
uevent.type = LTTNG_EVENT_TRACEPOINT;
uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
- default_event_name = event_get_default_agent_ust_name(domain->type);
+ default_event_name = event_get_default_agent_ust_name(
+ domain->type);
if (!default_event_name) {
- ret = -LTTNG_ERR_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
strncpy(uevent.name, default_event_name, sizeof(uevent.name));
}
{
+ char *filter_expression_copy = NULL;
struct lttng_filter_bytecode *filter_copy = NULL;
if (filter) {
- filter_copy = zmalloc(
- sizeof(struct lttng_filter_bytecode)
- + filter->len);
+ const size_t filter_size = sizeof(
+ struct lttng_filter_bytecode)
+ + filter->len;
+
+ filter_copy = zmalloc(filter_size);
if (!filter_copy) {
+ ret = LTTNG_ERR_NOMEM;
goto error;
}
+ memcpy(filter_copy, filter, filter_size);
- memcpy(filter_copy, filter,
- sizeof(struct lttng_filter_bytecode)
- + filter->len);
+ filter_expression_copy =
+ strdup(filter_expression);
+ if (!filter_expression) {
+ ret = LTTNG_ERR_NOMEM;
+ }
+
+ if (!filter_expression_copy || !filter_copy) {
+ free(filter_expression_copy);
+ free(filter_copy);
+ goto error;
+ }
}
- ret = cmd_enable_event(session, &tmp_dom,
+ ret = cmd_enable_event_internal(session, &tmp_dom,
(char *) default_chan_name,
- &uevent, filter_expression, filter_copy,
- NULL, wpipe);
- /* We have passed ownership */
- filter_expression = NULL;
+ &uevent, filter_expression_copy,
+ filter_copy, NULL, wpipe);
}
- if (ret != LTTNG_OK && ret != LTTNG_ERR_UST_EVENT_ENABLED) {
+ if (ret == LTTNG_ERR_UST_EVENT_ENABLED) {
+ goto already_enabled;
+ } else if (ret != LTTNG_OK) {
goto error;
}
/* The wild card * means that everything should be enabled. */
if (strncmp(event->name, "*", 1) == 0 && strlen(event->name) == 1) {
- ret = event_agent_enable_all(usess, agt, event, filter);
- filter = NULL;
+ ret = event_agent_enable_all(usess, agt, event, filter,
+ filter_expression);
} else {
- ret = event_agent_enable(usess, agt, event, filter);
- filter = NULL;
+ ret = event_agent_enable(usess, agt, event, filter,
+ filter_expression);
}
+ filter = NULL;
+ filter_expression = NULL;
if (ret != LTTNG_OK) {
goto error;
}
ret = LTTNG_OK;
+already_enabled:
error:
free(filter_expression);
free(filter);
return ret;
}
+/*
+ * Command LTTNG_ENABLE_EVENT processed by the client thread.
+ * We own filter, exclusion, and filter_expression.
+ */
+int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain,
+ char *channel_name, struct lttng_event *event,
+ char *filter_expression,
+ struct lttng_filter_bytecode *filter,
+ struct lttng_event_exclusion *exclusion,
+ int wpipe)
+{
+ return _cmd_enable_event(session, domain, channel_name, event,
+ filter_expression, filter, exclusion, wpipe, false);
+}
+
+/*
+ * Enable an event which is internal to LTTng. An internal should
+ * never be made visible to clients and are immune to checks such as
+ * reserved names.
+ */
+static int cmd_enable_event_internal(struct ltt_session *session,
+ struct lttng_domain *domain,
+ char *channel_name, struct lttng_event *event,
+ char *filter_expression,
+ struct lttng_filter_bytecode *filter,
+ struct lttng_event_exclusion *exclusion,
+ int wpipe)
+{
+ return _cmd_enable_event(session, domain, channel_name, event,
+ filter_expression, filter, exclusion, wpipe, true);
+}
+
/*
* Command LTTNG_LIST_TRACEPOINTS processed by the client thread.
*/
* Create session in no output mode with URIs set to NULL. The uris we've
* received are for a default snapshot output if one.
*/
- ret = cmd_create_session_uri(name, NULL, 0, creds, -1);
+ ret = cmd_create_session_uri(name, NULL, 0, creds, 0);
if (ret != LTTNG_OK) {
goto error;
}
if (session->kernel_session != NULL) {
(*domains)[index].type = LTTNG_DOMAIN_KERNEL;
+
+ /* Kernel session buffer type is always GLOBAL */
+ (*domains)[index].buf_type = LTTNG_BUFFER_GLOBAL;
+
index++;
}
rcu_read_lock();
cds_lfht_for_each_entry(session->ust_session->agents->ht,
&iter.iter, agt, node.node) {
- nb_event = list_lttng_agent_events(agt, events);
+ if (agt->domain == domain) {
+ nb_event = list_lttng_agent_events(
+ agt, events);
+ break;
+ }
}
rcu_read_unlock();
}
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,
assert(output);
assert(session);
- /* Get the datetime for the snapshot output directory. */
- ret = utils_get_current_time_str("%Y%m%d-%H%M%S", output->datetime,
- sizeof(output->datetime));
- if (!ret) {
- ret = LTTNG_ERR_INVALID;
- goto error;
- }
/*
* Copy kernel session sockets so we can communicate with the right
assert(output);
assert(session);
- /* Get the datetime for the snapshot output directory. */
- ret = utils_get_current_time_str("%Y%m%d-%H%M%S", output->datetime,
- sizeof(output->datetime));
- if (!ret) {
- ret = LTTNG_ERR_INVALID;
- goto error;
- }
-
/*
* Copy UST session sockets so we can communicate with the right
* consumer for the snapshot record command.
case EINVAL:
ret = LTTNG_ERR_INVALID;
break;
- case ENODATA:
- ret = LTTNG_ERR_SNAPSHOT_NODATA;
- break;
default:
ret = LTTNG_ERR_SNAPSHOT_FAIL;
break;
unsigned int use_tmp_output = 0;
struct snapshot_output tmp_output;
unsigned int snapshot_success = 0;
+ char datetime[16];
assert(session);
assert(output);
DBG("Cmd snapshot record for session %s", session->name);
+ /* Get the datetime for the snapshot output directory. */
+ ret = utils_get_current_time_str("%Y%m%d-%H%M%S", datetime,
+ sizeof(datetime));
+ if (!ret) {
+ ret = LTTNG_ERR_INVALID;
+ goto error;
+ }
+
/*
* Permission denied to create an output if the session is not
* set in no output mode.
}
/* Use the global session count for the temporary snapshot. */
tmp_output.nb_snapshot = session->snapshot.nb_snapshot;
+
+ /* Use the global datetime */
+ memcpy(tmp_output.datetime, datetime, sizeof(datetime));
use_tmp_output = 1;
}
- if (session->kernel_session) {
- struct ltt_kernel_session *ksess = session->kernel_session;
+ if (use_tmp_output) {
+ int64_t nb_packets_per_stream;
- if (use_tmp_output) {
- int64_t nb_packets_per_stream;
+ nb_packets_per_stream = get_session_nb_packets_per_stream(session,
+ tmp_output.max_size);
+ if (nb_packets_per_stream < 0) {
+ ret = LTTNG_ERR_MAX_SIZE_INVALID;
+ goto error;
+ }
- nb_packets_per_stream = get_session_nb_packets_per_stream(session,
- tmp_output.max_size);
- if (nb_packets_per_stream < 0) {
- ret = LTTNG_ERR_MAX_SIZE_INVALID;
+ if (session->kernel_session) {
+ ret = record_kernel_snapshot(session->kernel_session,
+ &tmp_output, session,
+ wait, nb_packets_per_stream);
+ if (ret != LTTNG_OK) {
goto error;
}
- ret = record_kernel_snapshot(ksess, &tmp_output, session,
+ }
+
+ if (session->ust_session) {
+ ret = record_ust_snapshot(session->ust_session,
+ &tmp_output, session,
wait, nb_packets_per_stream);
if (ret != LTTNG_OK) {
goto error;
}
- snapshot_success = 1;
- } else {
- struct snapshot_output *sout;
- struct lttng_ht_iter iter;
-
- rcu_read_lock();
- cds_lfht_for_each_entry(session->snapshot.output_ht->ht,
- &iter.iter, sout, node.node) {
- int64_t nb_packets_per_stream;
-
- /*
- * Make a local copy of the output and assign the possible
- * temporary value given by the caller.
- */
- memset(&tmp_output, 0, sizeof(tmp_output));
- memcpy(&tmp_output, sout, sizeof(tmp_output));
-
- if (output->max_size != (uint64_t) -1ULL) {
- tmp_output.max_size = output->max_size;
- }
+ }
- nb_packets_per_stream = get_session_nb_packets_per_stream(session,
- tmp_output.max_size);
- if (nb_packets_per_stream < 0) {
- ret = LTTNG_ERR_MAX_SIZE_INVALID;
- goto error;
- }
+ snapshot_success = 1;
+ } else {
+ struct snapshot_output *sout;
+ struct lttng_ht_iter iter;
- /* Use temporary name. */
- if (*output->name != '\0') {
- strncpy(tmp_output.name, output->name,
- sizeof(tmp_output.name));
- }
+ rcu_read_lock();
+ cds_lfht_for_each_entry(session->snapshot.output_ht->ht,
+ &iter.iter, sout, node.node) {
+ int64_t nb_packets_per_stream;
- tmp_output.nb_snapshot = session->snapshot.nb_snapshot;
+ /*
+ * Make a local copy of the output and assign the possible
+ * temporary value given by the caller.
+ */
+ memset(&tmp_output, 0, sizeof(tmp_output));
+ memcpy(&tmp_output, sout, sizeof(tmp_output));
- ret = record_kernel_snapshot(ksess, &tmp_output,
- session, wait, nb_packets_per_stream);
- if (ret != LTTNG_OK) {
- rcu_read_unlock();
- goto error;
- }
- snapshot_success = 1;
+ if (output->max_size != (uint64_t) -1ULL) {
+ tmp_output.max_size = output->max_size;
}
- rcu_read_unlock();
- }
- }
-
- if (session->ust_session) {
- struct ltt_ust_session *usess = session->ust_session;
-
- if (use_tmp_output) {
- int64_t nb_packets_per_stream;
nb_packets_per_stream = get_session_nb_packets_per_stream(session,
tmp_output.max_size);
if (nb_packets_per_stream < 0) {
ret = LTTNG_ERR_MAX_SIZE_INVALID;
+ rcu_read_unlock();
goto error;
}
- ret = record_ust_snapshot(usess, &tmp_output, session,
- wait, nb_packets_per_stream);
- if (ret != LTTNG_OK) {
- goto error;
- }
- snapshot_success = 1;
- } else {
- struct snapshot_output *sout;
- struct lttng_ht_iter iter;
-
- rcu_read_lock();
- cds_lfht_for_each_entry(session->snapshot.output_ht->ht,
- &iter.iter, sout, node.node) {
- int64_t nb_packets_per_stream;
- /*
- * Make a local copy of the output and assign the possible
- * temporary value given by the caller.
- */
- memset(&tmp_output, 0, sizeof(tmp_output));
- memcpy(&tmp_output, sout, sizeof(tmp_output));
-
- if (output->max_size != (uint64_t) -1ULL) {
- tmp_output.max_size = output->max_size;
- }
-
- nb_packets_per_stream = get_session_nb_packets_per_stream(session,
- tmp_output.max_size);
- if (nb_packets_per_stream < 0) {
- ret = LTTNG_ERR_MAX_SIZE_INVALID;
+ /* Use temporary name. */
+ if (*output->name != '\0') {
+ if (lttng_strncpy(tmp_output.name, output->name,
+ sizeof(tmp_output.name))) {
+ ret = LTTNG_ERR_INVALID;
rcu_read_unlock();
goto error;
}
+ }
- /* Use temporary name. */
- if (*output->name != '\0') {
- strncpy(tmp_output.name, output->name,
- sizeof(tmp_output.name));
- }
+ tmp_output.nb_snapshot = session->snapshot.nb_snapshot;
+ memcpy(tmp_output.datetime, datetime, sizeof(datetime));
- tmp_output.nb_snapshot = session->snapshot.nb_snapshot;
+ if (session->kernel_session) {
+ ret = record_kernel_snapshot(session->kernel_session,
+ &tmp_output, session,
+ wait, nb_packets_per_stream);
+ if (ret != LTTNG_OK) {
+ rcu_read_unlock();
+ goto error;
+ }
+ }
- ret = record_ust_snapshot(usess, &tmp_output, session,
+ if (session->ust_session) {
+ ret = record_ust_snapshot(session->ust_session,
+ &tmp_output, session,
wait, nb_packets_per_stream);
if (ret != LTTNG_OK) {
rcu_read_unlock();
goto error;
}
- snapshot_success = 1;
}
- rcu_read_unlock();
+ snapshot_success = 1;
}
+ rcu_read_unlock();
}
if (snapshot_success) {