X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fkernel-consumer%2Fkernel-consumer.c;h=ecacadfd5bae7dc2b423bdae3b5023cb835d797b;hp=e06f3b3e079aae44f494ba6d4409f02120018af4;hb=0c5b37182381d8350ead74f5c10f272c746e3277;hpb=6f9449c22eef59294cf1e1dc3610a5cbf14baec0 diff --git a/src/common/kernel-consumer/kernel-consumer.c b/src/common/kernel-consumer/kernel-consumer.c index e06f3b3e0..ecacadfd5 100644 --- a/src/common/kernel-consumer/kernel-consumer.c +++ b/src/common/kernel-consumer/kernel-consumer.c @@ -19,6 +19,7 @@ #include #include #include +#include #include #include @@ -36,7 +37,7 @@ #include #include #include -#include +#include #include "kernel-consumer.h" @@ -287,7 +288,7 @@ 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); /* @@ -450,19 +451,24 @@ 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(); @@ -488,14 +494,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; 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; } @@ -547,16 +553,20 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, 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"); @@ -569,15 +579,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; @@ -592,6 +602,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 @@ -610,8 +622,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; } @@ -625,18 +637,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; } @@ -647,8 +660,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; } @@ -681,9 +694,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; @@ -716,8 +729,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); @@ -743,9 +756,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); @@ -758,9 +773,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; @@ -784,8 +802,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)); @@ -809,6 +828,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 @@ -830,8 +850,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; } @@ -849,9 +870,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; @@ -870,6 +893,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); @@ -896,8 +920,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; } @@ -906,18 +930,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; } @@ -932,6 +958,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) { @@ -940,20 +967,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; } @@ -962,8 +997,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; } @@ -973,6 +1008,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) { @@ -982,8 +1018,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; } @@ -1076,39 +1112,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; } @@ -1116,8 +1156,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; @@ -1126,6 +1166,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); @@ -1137,27 +1178,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"); } } @@ -1169,22 +1215,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; } @@ -1193,11 +1244,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; } @@ -1206,8 +1259,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; @@ -1225,17 +1278,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; } @@ -1275,6 +1331,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 ? @@ -1288,12 +1345,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; @@ -1310,6 +1368,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; } @@ -1319,11 +1395,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: /* @@ -1331,15 +1407,21 @@ 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; } /* @@ -1347,36 +1429,38 @@ end: * 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) +enum sync_metadata_status lttng_kconsumer_sync_metadata( + struct lttng_consumer_stream *metadata) { int ret; + enum sync_metadata_status status; assert(metadata); ret = kernctl_buffer_flush(metadata->wait_fd); if (ret < 0) { ERR("Failed to flush kernel stream"); + status = SYNC_METADATA_STATUS_ERROR; goto end; } ret = kernctl_snapshot(metadata->wait_fd); if (ret < 0) { - if (ret != -EAGAIN) { + 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."); - goto end; + status = SYNC_METADATA_STATUS_ERROR; } - DBG("Sync metadata, no new kernel metadata"); - /* No new metadata, exit. */ - ret = ENODATA; - goto end; + } else { + status = SYNC_METADATA_STATUS_NEW_DATA; } end: - return ret; + return status; } static @@ -1558,6 +1642,42 @@ end: return ret; } +static +int get_next_subbuffer_metadata_check(struct lttng_consumer_stream *stream, + struct stream_subbuffer *subbuffer) +{ + int ret; + const char *addr; + bool coherent; + + 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; + } + + 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: + return ret; +} + static int put_next_subbuffer(struct lttng_consumer_stream *stream, struct stream_subbuffer *subbuffer) @@ -1576,15 +1696,53 @@ int put_next_subbuffer(struct lttng_consumer_stream *stream, return ret; } -static void lttng_kconsumer_set_stream_ops( +static +bool is_get_next_check_metadata_available(int tracer_fd) +{ + return kernctl_get_next_subbuf_metadata_check(tracer_fd, NULL) != + -ENOTTY; +} + +static +int lttng_kconsumer_set_stream_ops( struct lttng_consumer_stream *stream) { - if (stream->chan->output == CONSUMER_CHANNEL_MMAP) { - stream->read_subbuffer_ops.get_next_subbuffer = - get_next_subbuffer_mmap; - } else { - stream->read_subbuffer_ops.get_next_subbuffer = - get_next_subbuffer_splice; + int ret = 0; + + 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 { + /* + * 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. + */ + 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; + } + } + + 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 { + stream->read_subbuffer_ops.get_next_subbuffer = + get_next_subbuffer_splice; + } } if (stream->metadata_flag) { @@ -1600,6 +1758,8 @@ static void lttng_kconsumer_set_stream_ops( } stream->read_subbuffer_ops.put_next_subbuffer = put_next_subbuffer; +end: + return ret; } int lttng_kconsumer_on_recv_stream(struct lttng_consumer_stream *stream) @@ -1640,7 +1800,10 @@ int lttng_kconsumer_on_recv_stream(struct lttng_consumer_stream *stream) } } - lttng_kconsumer_set_stream_ops(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;