struct lttng_bytecode *filter,
struct lttng_event_exclusion *exclusion,
int wpipe);
-static int cmd_enable_channel_internal(struct ltt_session *session,
+static enum lttng_error_code cmd_enable_channel_internal(
+ struct ltt_session *session,
const struct lttng_domain *domain,
const struct lttng_channel *_attr,
int wpipe);
* Returns LTTNG_OK, or an LTTng error code on failure.
*/
static enum lttng_error_code send_consumer_relayd_sockets(
- enum lttng_domain_type domain,
unsigned int session_id, struct consumer_output *consumer,
struct consumer_socket *sock, const char *session_name,
const char *hostname, const char *base_path, int session_live_timer,
cds_lfht_for_each_entry(usess->consumer->socks->ht, &iter.iter,
socket, node.node) {
pthread_mutex_lock(socket->lock);
- ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_UST, session->id,
+ ret = send_consumer_relayd_sockets(session->id,
usess->consumer, socket,
session->name, session->hostname,
session->base_path,
cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
socket, node.node) {
pthread_mutex_lock(socket->lock);
- ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_KERNEL, session->id,
+ ret = send_consumer_relayd_sockets(session->id,
ksess->consumer, socket,
session->name, session->hostname,
session->base_path,
return ret;
}
-static int cmd_enable_channel_internal(struct ltt_session *session,
+static enum lttng_error_code cmd_enable_channel_internal(
+ struct ltt_session *session,
const struct lttng_domain *domain,
const struct lttng_channel *_attr,
int wpipe)
{
- int ret;
+ enum lttng_error_code ret_code;
struct ltt_ust_session *usess = session->ust_session;
struct lttng_ht *chan_ht;
size_t len;
attr = lttng_channel_copy(_attr);
if (!attr) {
- ret = -LTTNG_ERR_NOMEM;
+ ret_code = LTTNG_ERR_NOMEM;
goto end;
}
/* Validate channel name */
if (attr->name[0] == '.' ||
memchr(attr->name, '/', len) != NULL) {
- ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
+ ret_code = LTTNG_ERR_INVALID_CHANNEL_NAME;
goto end;
}
case LTTNG_DOMAIN_PYTHON:
if (!agent_tracing_is_enabled()) {
DBG("Attempted to enable a channel in an agent domain but the agent thread is not running");
- ret = LTTNG_ERR_AGENT_TRACING_DISABLED;
+ ret_code = LTTNG_ERR_AGENT_TRACING_DISABLED;
goto error;
}
break;
default:
- ret = LTTNG_ERR_UNKNOWN_DOMAIN;
+ ret_code = LTTNG_ERR_UNKNOWN_DOMAIN;
goto error;
}
* some point in time before. The tracer does not allow it.
*/
if (session->has_been_started) {
- ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
+ ret_code = LTTNG_ERR_TRACE_ALREADY_STARTED;
goto error;
}
/* Enforce mmap output for snapshot sessions. */
attr->attr.output = LTTNG_EVENT_MMAP;
}
- ret = channel_kernel_create(
+ ret_code = channel_kernel_create(
session->kernel_session, attr, wpipe);
if (attr->name[0] != '\0') {
session->kernel_session->has_non_default_channel = 1;
}
} else {
- ret = channel_kernel_enable(session->kernel_session, kchan);
+ ret_code = channel_kernel_enable(session->kernel_session, kchan);
}
- if (ret != LTTNG_OK) {
+ if (ret_code != LTTNG_OK) {
goto error;
}
if (domain->type == LTTNG_DOMAIN_JUL) {
if (strncmp(attr->name, DEFAULT_JUL_CHANNEL_NAME,
LTTNG_SYMBOL_NAME_LEN)) {
- ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
+ ret_code = 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;
+ ret_code = 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;
+ ret_code = LTTNG_ERR_INVALID_CHANNEL_NAME;
goto error;
}
}
* some point in time before. The tracer does not allow it.
*/
if (session->has_been_started) {
- ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
+ ret_code = LTTNG_ERR_TRACE_ALREADY_STARTED;
goto error;
}
- ret = channel_ust_create(usess, attr, domain->buf_type);
+ ret_code = channel_ust_create(usess, attr, domain->buf_type);
if (attr->name[0] != '\0') {
usess->has_non_default_channel = 1;
}
} else {
- ret = channel_ust_enable(usess, uchan);
+ ret_code = channel_ust_enable(usess, uchan);
}
break;
}
default:
- ret = LTTNG_ERR_UNKNOWN_DOMAIN;
+ ret_code = LTTNG_ERR_UNKNOWN_DOMAIN;
goto error;
}
- if (ret == LTTNG_OK && attr->attr.output != LTTNG_EVENT_MMAP) {
+ if (ret_code == LTTNG_OK && attr->attr.output != LTTNG_EVENT_MMAP) {
session->has_non_mmap_channel = true;
}
error:
rcu_read_unlock();
end:
lttng_channel_destroy(attr);
- return ret;
+ return ret_code;
}
enum lttng_error_code cmd_process_attr_tracker_get_tracking_policy(
ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
goto error;
}
- /* break is _not_ missing here. */
}
+ /* fall through */
case LTTNG_DOMAIN_UST:
{
struct ltt_ust_session *usess = session->ust_session;
*/
session->rotated_after_last_stop = false;
- if (session->rotate_timer_period) {
+ if (session->rotate_timer_period && !session->rotation_schedule_timer_enabled) {
int int_ret = timer_session_rotation_schedule_timer_start(
session, session->rotate_timer_period);
.cmd_header_size =
sizeof(struct lttcomm_session_destroy_command_header),
.data_size = 0,
+ .fd_count = 0,
};
size_t payload_size_before_location;
cds_lfht_for_each_entry(output->socks->ht, &iter.iter,
socket, node.node) {
pthread_mutex_lock(socket->lock);
- status = send_consumer_relayd_sockets(LTTNG_DOMAIN_NONE, session->id,
+ status = send_consumer_relayd_sockets(session->id,
output, socket,
session->name, session->hostname,
base_path,
struct ltt_kernel_session *ksess,
const struct consumer_output *output,
const struct ltt_session *session,
- int wait, uint64_t nb_packets_per_stream)
+ uint64_t nb_packets_per_stream)
{
enum lttng_error_code status;
LTTNG_ASSERT(session);
status = kernel_snapshot_record(
- ksess, output, wait, nb_packets_per_stream);
+ ksess, output, nb_packets_per_stream);
return status;
}
static enum lttng_error_code record_ust_snapshot(struct ltt_ust_session *usess,
const struct consumer_output *output,
const struct ltt_session *session,
- int wait, uint64_t nb_packets_per_stream)
+ uint64_t nb_packets_per_stream)
{
enum lttng_error_code status;
LTTNG_ASSERT(session);
status = ust_app_snapshot_record(
- usess, output, wait, nb_packets_per_stream);
+ usess, output, nb_packets_per_stream);
return status;
}
static
enum lttng_error_code snapshot_record(struct ltt_session *session,
- const struct snapshot_output *snapshot_output, int wait)
+ const struct snapshot_output *snapshot_output)
{
int64_t nb_packets_per_stream;
char snapshot_chunk_name[LTTNG_NAME_MAX];
if (session->kernel_session) {
ret_code = record_kernel_snapshot(session->kernel_session,
snapshot_kernel_consumer_output, session,
- wait, nb_packets_per_stream);
+ nb_packets_per_stream);
if (ret_code != LTTNG_OK) {
goto error_close_trace_chunk;
}
if (session->ust_session) {
ret_code = record_ust_snapshot(session->ust_session,
snapshot_ust_consumer_output, session,
- wait, nb_packets_per_stream);
+ nb_packets_per_stream);
if (ret_code != LTTNG_OK) {
goto error_close_trace_chunk;
}
* Return LTTNG_OK on success or else a LTTNG_ERR code.
*/
int cmd_snapshot_record(struct ltt_session *session,
- const struct lttng_snapshot_output *output, int wait)
+ const struct lttng_snapshot_output *output,
+ int wait __attribute__((unused)))
{
enum lttng_error_code cmd_ret = LTTNG_OK;
int ret;
/* Use the global datetime */
memcpy(tmp_output->datetime, datetime, sizeof(datetime));
- cmd_ret = snapshot_record(session, tmp_output, wait);
+ cmd_ret = snapshot_record(session, tmp_output);
if (cmd_ret != LTTNG_OK) {
goto error;
}
}
}
- cmd_ret = snapshot_record(session, &output_copy, wait);
+ cmd_ret = snapshot_record(session, &output_copy);
if (cmd_ret != LTTNG_OK) {
rcu_read_unlock();
goto error;
projects / lttng-tools.git / blobdiff