node = lttng_ht_iter_get_node_str(&iter);
if (node == NULL) {
ret_code = LTTNG_ERR_UST_CHAN_NOT_FOUND;
- goto end;
+ goto error;
}
uchan = caa_container_of(&node->node, struct ltt_ust_channel, node.node);
tmp_event = lttng_event_create();
if (!tmp_event) {
ret_code = LTTNG_ERR_NOMEM;
- goto end;
+ goto error;
}
if (lttng_strncpy(tmp_event->name, uevent->attr.name,
LTTNG_SYMBOL_NAME_LEN)) {
ret_code = LTTNG_ERR_FATAL;
lttng_event_destroy(tmp_event);
- goto end;
+ goto error;
}
tmp_event->name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
* 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,
/*
* Command LTTNG_ADD_CONTEXT processed by the client thread.
*/
-int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain,
- char *channel_name, const struct lttng_event_context *ctx, int kwpipe)
+int cmd_add_context(struct command_ctx *cmd_ctx,
+ const struct lttng_event_context *event_context, int kwpipe)
{
int ret, chan_kern_created = 0, chan_ust_created = 0;
- char *app_ctx_provider_name = NULL, *app_ctx_name = NULL;
+ const enum lttng_domain_type domain = cmd_ctx->lsm.domain.type;
+ const struct ltt_session *session = cmd_ctx->session;
+ const char *channel_name = cmd_ctx->lsm.u.context.channel_name;
/*
* Don't try to add a context if the session has been started at
* some point in time before. The tracer does not allow it and would
* result in a corrupted trace.
*/
- if (session->has_been_started) {
+ if (cmd_ctx->session->has_been_started) {
ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
goto end;
}
- if (ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT) {
- app_ctx_provider_name = ctx->u.app_ctx.provider_name;
- app_ctx_name = ctx->u.app_ctx.ctx_name;
- }
-
switch (domain) {
case LTTNG_DOMAIN_KERNEL:
LTTNG_ASSERT(session->kernel_session);
chan_kern_created = 1;
}
/* Add kernel context to kernel tracer */
- ret = context_kernel_add(session->kernel_session, ctx, channel_name);
+ ret = context_kernel_add(session->kernel_session,
+ event_context, channel_name);
if (ret != LTTNG_OK) {
goto error;
}
chan_ust_created = 1;
}
- ret = context_ust_add(usess, domain, ctx, channel_name);
- free(app_ctx_provider_name);
- free(app_ctx_name);
- app_ctx_name = NULL;
- app_ctx_provider_name = NULL;
+ ret = context_ust_add(usess, domain, event_context,
+ channel_name);
if (ret != LTTNG_OK) {
goto error;
}
trace_ust_destroy_channel(uchan);
}
end:
- free(app_ctx_provider_name);
- free(app_ctx_name);
return ret;
}
/*
* Command LTTNG_LIST_TRACEPOINT_FIELDS processed by the client thread.
*/
-ssize_t cmd_list_tracepoint_fields(enum lttng_domain_type domain,
- struct lttng_event_field **fields)
+enum lttng_error_code cmd_list_tracepoint_fields(enum lttng_domain_type domain,
+ struct lttng_payload *reply)
{
+ enum lttng_error_code ret_code;
int ret;
- ssize_t nb_fields = 0;
+ unsigned int i, nb_fields;
+ struct lttng_event_field *fields = NULL;
+ struct lttcomm_list_command_header reply_command_header = {};
+ size_t reply_command_header_offset;
+
+ assert(reply);
+
+ /* Reserve space for command reply header. */
+ reply_command_header_offset = reply->buffer.size;
+ ret = lttng_dynamic_buffer_set_size(&reply->buffer,
+ reply_command_header_offset +
+ sizeof(struct lttcomm_list_command_header));
+ if (ret) {
+ ret_code = LTTNG_ERR_NOMEM;
+ goto error;
+ }
switch (domain) {
case LTTNG_DOMAIN_UST:
- nb_fields = ust_app_list_event_fields(fields);
- if (nb_fields < 0) {
- ret = LTTNG_ERR_UST_LIST_FAIL;
+ ret = ust_app_list_event_fields(&fields);
+ if (ret < 0) {
+ ret_code = LTTNG_ERR_UST_LIST_FAIL;
goto error;
}
+
break;
case LTTNG_DOMAIN_KERNEL:
default: /* fall-through */
- ret = LTTNG_ERR_UND;
+ ret_code = LTTNG_ERR_UND;
goto error;
}
- return nb_fields;
+ nb_fields = ret;
+
+ for (i = 0; i < nb_fields; i++) {
+ ret = lttng_event_field_serialize(&fields[i], reply);
+ if (ret) {
+ ret_code = LTTNG_ERR_NOMEM;
+ goto error;
+ }
+ }
+
+ if (nb_fields > UINT32_MAX) {
+ ERR("Tracepoint field count would overflow the tracepoint field listing command's reply");
+ ret_code = LTTNG_ERR_OVERFLOW;
+ goto error;
+ }
+
+ /* Update command reply header. */
+ reply_command_header.count = (uint32_t) nb_fields;
+
+ memcpy(reply->buffer.data + reply_command_header_offset, &reply_command_header,
+ sizeof(reply_command_header));
+
+ ret_code = LTTNG_OK;
error:
- /* Return negative value to differentiate return code */
- return -ret;
+ free(fields);
+ return ret_code;
}
enum lttng_error_code cmd_list_syscalls(
*/
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;
channel = trace_ust_channel_to_lttng_channel(uchan);
if (!channel) {
- ret = LTTNG_ERR_NOMEM;
- break;
+ ret_code = LTTNG_ERR_NOMEM;
+ goto end;
}
extended = (struct lttng_channel_extended *)
if (ret < 0) {
lttng_channel_destroy(channel);
ret_code = LTTNG_ERR_UNK;
- break;
+ goto end;
}
extended->discarded_events = discarded_events;
if (ret) {
ERR("Failed to serialize lttng_channel: channel name = '%s'",
channel->name);
+ lttng_channel_destroy(channel);
ret_code = LTTNG_ERR_UNK;
- ret = -1;
- break;
+ goto end;
}
+ lttng_channel_destroy(channel);
i++;
}
rcu_read_unlock();
enum lttng_error_code ret_code = LTTNG_OK;
struct lttcomm_list_command_header reply_command_header = {};
size_t reply_command_header_offset;
- unsigned int nb_events;
+ unsigned int nb_events = 0;
assert(reply_payload);
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