X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fcommon%2Fkernel-consumer%2Fkernel-consumer.c;h=236c2c98f9d80f98b2e43b7c74ba9175893a64e3;hb=a0377dfefe40662ba7d68617bce6ff467114136c;hp=4a2e4e07d7c0b8e5eac8e34927afad5f8762da4a;hpb=23d565989350c270c68e9a6c8edfbe2dd6a6895d;p=lttng-tools.git diff --git a/src/common/kernel-consumer/kernel-consumer.c b/src/common/kernel-consumer/kernel-consumer.c index 4a2e4e07d..236c2c98f 100644 --- a/src/common/kernel-consumer/kernel-consumer.c +++ b/src/common/kernel-consumer/kernel-consumer.c @@ -7,10 +7,7 @@ * */ -#include "common/buffer-view.h" -#include #define _LGPL_SOURCE -#include #include #include #include @@ -21,6 +18,7 @@ #include #include #include +#include #include #include @@ -36,10 +34,13 @@ #include #include #include +#include +#include +#include #include "kernel-consumer.h" -extern struct lttng_consumer_global_data consumer_data; +extern struct lttng_consumer_global_data the_consumer_data; extern int consumer_poll_timeout; /* @@ -72,7 +73,7 @@ int lttng_kconsumer_take_snapshot(struct lttng_consumer_stream *stream) int lttng_kconsumer_sample_snapshot_positions( struct lttng_consumer_stream *stream) { - assert(stream); + LTTNG_ASSERT(stream); return kernctl_snapshot_sample_positions(stream->wait_fd); } @@ -172,7 +173,7 @@ static int lttng_kconsumer_snapshot_channel( */ pthread_mutex_lock(&stream->lock); - assert(channel->trace_chunk); + LTTNG_ASSERT(channel->trace_chunk); if (!lttng_trace_chunk_get(channel->trace_chunk)) { /* * Can't happen barring an internal error as the channel @@ -182,7 +183,7 @@ static int lttng_kconsumer_snapshot_channel( ret = -1; goto end_unlock; } - assert(!stream->trace_chunk); + LTTNG_ASSERT(!stream->trace_chunk); stream->trace_chunk = channel->trace_chunk; /* @@ -286,9 +287,9 @@ static int lttng_kconsumer_snapshot_channel( subbuf_view = lttng_buffer_view_init( subbuf_addr, 0, padded_len); - read_len = lttng_consumer_on_read_subbuffer_mmap(ctx, + read_len = lttng_consumer_on_read_subbuffer_mmap( stream, &subbuf_view, - padded_len - len, NULL); + padded_len - len); /* * We write the padded len in local tracefiles but the data len * when using a relay. Display the error but continue processing @@ -364,7 +365,7 @@ static int lttng_kconsumer_snapshot_metadata( ssize_t ret_read; struct lttng_consumer_stream *metadata_stream; - assert(ctx); + LTTNG_ASSERT(ctx); DBG("Kernel consumer snapshot metadata with key %" PRIu64 " at path %s", key, path); @@ -372,11 +373,11 @@ static int lttng_kconsumer_snapshot_metadata( rcu_read_lock(); metadata_stream = metadata_channel->metadata_stream; - assert(metadata_stream); + LTTNG_ASSERT(metadata_stream); pthread_mutex_lock(&metadata_stream->lock); - assert(metadata_channel->trace_chunk); - assert(metadata_stream->trace_chunk); + LTTNG_ASSERT(metadata_channel->trace_chunk); + LTTNG_ASSERT(metadata_stream->trace_chunk); /* Flag once that we have a valid relayd for the stream. */ if (relayd_id != (uint64_t) -1ULL) { @@ -399,18 +400,14 @@ static int lttng_kconsumer_snapshot_metadata( do { health_code_update(); - ret_read = lttng_kconsumer_read_subbuffer(metadata_stream, ctx); + ret_read = lttng_consumer_read_subbuffer(metadata_stream, ctx, true); if (ret_read < 0) { - if (ret_read != -EAGAIN) { - ERR("Kernel snapshot reading metadata subbuffer (ret: %zd)", - ret_read); - ret = ret_read; - goto error_snapshot; - } - /* ret_read is negative at this point so we will exit the loop. */ - continue; + ERR("Kernel snapshot reading metadata subbuffer (ret: %zd)", + ret_read); + ret = ret_read; + goto error_snapshot; } - } while (ret_read >= 0); + } while (ret_read > 0); if (use_relayd) { close_relayd_stream(metadata_stream); @@ -449,25 +446,30 @@ error_snapshot: int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, int sock, struct pollfd *consumer_sockpoll) { - ssize_t ret; + int ret_func; enum lttcomm_return_code ret_code = LTTCOMM_CONSUMERD_SUCCESS; struct lttcomm_consumer_msg msg; health_code_update(); - ret = lttcomm_recv_unix_sock(sock, &msg, sizeof(msg)); - if (ret != sizeof(msg)) { - if (ret > 0) { - lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_ERROR_RECV_CMD); - ret = -1; + { + ssize_t ret_recv; + + ret_recv = lttcomm_recv_unix_sock(sock, &msg, sizeof(msg)); + if (ret_recv != sizeof(msg)) { + if (ret_recv > 0) { + lttng_consumer_send_error(ctx, + LTTCOMM_CONSUMERD_ERROR_RECV_CMD); + ret_recv = -1; + } + return ret_recv; } - return ret; } health_code_update(); /* Deprecated command */ - assert(msg.cmd_type != LTTNG_CONSUMER_STOP); + LTTNG_ASSERT(msg.cmd_type != LTTNG_CONSUMER_STOP); health_code_update(); @@ -487,14 +489,14 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, case LTTNG_CONSUMER_ADD_CHANNEL: { struct lttng_consumer_channel *new_channel; - int ret_recv; + int ret_send_status, ret_add_channel = 0; const uint64_t chunk_id = msg.u.channel.chunk_id.value; health_code_update(); /* First send a status message before receiving the fds. */ - ret = consumer_send_status_msg(sock, ret_code); - if (ret < 0) { + ret_send_status = consumer_send_status_msg(sock, ret_code); + if (ret_send_status < 0) { /* Somehow, the session daemon is not responding anymore. */ goto error_fatal; } @@ -539,23 +541,27 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, new_channel->type = msg.u.channel.type; break; default: - assert(0); + abort(); goto end_nosignal; }; health_code_update(); if (ctx->on_recv_channel != NULL) { - ret_recv = ctx->on_recv_channel(new_channel); - if (ret_recv == 0) { - ret = consumer_add_channel(new_channel, ctx); - } else if (ret_recv < 0) { + int ret_recv_channel = + ctx->on_recv_channel(new_channel); + if (ret_recv_channel == 0) { + ret_add_channel = consumer_add_channel( + new_channel, ctx); + } else if (ret_recv_channel < 0) { goto end_nosignal; } } else { - ret = consumer_add_channel(new_channel, ctx); + ret_add_channel = + consumer_add_channel(new_channel, ctx); } - if (msg.u.channel.type == CONSUMER_CHANNEL_TYPE_DATA && !ret) { + if (msg.u.channel.type == CONSUMER_CHANNEL_TYPE_DATA && + !ret_add_channel) { int monitor_start_ret; DBG("Consumer starting monitor timer"); @@ -568,15 +574,15 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, ERR("Starting channel monitoring timer failed"); goto end_nosignal; } - } health_code_update(); /* If we received an error in add_channel, we need to report it. */ - if (ret < 0) { - ret = consumer_send_status_msg(sock, ret); - if (ret < 0) { + if (ret_add_channel < 0) { + ret_send_status = consumer_send_status_msg( + sock, ret_add_channel); + if (ret_send_status < 0) { goto error_fatal; } goto end_nosignal; @@ -591,6 +597,8 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, struct lttng_consumer_stream *new_stream; struct lttng_consumer_channel *channel; int alloc_ret = 0; + int ret_send_status, ret_poll, ret_get_max_subbuf_size; + ssize_t ret_pipe_write, ret_recv; /* * Get stream's channel reference. Needed when adding the stream to the @@ -609,8 +617,8 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, health_code_update(); /* First send a status message before receiving the fds. */ - ret = consumer_send_status_msg(sock, ret_code); - if (ret < 0) { + ret_send_status = consumer_send_status_msg(sock, ret_code); + if (ret_send_status < 0) { /* Somehow, the session daemon is not responding anymore. */ goto error_add_stream_fatal; } @@ -624,18 +632,19 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, /* Blocking call */ health_poll_entry(); - ret = lttng_consumer_poll_socket(consumer_sockpoll); + ret_poll = lttng_consumer_poll_socket(consumer_sockpoll); health_poll_exit(); - if (ret) { + if (ret_poll) { goto error_add_stream_fatal; } health_code_update(); /* Get stream file descriptor from socket */ - ret = lttcomm_recv_fds_unix_sock(sock, &fd, 1); - if (ret != sizeof(fd)) { + ret_recv = lttcomm_recv_fds_unix_sock(sock, &fd, 1); + if (ret_recv != sizeof(fd)) { lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_ERROR_RECV_FD); + ret_func = ret_recv; goto end; } @@ -646,8 +655,8 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, * above recv() failed, the session daemon is notified through the * error socket and the teardown is eventually done. */ - ret = consumer_send_status_msg(sock, ret_code); - if (ret < 0) { + ret_send_status = consumer_send_status_msg(sock, ret_code); + if (ret_send_status < 0) { /* Somehow, the session daemon is not responding anymore. */ goto error_add_stream_nosignal; } @@ -655,7 +664,7 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, health_code_update(); pthread_mutex_lock(&channel->lock); - new_stream = consumer_allocate_stream( + new_stream = consumer_stream_create( channel, channel->key, fd, @@ -680,9 +689,9 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, } new_stream->wait_fd = fd; - ret = kernctl_get_max_subbuf_size(new_stream->wait_fd, - &new_stream->max_sb_size); - if (ret < 0) { + ret_get_max_subbuf_size = kernctl_get_max_subbuf_size( + new_stream->wait_fd, &new_stream->max_sb_size); + if (ret_get_max_subbuf_size < 0) { pthread_mutex_unlock(&channel->lock); ERR("Failed to get kernel maximal subbuffer size"); goto error_add_stream_nosignal; @@ -690,23 +699,6 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, consumer_stream_update_channel_attributes(new_stream, channel); - switch (channel->output) { - case CONSUMER_CHANNEL_SPLICE: - new_stream->output = LTTNG_EVENT_SPLICE; - ret = utils_create_pipe(new_stream->splice_pipe); - if (ret < 0) { - pthread_mutex_unlock(&channel->lock); - goto error_add_stream_nosignal; - } - break; - case CONSUMER_CHANNEL_MMAP: - new_stream->output = LTTNG_EVENT_MMAP; - break; - default: - ERR("Stream output unknown %d", channel->output); - pthread_mutex_unlock(&channel->lock); - goto error_add_stream_nosignal; - } /* * We've just assigned the channel to the stream so increment the @@ -732,8 +724,8 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, pthread_mutex_lock(&new_stream->lock); if (ctx->on_recv_stream) { - ret = ctx->on_recv_stream(new_stream); - if (ret < 0) { + int ret_recv_stream = ctx->on_recv_stream(new_stream); + if (ret_recv_stream < 0) { pthread_mutex_unlock(&new_stream->lock); pthread_mutex_unlock(&channel->lock); consumer_stream_free(new_stream); @@ -759,9 +751,11 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, /* Send stream to relayd if the stream has an ID. */ if (new_stream->net_seq_idx != (uint64_t) -1ULL) { - ret = consumer_send_relayd_stream(new_stream, - new_stream->chan->pathname); - if (ret < 0) { + int ret_send_relayd_stream; + + ret_send_relayd_stream = consumer_send_relayd_stream( + new_stream, new_stream->chan->pathname); + if (ret_send_relayd_stream < 0) { pthread_mutex_unlock(&new_stream->lock); pthread_mutex_unlock(&channel->lock); consumer_stream_free(new_stream); @@ -774,9 +768,12 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, * to send the "streams_sent" command to relayd. */ if (channel->streams_sent_to_relayd) { - ret = consumer_send_relayd_streams_sent( - new_stream->net_seq_idx); - if (ret < 0) { + int ret_send_relayd_streams_sent; + + ret_send_relayd_streams_sent = + consumer_send_relayd_streams_sent( + new_stream->net_seq_idx); + if (ret_send_relayd_streams_sent < 0) { pthread_mutex_unlock(&new_stream->lock); pthread_mutex_unlock(&channel->lock); goto error_add_stream_nosignal; @@ -800,8 +797,9 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, health_code_update(); - ret = lttng_pipe_write(stream_pipe, &new_stream, sizeof(new_stream)); - if (ret < 0) { + ret_pipe_write = lttng_pipe_write( + stream_pipe, &new_stream, sizeof(new_stream)); + if (ret_pipe_write < 0) { ERR("Consumer write %s stream to pipe %d", new_stream->metadata_flag ? "metadata" : "data", lttng_pipe_get_writefd(stream_pipe)); @@ -825,6 +823,7 @@ error_add_stream_fatal: case LTTNG_CONSUMER_STREAMS_SENT: { struct lttng_consumer_channel *channel; + int ret_send_status; /* * Get stream's channel reference. Needed when adding the stream to the @@ -846,8 +845,9 @@ error_add_stream_fatal: /* * Send status code to session daemon. */ - ret = consumer_send_status_msg(sock, ret_code); - if (ret < 0 || ret_code != LTTCOMM_CONSUMERD_SUCCESS) { + ret_send_status = consumer_send_status_msg(sock, ret_code); + if (ret_send_status < 0 || + ret_code != LTTCOMM_CONSUMERD_SUCCESS) { /* Somehow, the session daemon is not responding anymore. */ goto error_streams_sent_nosignal; } @@ -865,9 +865,11 @@ error_add_stream_fatal: health_code_update(); /* Send stream to relayd if the stream has an ID. */ if (msg.u.sent_streams.net_seq_idx != (uint64_t) -1ULL) { - ret = consumer_send_relayd_streams_sent( + int ret_send_relay_streams; + + ret_send_relay_streams = consumer_send_relayd_streams_sent( msg.u.sent_streams.net_seq_idx); - if (ret < 0) { + if (ret_send_relay_streams < 0) { goto error_streams_sent_nosignal; } channel->streams_sent_to_relayd = true; @@ -886,6 +888,7 @@ error_streams_sent_nosignal: { uint64_t index = msg.u.destroy_relayd.net_seq_idx; struct consumer_relayd_sock_pair *relayd; + int ret_send_status; DBG("Kernel consumer destroying relayd %" PRIu64, index); @@ -912,8 +915,8 @@ error_streams_sent_nosignal: health_code_update(); - ret = consumer_send_status_msg(sock, ret_code); - if (ret < 0) { + ret_send_status = consumer_send_status_msg(sock, ret_code); + if (ret_send_status < 0) { /* Somehow, the session daemon is not responding anymore. */ goto error_fatal; } @@ -922,18 +925,20 @@ error_streams_sent_nosignal: } case LTTNG_CONSUMER_DATA_PENDING: { - int32_t ret; + int32_t ret_data_pending; uint64_t id = msg.u.data_pending.session_id; + ssize_t ret_send; DBG("Kernel consumer data pending command for id %" PRIu64, id); - ret = consumer_data_pending(id); + ret_data_pending = consumer_data_pending(id); health_code_update(); /* Send back returned value to session daemon */ - ret = lttcomm_send_unix_sock(sock, &ret, sizeof(ret)); - if (ret < 0) { + ret_send = lttcomm_send_unix_sock(sock, &ret_data_pending, + sizeof(ret_data_pending)); + if (ret_send < 0) { PERROR("send data pending ret code"); goto error_fatal; } @@ -948,6 +953,7 @@ error_streams_sent_nosignal: { struct lttng_consumer_channel *channel; uint64_t key = msg.u.snapshot_channel.key; + int ret_send_status; channel = consumer_find_channel(key); if (!channel) { @@ -956,20 +962,28 @@ error_streams_sent_nosignal: } else { pthread_mutex_lock(&channel->lock); if (msg.u.snapshot_channel.metadata == 1) { - ret = lttng_kconsumer_snapshot_metadata(channel, key, + int ret_snapshot; + + ret_snapshot = lttng_kconsumer_snapshot_metadata( + channel, key, msg.u.snapshot_channel.pathname, - msg.u.snapshot_channel.relayd_id, ctx); - if (ret < 0) { + msg.u.snapshot_channel.relayd_id, + ctx); + if (ret_snapshot < 0) { ERR("Snapshot metadata failed"); ret_code = LTTCOMM_CONSUMERD_SNAPSHOT_FAILED; } } else { - ret = lttng_kconsumer_snapshot_channel(channel, key, + int ret_snapshot; + + ret_snapshot = lttng_kconsumer_snapshot_channel( + channel, key, msg.u.snapshot_channel.pathname, msg.u.snapshot_channel.relayd_id, - msg.u.snapshot_channel.nb_packets_per_stream, + msg.u.snapshot_channel + .nb_packets_per_stream, ctx); - if (ret < 0) { + if (ret_snapshot < 0) { ERR("Snapshot channel failed"); ret_code = LTTCOMM_CONSUMERD_SNAPSHOT_FAILED; } @@ -978,8 +992,8 @@ error_streams_sent_nosignal: } health_code_update(); - ret = consumer_send_status_msg(sock, ret_code); - if (ret < 0) { + ret_send_status = consumer_send_status_msg(sock, ret_code); + if (ret_send_status < 0) { /* Somehow, the session daemon is not responding anymore. */ goto end_nosignal; } @@ -989,6 +1003,7 @@ error_streams_sent_nosignal: { uint64_t key = msg.u.destroy_channel.key; struct lttng_consumer_channel *channel; + int ret_send_status; channel = consumer_find_channel(key); if (!channel) { @@ -998,8 +1013,8 @@ error_streams_sent_nosignal: health_code_update(); - ret = consumer_send_status_msg(sock, ret_code); - if (ret < 0) { + ret_send_status = consumer_send_status_msg(sock, ret_code); + if (ret_send_status < 0) { /* Somehow, the session daemon is not responding anymore. */ goto end_destroy_channel; } @@ -1015,13 +1030,13 @@ error_streams_sent_nosignal: * This command should ONLY be issued for channel with streams set in * no monitor mode. */ - assert(!channel->monitor); + LTTNG_ASSERT(!channel->monitor); /* * The refcount should ALWAYS be 0 in the case of a channel in no * monitor mode. */ - assert(!uatomic_sub_return(&channel->refcount, 1)); + LTTNG_ASSERT(!uatomic_sub_return(&channel->refcount, 1)); consumer_del_channel(channel); end_destroy_channel: @@ -1092,39 +1107,43 @@ end_destroy_channel: case LTTNG_CONSUMER_SET_CHANNEL_MONITOR_PIPE: { int channel_monitor_pipe; + int ret_send_status, ret_set_channel_monitor_pipe; + ssize_t ret_recv; ret_code = LTTCOMM_CONSUMERD_SUCCESS; /* Successfully received the command's type. */ - ret = consumer_send_status_msg(sock, ret_code); - if (ret < 0) { + ret_send_status = consumer_send_status_msg(sock, ret_code); + if (ret_send_status < 0) { goto error_fatal; } - ret = lttcomm_recv_fds_unix_sock(sock, &channel_monitor_pipe, - 1); - if (ret != sizeof(channel_monitor_pipe)) { + ret_recv = lttcomm_recv_fds_unix_sock( + sock, &channel_monitor_pipe, 1); + if (ret_recv != sizeof(channel_monitor_pipe)) { ERR("Failed to receive channel monitor pipe"); goto error_fatal; } DBG("Received channel monitor pipe (%d)", channel_monitor_pipe); - ret = consumer_timer_thread_set_channel_monitor_pipe( - channel_monitor_pipe); - if (!ret) { + ret_set_channel_monitor_pipe = + consumer_timer_thread_set_channel_monitor_pipe( + channel_monitor_pipe); + if (!ret_set_channel_monitor_pipe) { int flags; + int ret_fcntl; ret_code = LTTCOMM_CONSUMERD_SUCCESS; /* Set the pipe as non-blocking. */ - ret = fcntl(channel_monitor_pipe, F_GETFL, 0); - if (ret == -1) { + ret_fcntl = fcntl(channel_monitor_pipe, F_GETFL, 0); + if (ret_fcntl == -1) { PERROR("fcntl get flags of the channel monitoring pipe"); goto error_fatal; } - flags = ret; + flags = ret_fcntl; - ret = fcntl(channel_monitor_pipe, F_SETFL, + ret_fcntl = fcntl(channel_monitor_pipe, F_SETFL, flags | O_NONBLOCK); - if (ret == -1) { + if (ret_fcntl == -1) { PERROR("fcntl set O_NONBLOCK flag of the channel monitoring pipe"); goto error_fatal; } @@ -1132,8 +1151,8 @@ end_destroy_channel: } else { ret_code = LTTCOMM_CONSUMERD_ALREADY_SET; } - ret = consumer_send_status_msg(sock, ret_code); - if (ret < 0) { + ret_send_status = consumer_send_status_msg(sock, ret_code); + if (ret_send_status < 0) { goto error_fatal; } break; @@ -1142,6 +1161,7 @@ end_destroy_channel: { struct lttng_consumer_channel *channel; uint64_t key = msg.u.rotate_channel.key; + int ret_send_status; DBG("Consumer rotate channel %" PRIu64, key); @@ -1153,27 +1173,32 @@ end_destroy_channel: /* * Sample the rotate position of all the streams in this channel. */ - ret = lttng_consumer_rotate_channel(channel, key, + int ret_rotate_channel; + + ret_rotate_channel = lttng_consumer_rotate_channel( + channel, key, msg.u.rotate_channel.relayd_id, - msg.u.rotate_channel.metadata, - ctx); - if (ret < 0) { + msg.u.rotate_channel.metadata, ctx); + if (ret_rotate_channel < 0) { ERR("Rotate channel failed"); ret_code = LTTCOMM_CONSUMERD_ROTATION_FAIL; } health_code_update(); } - ret = consumer_send_status_msg(sock, ret_code); - if (ret < 0) { + + ret_send_status = consumer_send_status_msg(sock, ret_code); + if (ret_send_status < 0) { /* Somehow, the session daemon is not responding anymore. */ goto error_rotate_channel; } if (channel) { /* Rotate the streams that are ready right now. */ - ret = lttng_consumer_rotate_ready_streams( + int ret_rotate; + + ret_rotate = lttng_consumer_rotate_ready_streams( channel, key, ctx); - if (ret < 0) { + if (ret_rotate < 0) { ERR("Rotate ready streams failed"); } } @@ -1185,22 +1210,27 @@ error_rotate_channel: { struct lttng_consumer_channel *channel; uint64_t key = msg.u.clear_channel.key; + int ret_send_status; channel = consumer_find_channel(key); if (!channel) { DBG("Channel %" PRIu64 " not found", key); ret_code = LTTCOMM_CONSUMERD_CHAN_NOT_FOUND; } else { - ret = lttng_consumer_clear_channel(channel); - if (ret) { + int ret_clear_channel; + + ret_clear_channel = + lttng_consumer_clear_channel(channel); + if (ret_clear_channel) { ERR("Clear channel failed"); - ret_code = ret; + ret_code = ret_clear_channel; } health_code_update(); } - ret = consumer_send_status_msg(sock, ret_code); - if (ret < 0) { + + ret_send_status = consumer_send_status_msg(sock, ret_code); + if (ret_send_status < 0) { /* Somehow, the session daemon is not responding anymore. */ goto end_nosignal; } @@ -1209,11 +1239,13 @@ error_rotate_channel: } case LTTNG_CONSUMER_INIT: { + int ret_send_status; + ret_code = lttng_consumer_init_command(ctx, msg.u.init.sessiond_uuid); health_code_update(); - ret = consumer_send_status_msg(sock, ret_code); - if (ret < 0) { + ret_send_status = consumer_send_status_msg(sock, ret_code); + if (ret_send_status < 0) { /* Somehow, the session daemon is not responding anymore. */ goto end_nosignal; } @@ -1222,8 +1254,8 @@ error_rotate_channel: case LTTNG_CONSUMER_CREATE_TRACE_CHUNK: { const struct lttng_credentials credentials = { - .uid = msg.u.create_trace_chunk.credentials.value.uid, - .gid = msg.u.create_trace_chunk.credentials.value.gid, + .uid = LTTNG_OPTIONAL_INIT_VALUE(msg.u.create_trace_chunk.credentials.value.uid), + .gid = LTTNG_OPTIONAL_INIT_VALUE(msg.u.create_trace_chunk.credentials.value.gid), }; const bool is_local_trace = !msg.u.create_trace_chunk.relayd_id.is_set; @@ -1241,17 +1273,20 @@ error_rotate_channel: */ if (is_local_trace) { int chunk_dirfd; + int ret_send_status; + ssize_t ret_recv; /* Acnowledge the reception of the command. */ - ret = consumer_send_status_msg(sock, - LTTCOMM_CONSUMERD_SUCCESS); - if (ret < 0) { + ret_send_status = consumer_send_status_msg( + sock, LTTCOMM_CONSUMERD_SUCCESS); + if (ret_send_status < 0) { /* Somehow, the session daemon is not responding anymore. */ goto end_nosignal; } - ret = lttcomm_recv_fds_unix_sock(sock, &chunk_dirfd, 1); - if (ret != sizeof(chunk_dirfd)) { + ret_recv = lttcomm_recv_fds_unix_sock( + sock, &chunk_dirfd, 1); + if (ret_recv != sizeof(chunk_dirfd)) { ERR("Failed to receive trace chunk directory file descriptor"); goto error_fatal; } @@ -1291,6 +1326,7 @@ error_rotate_channel: msg.u.close_trace_chunk.relayd_id.value; struct lttcomm_consumer_close_trace_chunk_reply reply; char path[LTTNG_PATH_MAX]; + ssize_t ret_send; ret_code = lttng_consumer_close_trace_chunk( msg.u.close_trace_chunk.relayd_id.is_set ? @@ -1304,12 +1340,13 @@ error_rotate_channel: NULL, path); reply.ret_code = ret_code; reply.path_length = strlen(path) + 1; - ret = lttcomm_send_unix_sock(sock, &reply, sizeof(reply)); - if (ret != sizeof(reply)) { + ret_send = lttcomm_send_unix_sock(sock, &reply, sizeof(reply)); + if (ret_send != sizeof(reply)) { goto error_fatal; } - ret = lttcomm_send_unix_sock(sock, path, reply.path_length); - if (ret != reply.path_length) { + ret_send = lttcomm_send_unix_sock( + sock, path, reply.path_length); + if (ret_send != reply.path_length) { goto error_fatal; } goto end_nosignal; @@ -1326,6 +1363,24 @@ error_rotate_channel: msg.u.trace_chunk_exists.chunk_id); goto end_msg_sessiond; } + case LTTNG_CONSUMER_OPEN_CHANNEL_PACKETS: + { + const uint64_t key = msg.u.open_channel_packets.key; + struct lttng_consumer_channel *channel = + consumer_find_channel(key); + + if (channel) { + pthread_mutex_lock(&channel->lock); + ret_code = lttng_consumer_open_channel_packets(channel); + pthread_mutex_unlock(&channel->lock); + } else { + WARN("Channel %" PRIu64 " not found", key); + ret_code = LTTCOMM_CONSUMERD_CHAN_NOT_FOUND; + } + + health_code_update(); + goto end_msg_sessiond; + } default: goto end_nosignal; } @@ -1335,11 +1390,11 @@ end_nosignal: * Return 1 to indicate success since the 0 value can be a socket * shutdown during the recv() or send() call. */ - ret = 1; + ret_func = 1; goto end; error_fatal: /* This will issue a consumer stop. */ - ret = -1; + ret_func = -1; goto end; end_msg_sessiond: /* @@ -1347,483 +1402,427 @@ end_msg_sessiond: * the caller because the session daemon socket management is done * elsewhere. Returning a negative code or 0 will shutdown the consumer. */ - ret = consumer_send_status_msg(sock, ret_code); - if (ret < 0) { - goto error_fatal; + { + int ret_send_status; + + ret_send_status = consumer_send_status_msg(sock, ret_code); + if (ret_send_status < 0) { + goto error_fatal; + } } - ret = 1; + + ret_func = 1; + end: health_code_update(); rcu_read_unlock(); - return ret; + return ret_func; } /* - * Populate index values of a kernel stream. Values are set in big endian order. + * Sync metadata meaning request them to the session daemon and snapshot to the + * metadata thread can consumer them. * - * Return 0 on success or else a negative value. + * Metadata stream lock MUST be acquired. */ -static int get_index_values(struct ctf_packet_index *index, int infd) +enum sync_metadata_status lttng_kconsumer_sync_metadata( + struct lttng_consumer_stream *metadata) { int ret; - uint64_t packet_size, content_size, timestamp_begin, timestamp_end, - events_discarded, stream_id, stream_instance_id, - packet_seq_num; + enum sync_metadata_status status; - ret = kernctl_get_timestamp_begin(infd, ×tamp_begin); - if (ret < 0) { - PERROR("kernctl_get_timestamp_begin"); - goto error; - } + LTTNG_ASSERT(metadata); - ret = kernctl_get_timestamp_end(infd, ×tamp_end); + ret = kernctl_buffer_flush(metadata->wait_fd); if (ret < 0) { - PERROR("kernctl_get_timestamp_end"); - goto error; + ERR("Failed to flush kernel stream"); + status = SYNC_METADATA_STATUS_ERROR; + goto end; } - ret = kernctl_get_events_discarded(infd, &events_discarded); + ret = kernctl_snapshot(metadata->wait_fd); if (ret < 0) { - PERROR("kernctl_get_events_discarded"); - goto error; + if (errno == EAGAIN) { + /* No new metadata, exit. */ + DBG("Sync metadata, no new kernel metadata"); + status = SYNC_METADATA_STATUS_NO_DATA; + } else { + ERR("Sync metadata, taking kernel snapshot failed."); + status = SYNC_METADATA_STATUS_ERROR; + } + } else { + status = SYNC_METADATA_STATUS_NEW_DATA; } - ret = kernctl_get_content_size(infd, &content_size); - if (ret < 0) { - PERROR("kernctl_get_content_size"); - goto error; - } +end: + return status; +} - ret = kernctl_get_packet_size(infd, &packet_size); - if (ret < 0) { - PERROR("kernctl_get_packet_size"); - goto error; - } +static +int extract_common_subbuffer_info(struct lttng_consumer_stream *stream, + struct stream_subbuffer *subbuf) +{ + int ret; - ret = kernctl_get_stream_id(infd, &stream_id); - if (ret < 0) { - PERROR("kernctl_get_stream_id"); - goto error; + ret = kernctl_get_subbuf_size( + stream->wait_fd, &subbuf->info.data.subbuf_size); + if (ret) { + goto end; } - ret = kernctl_get_instance_id(infd, &stream_instance_id); - if (ret < 0) { - if (ret == -ENOTTY) { - /* Command not implemented by lttng-modules. */ - stream_instance_id = -1ULL; - } else { - PERROR("kernctl_get_instance_id"); - goto error; - } + ret = kernctl_get_padded_subbuf_size( + stream->wait_fd, &subbuf->info.data.padded_subbuf_size); + if (ret) { + goto end; } - ret = kernctl_get_sequence_number(infd, &packet_seq_num); - if (ret < 0) { - if (ret == -ENOTTY) { - /* Command not implemented by lttng-modules. */ - packet_seq_num = -1ULL; - ret = 0; - } else { - PERROR("kernctl_get_sequence_number"); - goto error; - } +end: + return ret; +} + +static +int extract_metadata_subbuffer_info(struct lttng_consumer_stream *stream, + struct stream_subbuffer *subbuf) +{ + int ret; + + ret = extract_common_subbuffer_info(stream, subbuf); + if (ret) { + goto end; } - index->packet_seq_num = htobe64(index->packet_seq_num); - *index = (typeof(*index)) { - .offset = index->offset, - .packet_size = htobe64(packet_size), - .content_size = htobe64(content_size), - .timestamp_begin = htobe64(timestamp_begin), - .timestamp_end = htobe64(timestamp_end), - .events_discarded = htobe64(events_discarded), - .stream_id = htobe64(stream_id), - .stream_instance_id = htobe64(stream_instance_id), - .packet_seq_num = htobe64(packet_seq_num), - }; + ret = kernctl_get_metadata_version( + stream->wait_fd, &subbuf->info.metadata.version); + if (ret) { + goto end; + } -error: +end: return ret; } -/* - * Sync metadata meaning request them to the session daemon and snapshot to the - * metadata thread can consumer them. - * - * Metadata stream lock MUST be acquired. - * - * Return 0 if new metadatda is available, EAGAIN if the metadata stream - * is empty or a negative value on error. - */ -int lttng_kconsumer_sync_metadata(struct lttng_consumer_stream *metadata) + +static +int extract_data_subbuffer_info(struct lttng_consumer_stream *stream, + struct stream_subbuffer *subbuf) { int ret; - assert(metadata); + ret = extract_common_subbuffer_info(stream, subbuf); + if (ret) { + goto end; + } - ret = kernctl_buffer_flush(metadata->wait_fd); + ret = kernctl_get_packet_size( + stream->wait_fd, &subbuf->info.data.packet_size); if (ret < 0) { - ERR("Failed to flush kernel stream"); + PERROR("Failed to get sub-buffer packet size"); goto end; } - ret = kernctl_snapshot(metadata->wait_fd); + ret = kernctl_get_content_size( + stream->wait_fd, &subbuf->info.data.content_size); if (ret < 0) { - if (ret != -EAGAIN) { - ERR("Sync metadata, taking kernel snapshot failed."); + PERROR("Failed to get sub-buffer content size"); + goto end; + } + + ret = kernctl_get_timestamp_begin( + stream->wait_fd, &subbuf->info.data.timestamp_begin); + if (ret < 0) { + PERROR("Failed to get sub-buffer begin timestamp"); + goto end; + } + + ret = kernctl_get_timestamp_end( + stream->wait_fd, &subbuf->info.data.timestamp_end); + if (ret < 0) { + PERROR("Failed to get sub-buffer end timestamp"); + goto end; + } + + ret = kernctl_get_events_discarded( + stream->wait_fd, &subbuf->info.data.events_discarded); + if (ret) { + PERROR("Failed to get sub-buffer events discarded count"); + goto end; + } + + ret = kernctl_get_sequence_number(stream->wait_fd, + &subbuf->info.data.sequence_number.value); + if (ret) { + /* May not be supported by older LTTng-modules. */ + if (ret != -ENOTTY) { + PERROR("Failed to get sub-buffer sequence number"); goto end; } - DBG("Sync metadata, no new kernel metadata"); - /* No new metadata, exit. */ - ret = ENODATA; + } else { + subbuf->info.data.sequence_number.is_set = true; + } + + ret = kernctl_get_stream_id( + stream->wait_fd, &subbuf->info.data.stream_id); + if (ret < 0) { + PERROR("Failed to get stream id"); goto end; } + ret = kernctl_get_instance_id(stream->wait_fd, + &subbuf->info.data.stream_instance_id.value); + if (ret) { + /* May not be supported by older LTTng-modules. */ + if (ret != -ENOTTY) { + PERROR("Failed to get stream instance id"); + goto end; + } + } else { + subbuf->info.data.stream_instance_id.is_set = true; + } end: return ret; } static -int update_stream_stats(struct lttng_consumer_stream *stream) +enum get_next_subbuffer_status get_subbuffer_common( + struct lttng_consumer_stream *stream, + struct stream_subbuffer *subbuffer) { int ret; - uint64_t seq, discarded; + enum get_next_subbuffer_status status; - ret = kernctl_get_sequence_number(stream->wait_fd, &seq); - if (ret < 0) { - if (ret == -ENOTTY) { - /* Command not implemented by lttng-modules. */ - seq = -1ULL; - stream->sequence_number_unavailable = true; - } else { - PERROR("kernctl_get_sequence_number"); - goto end; - } + ret = kernctl_get_next_subbuf(stream->wait_fd); + switch (ret) { + case 0: + status = GET_NEXT_SUBBUFFER_STATUS_OK; + break; + case -ENODATA: + case -EAGAIN: + /* + * The caller only expects -ENODATA when there is no data to + * read, but the kernel tracer returns -EAGAIN when there is + * currently no data for a non-finalized stream, and -ENODATA + * when there is no data for a finalized stream. Those can be + * combined into a -ENODATA return value. + */ + status = GET_NEXT_SUBBUFFER_STATUS_NO_DATA; + goto end; + default: + status = GET_NEXT_SUBBUFFER_STATUS_ERROR; + goto end; } - /* - * Start the sequence when we extract the first packet in case we don't - * start at 0 (for example if a consumer is not connected to the - * session immediately after the beginning). - */ - if (stream->last_sequence_number == -1ULL) { - stream->last_sequence_number = seq; - } else if (seq > stream->last_sequence_number) { - stream->chan->lost_packets += seq - - stream->last_sequence_number - 1; - } else { - /* seq <= last_sequence_number */ - ERR("Sequence number inconsistent : prev = %" PRIu64 - ", current = %" PRIu64, - stream->last_sequence_number, seq); - ret = -1; - goto end; + ret = stream->read_subbuffer_ops.extract_subbuffer_info( + stream, subbuffer); + if (ret) { + status = GET_NEXT_SUBBUFFER_STATUS_ERROR; } - stream->last_sequence_number = seq; +end: + return status; +} - ret = kernctl_get_events_discarded(stream->wait_fd, &discarded); - if (ret < 0) { - PERROR("kernctl_get_events_discarded"); +static +enum get_next_subbuffer_status get_next_subbuffer_splice( + struct lttng_consumer_stream *stream, + struct stream_subbuffer *subbuffer) +{ + const enum get_next_subbuffer_status status = + get_subbuffer_common(stream, subbuffer); + + if (status != GET_NEXT_SUBBUFFER_STATUS_OK) { goto end; } - if (discarded < stream->last_discarded_events) { - /* - * Overflow has occurred. We assume only one wrap-around - * has occurred. - */ - stream->chan->discarded_events += (1ULL << (CAA_BITS_PER_LONG - 1)) - - stream->last_discarded_events + discarded; - } else { - stream->chan->discarded_events += discarded - - stream->last_discarded_events; - } - stream->last_discarded_events = discarded; - ret = 0; + subbuffer->buffer.fd = stream->wait_fd; end: - return ret; + return status; } -/* - * Check if the local version of the metadata stream matches with the version - * of the metadata stream in the kernel. If it was updated, set the reset flag - * on the stream. - */ static -int metadata_stream_check_version(int infd, struct lttng_consumer_stream *stream) +enum get_next_subbuffer_status get_next_subbuffer_mmap( + struct lttng_consumer_stream *stream, + struct stream_subbuffer *subbuffer) { int ret; - uint64_t cur_version; + enum get_next_subbuffer_status status; + const char *addr; - ret = kernctl_get_metadata_version(infd, &cur_version); - if (ret < 0) { - if (ret == -ENOTTY) { - /* - * LTTng-modules does not implement this - * command. - */ - ret = 0; - goto end; - } - ERR("Failed to get the metadata version"); + status = get_subbuffer_common(stream, subbuffer); + if (status != GET_NEXT_SUBBUFFER_STATUS_OK) { goto end; } - if (stream->metadata_version == cur_version) { - ret = 0; + ret = get_current_subbuf_addr(stream, &addr); + if (ret) { + status = GET_NEXT_SUBBUFFER_STATUS_ERROR; goto end; } - DBG("New metadata version detected"); - stream->metadata_version = cur_version; - stream->reset_metadata_flag = 1; - ret = 0; - + subbuffer->buffer.buffer = lttng_buffer_view_init( + addr, 0, subbuffer->info.data.padded_subbuf_size); end: - return ret; + return status; } -/* - * Consume data on a file descriptor and write it on a trace file. - * The stream and channel locks must be held by the caller. - */ -ssize_t lttng_kconsumer_read_subbuffer(struct lttng_consumer_stream *stream, - struct lttng_consumer_local_data *ctx) +static +enum get_next_subbuffer_status get_next_subbuffer_metadata_check(struct lttng_consumer_stream *stream, + struct stream_subbuffer *subbuffer) { - unsigned long len, subbuf_size, padding; - int err, write_index = 1; - ssize_t ret = 0; - int infd = stream->wait_fd; - struct ctf_packet_index index = {}; - bool in_error_state = false; + int ret; + const char *addr; + bool coherent; + enum get_next_subbuffer_status status; - DBG("In read_subbuffer (infd : %d)", infd); + ret = kernctl_get_next_subbuf_metadata_check(stream->wait_fd, + &coherent); + if (ret) { + goto end; + } + + ret = stream->read_subbuffer_ops.extract_subbuffer_info( + stream, subbuffer); + if (ret) { + goto end; + } + + LTTNG_OPTIONAL_SET(&subbuffer->info.metadata.coherent, coherent); + ret = get_current_subbuf_addr(stream, &addr); + if (ret) { + goto end; + } - /* Get the next subbuffer */ - err = kernctl_get_next_subbuf(infd); - if (err != 0) { + subbuffer->buffer.buffer = lttng_buffer_view_init( + addr, 0, subbuffer->info.data.padded_subbuf_size); + DBG("Got metadata packet with padded_subbuf_size = %lu, coherent = %s", + subbuffer->info.metadata.padded_subbuf_size, + coherent ? "true" : "false"); +end: + /* + * The caller only expects -ENODATA when there is no data to read, but + * the kernel tracer returns -EAGAIN when there is currently no data + * for a non-finalized stream, and -ENODATA when there is no data for a + * finalized stream. Those can be combined into a -ENODATA return value. + */ + switch (ret) { + case 0: + status = GET_NEXT_SUBBUFFER_STATUS_OK; + break; + case -ENODATA: + case -EAGAIN: /* - * This is a debug message even for single-threaded consumer, - * because poll() have more relaxed criterions than get subbuf, - * so get_subbuf may fail for short race windows where poll() - * would issue wakeups. + * The caller only expects -ENODATA when there is no data to + * read, but the kernel tracer returns -EAGAIN when there is + * currently no data for a non-finalized stream, and -ENODATA + * when there is no data for a finalized stream. Those can be + * combined into a -ENODATA return value. */ - DBG("Reserving sub buffer failed (everything is normal, " - "it is due to concurrency)"); - ret = err; - goto error; + status = GET_NEXT_SUBBUFFER_STATUS_NO_DATA; + break; + default: + status = GET_NEXT_SUBBUFFER_STATUS_ERROR; + break; } - /* Get the full subbuffer size including padding */ - err = kernctl_get_padded_subbuf_size(infd, &len); - if (err != 0) { - PERROR("Getting sub-buffer len failed."); - err = kernctl_put_subbuf(infd); - if (err != 0) { - if (err == -EFAULT) { - PERROR("Error in unreserving sub buffer\n"); - } else if (err == -EIO) { - /* Should never happen with newer LTTng versions */ - PERROR("Reader has been pushed by the writer, last sub-buffer corrupted."); - } - ret = err; - goto error; - } - ret = err; - goto error; - } + return status; +} - if (!stream->metadata_flag) { - ret = get_index_values(&index, infd); - if (ret < 0) { - err = kernctl_put_subbuf(infd); - if (err != 0) { - if (err == -EFAULT) { - PERROR("Error in unreserving sub buffer\n"); - } else if (err == -EIO) { - /* Should never happen with newer LTTng versions */ - PERROR("Reader has been pushed by the writer, last sub-buffer corrupted."); - } - ret = err; - goto error; - } - goto error; - } - ret = update_stream_stats(stream); - if (ret < 0) { - err = kernctl_put_subbuf(infd); - if (err != 0) { - if (err == -EFAULT) { - PERROR("Error in unreserving sub buffer\n"); - } else if (err == -EIO) { - /* Should never happen with newer LTTng versions */ - PERROR("Reader has been pushed by the writer, last sub-buffer corrupted."); - } - ret = err; - goto error; - } - goto error; - } - } else { - write_index = 0; - ret = metadata_stream_check_version(infd, stream); - if (ret < 0) { - err = kernctl_put_subbuf(infd); - if (err != 0) { - if (err == -EFAULT) { - PERROR("Error in unreserving sub buffer\n"); - } else if (err == -EIO) { - /* Should never happen with newer LTTng versions */ - PERROR("Reader has been pushed by the writer, last sub-buffer corrupted."); - } - ret = err; - goto error; - } - goto error; +static +int put_next_subbuffer(struct lttng_consumer_stream *stream, + struct stream_subbuffer *subbuffer) +{ + const int ret = kernctl_put_next_subbuf(stream->wait_fd); + + if (ret) { + if (ret == -EFAULT) { + PERROR("Error in unreserving sub buffer"); + } else if (ret == -EIO) { + /* Should never happen with newer LTTng versions */ + PERROR("Reader has been pushed by the writer, last sub-buffer corrupted"); } } - switch (stream->chan->output) { - case CONSUMER_CHANNEL_SPLICE: - /* - * XXX: The lttng-modules splice "actor" does not handle copying - * partial pages hence only using the subbuffer size without the - * padding makes the splice fail. - */ - subbuf_size = len; - padding = 0; + return ret; +} - /* splice the subbuffer to the tracefile */ - ret = lttng_consumer_on_read_subbuffer_splice(ctx, stream, subbuf_size, - padding, &index); - /* - * XXX: Splice does not support network streaming so the return value - * is simply checked against subbuf_size and not like the mmap() op. - */ - if (ret != subbuf_size) { - /* - * display the error but continue processing to try - * to release the subbuffer - */ - ERR("Error splicing to tracefile (ret: %zd != len: %lu)", - ret, subbuf_size); - write_index = 0; - } - break; - case CONSUMER_CHANNEL_MMAP: - { - const char *subbuf_addr; - struct lttng_buffer_view subbuf_view; - - /* Get subbuffer size without padding */ - err = kernctl_get_subbuf_size(infd, &subbuf_size); - if (err != 0) { - PERROR("Getting sub-buffer len failed."); - err = kernctl_put_subbuf(infd); - if (err != 0) { - if (err == -EFAULT) { - PERROR("Error in unreserving sub buffer\n"); - } else if (err == -EIO) { - /* Should never happen with newer LTTng versions */ - PERROR("Reader has been pushed by the writer, last sub-buffer corrupted."); - } - ret = err; - goto error; - } - ret = err; - goto error; - } +static +bool is_get_next_check_metadata_available(int tracer_fd) +{ + const int ret = kernctl_get_next_subbuf_metadata_check(tracer_fd, NULL); + const bool available = ret != -ENOTTY; - ret = get_current_subbuf_addr(stream, &subbuf_addr); - if (ret) { - goto error_put_subbuf; - } + if (ret == 0) { + /* get succeeded, make sure to put the subbuffer. */ + kernctl_put_subbuf(tracer_fd); + } - /* Make sure the tracer is not gone mad on us! */ - assert(len >= subbuf_size); + return available; +} - padding = len - subbuf_size; +static +int signal_metadata(struct lttng_consumer_stream *stream, + struct lttng_consumer_local_data *ctx) +{ + ASSERT_LOCKED(stream->metadata_rdv_lock); + return pthread_cond_broadcast(&stream->metadata_rdv) ? -errno : 0; +} - subbuf_view = lttng_buffer_view_init(subbuf_addr, 0, len); +static +int lttng_kconsumer_set_stream_ops( + struct lttng_consumer_stream *stream) +{ + int ret = 0; - /* write the subbuffer to the tracefile */ - ret = lttng_consumer_on_read_subbuffer_mmap( - ctx, stream, &subbuf_view, padding, &index); - /* - * The mmap operation should write subbuf_size amount of data - * when network streaming or the full padding (len) size when we - * are _not_ streaming. - */ - if ((ret != subbuf_size && stream->net_seq_idx != (uint64_t) -1ULL) || - (ret != len && stream->net_seq_idx == (uint64_t) -1ULL)) { + if (stream->metadata_flag && stream->chan->is_live) { + DBG("Attempting to enable metadata bucketization for live consumers"); + if (is_get_next_check_metadata_available(stream->wait_fd)) { + DBG("Kernel tracer supports get_next_subbuffer_metadata_check, metadata will be accumulated until a coherent state is reached"); + stream->read_subbuffer_ops.get_next_subbuffer = + get_next_subbuffer_metadata_check; + ret = consumer_stream_enable_metadata_bucketization( + stream); + if (ret) { + goto end; + } + } else { /* - * Display the error but continue processing to try to release the - * subbuffer. This is a DBG statement since this is possible to - * happen without being a critical error. + * The kernel tracer version is too old to indicate + * when the metadata stream has reached a "coherent" + * (parseable) point. + * + * This means that a live viewer may see an incoherent + * sequence of metadata and fail to parse it. */ - DBG("Error writing to tracefile " - "(ret: %zd != len: %lu != subbuf_size: %lu)", - ret, len, subbuf_size); - write_index = 0; - } - break; - } - default: - ERR("Unknown output method"); - ret = -EPERM; - } -error_put_subbuf: - err = kernctl_put_next_subbuf(infd); - if (err != 0) { - if (err == -EFAULT) { - PERROR("Error in unreserving sub buffer\n"); - } else if (err == -EIO) { - /* Should never happen with newer LTTng versions */ - PERROR("Reader has been pushed by the writer, last sub-buffer corrupted."); + WARN("Kernel tracer does not support get_next_subbuffer_metadata_check which may cause live clients to fail to parse the metadata stream"); + metadata_bucket_destroy(stream->metadata_bucket); + stream->metadata_bucket = NULL; } - ret = err; - goto error; - } else if (in_error_state) { - goto error; - } - /* Write index if needed. */ - if (!write_index) { - goto end; + stream->read_subbuffer_ops.on_sleep = signal_metadata; } - if (stream->chan->live_timer_interval && !stream->metadata_flag) { - /* - * In live, block until all the metadata is sent. - */ - pthread_mutex_lock(&stream->metadata_timer_lock); - assert(!stream->missed_metadata_flush); - stream->waiting_on_metadata = true; - pthread_mutex_unlock(&stream->metadata_timer_lock); - - err = consumer_stream_sync_metadata(ctx, stream->session_id); - - pthread_mutex_lock(&stream->metadata_timer_lock); - stream->waiting_on_metadata = false; - if (stream->missed_metadata_flush) { - stream->missed_metadata_flush = false; - pthread_mutex_unlock(&stream->metadata_timer_lock); - (void) consumer_flush_kernel_index(stream); + if (!stream->read_subbuffer_ops.get_next_subbuffer) { + if (stream->chan->output == CONSUMER_CHANNEL_MMAP) { + stream->read_subbuffer_ops.get_next_subbuffer = + get_next_subbuffer_mmap; } else { - pthread_mutex_unlock(&stream->metadata_timer_lock); - } - if (err < 0) { - goto error; + stream->read_subbuffer_ops.get_next_subbuffer = + get_next_subbuffer_splice; } } - err = consumer_stream_write_index(stream, &index); - if (err < 0) { - goto error; + if (stream->metadata_flag) { + stream->read_subbuffer_ops.extract_subbuffer_info = + extract_metadata_subbuffer_info; + } else { + stream->read_subbuffer_ops.extract_subbuffer_info = + extract_data_subbuffer_info; + if (stream->chan->is_live) { + stream->read_subbuffer_ops.send_live_beacon = + consumer_flush_kernel_index; + } } + stream->read_subbuffer_ops.put_next_subbuffer = put_next_subbuffer; end: -error: return ret; } @@ -1831,7 +1830,7 @@ int lttng_kconsumer_on_recv_stream(struct lttng_consumer_stream *stream) { int ret; - assert(stream); + LTTNG_ASSERT(stream); /* * Don't create anything if this is set for streaming or if there is @@ -1865,6 +1864,11 @@ int lttng_kconsumer_on_recv_stream(struct lttng_consumer_stream *stream) } } + ret = lttng_kconsumer_set_stream_ops(stream); + if (ret) { + goto error_close_fd; + } + /* we return 0 to let the library handle the FD internally */ return 0; @@ -1873,7 +1877,7 @@ error_close_fd: int err; err = close(stream->out_fd); - assert(!err); + LTTNG_ASSERT(!err); stream->out_fd = -1; } error: @@ -1892,7 +1896,7 @@ int lttng_kconsumer_data_pending(struct lttng_consumer_stream *stream) { int ret; - assert(stream); + LTTNG_ASSERT(stream); if (stream->endpoint_status != CONSUMER_ENDPOINT_ACTIVE) { ret = 0; @@ -1903,7 +1907,7 @@ int lttng_kconsumer_data_pending(struct lttng_consumer_stream *stream) if (ret == 0) { /* There is still data so let's put back this subbuffer. */ ret = kernctl_put_subbuf(stream->wait_fd); - assert(ret == 0); + LTTNG_ASSERT(ret == 0); ret = 1; /* Data is pending */ goto end; }