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++;
}
if (nb_event == 0) {
*events = NULL;
- goto syscall;
+ goto end;
}
*events = zmalloc(nb_event * sizeof(struct lttng_event));
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;
switch (event->type) {
case LTTNG_EVENT_ALL:
- ret = event_kernel_disable_event_all(kchan);
- if (ret != LTTNG_OK) {
- goto error_unlock;
- }
- 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_unlock;
}
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_unlock;
- }
- break;
default:
ret = LTTNG_ERR_UNK;
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') {
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_unlock;
}
ret = -LTTNG_ERR_UST_EVENT_NOT_FOUND;
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);
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_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;
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) {
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;
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;
}
ret = LTTNG_OK;
+already_enabled:
error:
free(filter_expression);
free(filter);
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) {