X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fust-consumer%2Fust-consumer.c;h=431b94626736d042d92db89db0774e7e941cc3e7;hp=f802c462d4393565d5c3da60be70bd6b8d1cad3e;hb=331744e34f56a5aec69b05d356d6901e67926acc;hpb=536322299f7fc9ef136a0d7e50ba8e1b5d7a754b diff --git a/src/common/ust-consumer/ust-consumer.c b/src/common/ust-consumer/ust-consumer.c index f802c462d..431b94626 100644 --- a/src/common/ust-consumer/ust-consumer.c +++ b/src/common/ust-consumer/ust-consumer.c @@ -29,11 +29,15 @@ #include #include #include +#include +#include #include #include #include #include +#include +#include #include "ust-consumer.h" @@ -42,56 +46,693 @@ extern int consumer_poll_timeout; extern volatile int consumer_quit; /* - * Wrapper over the mmap() read offset from ust-ctl library. Since this can be - * compiled out, we isolate it in this library. + * Free channel object and all streams associated with it. This MUST be used + * only and only if the channel has _NEVER_ been added to the global channel + * hash table. */ -int lttng_ustctl_get_mmap_read_offset(struct lttng_ust_shm_handle *handle, - struct lttng_ust_lib_ring_buffer *buf, unsigned long *off) +static void destroy_channel(struct lttng_consumer_channel *channel) { - return ustctl_get_mmap_read_offset(handle, buf, off); -}; + struct lttng_consumer_stream *stream, *stmp; + + assert(channel); + + DBG("UST consumer cleaning stream list"); + + cds_list_for_each_entry_safe(stream, stmp, &channel->streams.head, + send_node) { + cds_list_del(&stream->send_node); + ustctl_destroy_stream(stream->ustream); + free(stream); + } + + /* + * If a channel is available meaning that was created before the streams + * were, delete it. + */ + if (channel->uchan) { + lttng_ustconsumer_del_channel(channel); + } + free(channel); +} /* - * Take a snapshot for a specific fd + * Add channel to internal consumer state. * - * Returns 0 on success, < 0 on error + * Returns 0 on success or else a negative value. */ -int lttng_ustconsumer_take_snapshot(struct lttng_consumer_local_data *ctx, - struct lttng_consumer_stream *stream) +static int add_channel(struct lttng_consumer_channel *channel, + struct lttng_consumer_local_data *ctx) { int ret = 0; - ret = ustctl_snapshot(stream->chan->handle, stream->buf); - if (ret != 0) { - errno = -ret; - PERROR("Getting sub-buffer snapshot."); + assert(channel); + assert(ctx); + + if (ctx->on_recv_channel != NULL) { + ret = ctx->on_recv_channel(channel); + if (ret == 0) { + ret = consumer_add_channel(channel, ctx); + } else if (ret < 0) { + /* Most likely an ENOMEM. */ + lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_OUTFD_ERROR); + goto error; + } + } else { + ret = consumer_add_channel(channel, ctx); } + DBG("UST consumer channel added (key: %" PRIu64 ")", channel->key); + +error: return ret; } /* - * Get the produced position + * Allocate and return a consumer channel object. + */ +static struct lttng_consumer_channel *allocate_channel(uint64_t session_id, + const char *pathname, const char *name, uid_t uid, gid_t gid, + int relayd_id, uint64_t key, enum lttng_event_output output) +{ + assert(pathname); + assert(name); + + return consumer_allocate_channel(key, session_id, pathname, name, uid, gid, + relayd_id, output); +} + +/* + * Allocate and return a consumer stream object. If _alloc_ret is not NULL, the + * error value if applicable is set in it else it is kept untouched. * - * Returns 0 on success, < 0 on error + * Return NULL on error else the newly allocated stream object. */ -int lttng_ustconsumer_get_produced_snapshot( - struct lttng_consumer_local_data *ctx, - struct lttng_consumer_stream *stream, - unsigned long *pos) +static struct lttng_consumer_stream *allocate_stream(int cpu, int key, + struct lttng_consumer_channel *channel, + struct lttng_consumer_local_data *ctx, int *_alloc_ret) +{ + int alloc_ret; + struct lttng_consumer_stream *stream = NULL; + + assert(channel); + assert(ctx); + + stream = consumer_allocate_stream(channel->key, + key, + LTTNG_CONSUMER_ACTIVE_STREAM, + channel->name, + channel->uid, + channel->gid, + channel->relayd_id, + channel->session_id, + cpu, + &alloc_ret, + channel->type); + if (stream == NULL) { + switch (alloc_ret) { + case -ENOENT: + /* + * We could not find the channel. Can happen if cpu hotplug + * happens while tearing down. + */ + DBG3("Could not find channel"); + break; + case -ENOMEM: + case -EINVAL: + default: + lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_OUTFD_ERROR); + break; + } + goto error; + } + + stream->chan = channel; + +error: + if (_alloc_ret) { + *_alloc_ret = alloc_ret; + } + return stream; +} + +/* + * Send the given stream pointer to the corresponding thread. + * + * Returns 0 on success else a negative value. + */ +static int send_stream_to_thread(struct lttng_consumer_stream *stream, + struct lttng_consumer_local_data *ctx) +{ + int ret, stream_pipe; + + /* Get the right pipe where the stream will be sent. */ + if (stream->metadata_flag) { + stream_pipe = ctx->consumer_metadata_pipe[1]; + } else { + stream_pipe = ctx->consumer_data_pipe[1]; + } + + do { + ret = write(stream_pipe, &stream, sizeof(stream)); + } while (ret < 0 && errno == EINTR); + if (ret < 0) { + PERROR("Consumer write %s stream to pipe %d", + stream->metadata_flag ? "metadata" : "data", stream_pipe); + } + + return ret; +} + +/* + * Search for a relayd object related to the stream. If found, send the stream + * to the relayd. + * + * On success, returns 0 else a negative value. + */ +static int send_stream_to_relayd(struct lttng_consumer_stream *stream) +{ + int ret = 0; + struct consumer_relayd_sock_pair *relayd; + + assert(stream); + + relayd = consumer_find_relayd(stream->net_seq_idx); + if (relayd != NULL) { + pthread_mutex_lock(&relayd->ctrl_sock_mutex); + /* Add stream on the relayd */ + ret = relayd_add_stream(&relayd->control_sock, stream->name, + stream->chan->pathname, &stream->relayd_stream_id); + pthread_mutex_unlock(&relayd->ctrl_sock_mutex); + if (ret < 0) { + goto error; + } + } else if (stream->net_seq_idx != (uint64_t) -1ULL) { + ERR("Network sequence index %" PRIu64 " unknown. Not adding stream.", + stream->net_seq_idx); + ret = -1; + goto error; + } + +error: + return ret; +} + +/* + * Create streams for the given channel using liblttng-ust-ctl. + * + * Return 0 on success else a negative value. + */ +static int create_ust_streams(struct lttng_consumer_channel *channel, + struct lttng_consumer_local_data *ctx) +{ + int ret, cpu = 0; + struct ustctl_consumer_stream *ustream; + struct lttng_consumer_stream *stream; + + assert(channel); + assert(ctx); + + /* + * While a stream is available from ustctl. When NULL is returned, we've + * reached the end of the possible stream for the channel. + */ + while ((ustream = ustctl_create_stream(channel->uchan, cpu))) { + int wait_fd; + + wait_fd = ustctl_stream_get_wait_fd(ustream); + + /* Allocate consumer stream object. */ + stream = allocate_stream(cpu, wait_fd, channel, ctx, &ret); + if (!stream) { + goto error_alloc; + } + stream->ustream = ustream; + /* + * Store it so we can save multiple function calls afterwards since + * this value is used heavily in the stream threads. This is UST + * specific so this is why it's done after allocation. + */ + stream->wait_fd = wait_fd; + + /* + * Order is important this is why a list is used. On error, the caller + * should clean this list. + */ + cds_list_add_tail(&stream->send_node, &channel->streams.head); + + ret = ustctl_get_max_subbuf_size(stream->ustream, + &stream->max_sb_size); + if (ret < 0) { + ERR("ustctl_get_max_subbuf_size failed for stream %s", + stream->name); + goto error; + } + + /* Do actions once stream has been received. */ + if (ctx->on_recv_stream) { + ret = ctx->on_recv_stream(stream); + if (ret < 0) { + goto error; + } + } + + DBG("UST consumer add stream %s (key: %" PRIu64 ") with relayd id %" PRIu64, + stream->name, stream->key, stream->relayd_stream_id); + + /* Set next CPU stream. */ + channel->streams.count = ++cpu; + + /* Keep stream reference when creating metadata. */ + if (channel->type == CONSUMER_CHANNEL_TYPE_METADATA) { + channel->metadata_stream = stream; + } + } + + return 0; + +error: +error_alloc: + return ret; +} + +/* + * Create an UST channel with the given attributes and send it to the session + * daemon using the ust ctl API. + * + * Return 0 on success or else a negative value. + */ +static int create_ust_channel(struct ustctl_consumer_channel_attr *attr, + struct ustctl_consumer_channel **chanp) +{ + int ret; + struct ustctl_consumer_channel *channel; + + assert(attr); + assert(chanp); + + DBG3("Creating channel to ustctl with attr: [overwrite: %d, " + "subbuf_size: %" PRIu64 ", num_subbuf: %" PRIu64 ", " + "switch_timer_interval: %u, read_timer_interval: %u, " + "output: %d, type: %d", attr->overwrite, attr->subbuf_size, + attr->num_subbuf, attr->switch_timer_interval, + attr->read_timer_interval, attr->output, attr->type); + + channel = ustctl_create_channel(attr); + if (!channel) { + ret = -1; + goto error_create; + } + + *chanp = channel; + + return 0; + +error_create: + return ret; +} + +/* + * Send a single given stream to the session daemon using the sock. + * + * Return 0 on success else a negative value. + */ +static int send_sessiond_stream(int sock, struct lttng_consumer_stream *stream) +{ + int ret; + + assert(stream); + assert(sock >= 0); + + DBG2("UST consumer sending stream %" PRIu64 " to sessiond", stream->key); + + /* Send stream to session daemon. */ + ret = ustctl_send_stream_to_sessiond(sock, stream->ustream); + if (ret < 0) { + goto error; + } + +error: + return ret; +} + +/* + * Send channel to sessiond. + * + * Return 0 on success or else a negative value. + */ +static int send_sessiond_channel(int sock, + struct lttng_consumer_channel *channel, + struct lttng_consumer_local_data *ctx, int *relayd_error) { int ret; + struct lttng_consumer_stream *stream; - ret = ustctl_snapshot_get_produced(stream->chan->handle, - stream->buf, pos); - if (ret != 0) { - errno = -ret; - PERROR("kernctl_snapshot_get_produced"); + assert(channel); + assert(ctx); + assert(sock >= 0); + + DBG("UST consumer sending channel %s to sessiond", channel->name); + + /* Send channel to sessiond. */ + ret = ustctl_send_channel_to_sessiond(sock, channel->uchan); + if (ret < 0) { + goto error; + } + + ret = ustctl_channel_close_wakeup_fd(channel->uchan); + if (ret < 0) { + goto error; } + /* The channel was sent successfully to the sessiond at this point. */ + cds_list_for_each_entry(stream, &channel->streams.head, send_node) { + /* Try to send the stream to the relayd if one is available. */ + ret = send_stream_to_relayd(stream); + if (ret < 0) { + /* + * Flag that the relayd was the problem here probably due to a + * communicaton error on the socket. + */ + if (relayd_error) { + *relayd_error = 1; + } + goto error; + } + + /* Send stream to session daemon. */ + ret = send_sessiond_stream(sock, stream); + if (ret < 0) { + goto error; + } + } + + /* Tell sessiond there is no more stream. */ + ret = ustctl_send_stream_to_sessiond(sock, NULL); + if (ret < 0) { + goto error; + } + + DBG("UST consumer NULL stream sent to sessiond"); + + return 0; + +error: return ret; } +/* + * Creates a channel and streams and add the channel it to the channel internal + * state. The created stream must ONLY be sent once the GET_CHANNEL command is + * received. + * + * Return 0 on success or else, a negative value is returned and the channel + * MUST be destroyed by consumer_del_channel(). + */ +static int ask_channel(struct lttng_consumer_local_data *ctx, int sock, + struct lttng_consumer_channel *channel, + struct ustctl_consumer_channel_attr *attr) +{ + int ret; + + assert(ctx); + assert(channel); + assert(attr); + + /* + * This value is still used by the kernel consumer since for the kernel, + * the stream ownership is not IN the consumer so we need to have the + * number of left stream that needs to be initialized so we can know when + * to delete the channel (see consumer.c). + * + * As for the user space tracer now, the consumer creates and sends the + * stream to the session daemon which only sends them to the application + * once every stream of a channel is received making this value useless + * because we they will be added to the poll thread before the application + * receives them. This ensures that a stream can not hang up during + * initilization of a channel. + */ + channel->nb_init_stream_left = 0; + + /* The reply msg status is handled in the following call. */ + ret = create_ust_channel(attr, &channel->uchan); + if (ret < 0) { + goto error; + } + + channel->wait_fd = ustctl_channel_get_wait_fd(channel->uchan); + + if (ret < 0) { + goto error; + } + + /* Open all streams for this channel. */ + ret = create_ust_streams(channel, ctx); + if (ret < 0) { + goto error; + } + +error: + return ret; +} + +/* + * Send all stream of a channel to the right thread handling it. + * + * On error, return a negative value else 0 on success. + */ +static int send_streams_to_thread(struct lttng_consumer_channel *channel, + struct lttng_consumer_local_data *ctx) +{ + int ret = 0; + struct lttng_consumer_stream *stream, *stmp; + + assert(channel); + assert(ctx); + + /* Send streams to the corresponding thread. */ + cds_list_for_each_entry_safe(stream, stmp, &channel->streams.head, + send_node) { + /* Sending the stream to the thread. */ + ret = send_stream_to_thread(stream, ctx); + if (ret < 0) { + /* + * If we are unable to send the stream to the thread, there is + * a big problem so just stop everything. + */ + goto error; + } + + /* Remove node from the channel stream list. */ + cds_list_del(&stream->send_node); + } + +error: + return ret; +} + +/* + * Write metadata to the given channel using ustctl to convert the string to + * the ringbuffer. + * Called only from consumer_metadata_cache_write. + * The metadata cache lock MUST be acquired to write in the cache. + * + * Return 0 on success else a negative value. + */ +int lttng_ustconsumer_push_metadata(struct lttng_consumer_channel *metadata, + const char *metadata_str, uint64_t target_offset, uint64_t len) +{ + int ret; + + assert(metadata); + assert(metadata_str); + + DBG("UST consumer writing metadata to channel %s", metadata->name); + + assert(target_offset <= metadata->metadata_cache->max_offset); + ret = ustctl_write_metadata_to_channel(metadata->uchan, + metadata_str + target_offset, len); + if (ret < 0) { + ERR("ustctl write metadata fail with ret %d, len %ld", ret, len); + goto error; + } + + ustctl_flush_buffer(metadata->metadata_stream->ustream, 1); + +error: + return ret; +} + +/* + * Flush channel's streams using the given key to retrieve the channel. + * + * Return 0 on success else an LTTng error code. + */ +static int flush_channel(uint64_t chan_key) +{ + int ret = 0; + struct lttng_consumer_channel *channel; + struct lttng_consumer_stream *stream; + struct lttng_ht *ht; + struct lttng_ht_iter iter; + + DBG("UST consumer flush channel key %lu", chan_key); + + channel = consumer_find_channel(chan_key); + if (!channel) { + ERR("UST consumer flush channel %lu not found", chan_key); + ret = LTTNG_ERR_UST_CHAN_NOT_FOUND; + goto error; + } + + ht = consumer_data.stream_per_chan_id_ht; + + /* For each stream of the channel id, flush it. */ + rcu_read_lock(); + cds_lfht_for_each_entry_duplicate(ht->ht, + ht->hash_fct(&channel->key, lttng_ht_seed), ht->match_fct, + &channel->key, &iter.iter, stream, node_channel_id.node) { + ustctl_flush_buffer(stream->ustream, 1); + } + rcu_read_unlock(); + +error: + return ret; +} + +/* + * Close metadata stream wakeup_fd using the given key to retrieve the channel. + * + * Return 0 on success else an LTTng error code. + */ +static int close_metadata(uint64_t chan_key) +{ + int ret; + struct lttng_consumer_channel *channel; + + DBG("UST consumer close metadata key %lu", chan_key); + + channel = consumer_find_channel(chan_key); + if (!channel) { + ERR("UST consumer close metadata %lu not found", chan_key); + ret = LTTNG_ERR_UST_CHAN_NOT_FOUND; + goto error; + } + + ret = ustctl_stream_close_wakeup_fd(channel->metadata_stream->ustream); + if (ret < 0) { + ERR("UST consumer unable to close fd of metadata (ret: %d)", ret); + ret = LTTCOMM_CONSUMERD_ERROR_METADATA; + goto error; + } + if (channel->switch_timer_enabled == 1) { + DBG("Deleting timer on metadata channel"); + consumer_timer_switch_stop(channel); + } + consumer_metadata_cache_destroy(channel); + +error: + return ret; +} + +/* + * RCU read side lock MUST be acquired before calling this function. + * + * Return 0 on success else an LTTng error code. + */ +static int setup_metadata(struct lttng_consumer_local_data *ctx, uint64_t key) +{ + int ret; + struct lttng_consumer_channel *metadata; + + DBG("UST consumer setup metadata key %lu", key); + + metadata = consumer_find_channel(key); + if (!metadata) { + ERR("UST consumer push metadata %" PRIu64 " not found", key); + ret = LTTNG_ERR_UST_CHAN_NOT_FOUND; + goto error; + } + + /* + * Send metadata stream to relayd if one available. Availability is + * known if the stream is still in the list of the channel. + */ + if (cds_list_empty(&metadata->streams.head)) { + ERR("Metadata channel key %" PRIu64 ", no stream available.", key); + ret = LTTCOMM_CONSUMERD_ERROR_METADATA; + goto error; + } + + /* Send metadata stream to relayd if needed. */ + ret = send_stream_to_relayd(metadata->metadata_stream); + if (ret < 0) { + ret = LTTCOMM_CONSUMERD_ERROR_METADATA; + goto error; + } + + ret = send_streams_to_thread(metadata, ctx); + if (ret < 0) { + /* + * If we are unable to send the stream to the thread, there is + * a big problem so just stop everything. + */ + ret = LTTCOMM_CONSUMERD_FATAL; + goto error; + } + /* List MUST be empty after or else it could be reused. */ + assert(cds_list_empty(&metadata->streams.head)); + + ret = 0; + +error: + return ret; +} + +/* + * Receive the metadata updates from the sessiond. + */ +int lttng_ustconsumer_recv_metadata(int sock, uint64_t key, uint64_t offset, + uint64_t len, struct lttng_consumer_channel *channel) +{ + int ret, ret_code = LTTNG_OK; + char *metadata_str; + + DBG("UST consumer push metadata key %lu of len %lu", key, len); + + metadata_str = zmalloc(len * sizeof(char)); + if (!metadata_str) { + PERROR("zmalloc metadata string"); + ret_code = LTTCOMM_CONSUMERD_ENOMEM; + goto end; + } + + /* Receive metadata string. */ + ret = lttcomm_recv_unix_sock(sock, metadata_str, len); + if (ret < 0) { + /* Session daemon is dead so return gracefully. */ + ret_code = ret; + goto end_free; + } + + pthread_mutex_lock(&channel->metadata_cache->lock); + ret = consumer_metadata_cache_write(channel, offset, len, metadata_str); + if (ret < 0) { + /* Unable to handle metadata. Notify session daemon. */ + ret_code = LTTCOMM_CONSUMERD_ERROR_METADATA; + } + pthread_mutex_unlock(&channel->metadata_cache->lock); + + while (consumer_metadata_cache_flushed(channel, offset + len)) { + DBG("Waiting for metadata to be flushed"); + usleep(DEFAULT_METADATA_AVAILABILITY_WAIT_TIME); + } + +end_free: + free(metadata_str); +end: + return ret_code; +} + /* * Receive command from session daemon and process it. * @@ -101,219 +742,330 @@ int lttng_ustconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, int sock, struct pollfd *consumer_sockpoll) { ssize_t ret; + enum lttng_error_code ret_code = LTTNG_OK; struct lttcomm_consumer_msg msg; + struct lttng_consumer_channel *channel = NULL; ret = lttcomm_recv_unix_sock(sock, &msg, sizeof(msg)); if (ret != sizeof(msg)) { DBG("Consumer received unexpected message size %zd (expects %zu)", ret, sizeof(msg)); - lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_ERROR_RECV_FD); + lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_ERROR_RECV_CMD); + /* + * The ret value might 0 meaning an orderly shutdown but this is ok + * since the caller handles this. + */ return ret; } if (msg.cmd_type == LTTNG_CONSUMER_STOP) { + /* + * Notify the session daemon that the command is completed. + * + * On transport layer error, the function call will print an error + * message so handling the returned code is a bit useless since we + * return an error code anyway. + */ + (void) consumer_send_status_msg(sock, ret_code); return -ENOENT; } - /* relayd needs RCU read-side lock */ - rcu_read_lock(); + /* relayd needs RCU read-side lock */ + rcu_read_lock(); + + switch (msg.cmd_type) { + case LTTNG_CONSUMER_ADD_RELAYD_SOCKET: + { + /* Session daemon status message are handled in the following call. */ + ret = consumer_add_relayd_socket(msg.u.relayd_sock.net_index, + msg.u.relayd_sock.type, ctx, sock, consumer_sockpoll, + &msg.u.relayd_sock.sock, msg.u.relayd_sock.session_id); + goto end_nosignal; + } + case LTTNG_CONSUMER_DESTROY_RELAYD: + { + uint64_t index = msg.u.destroy_relayd.net_seq_idx; + struct consumer_relayd_sock_pair *relayd; + + DBG("UST consumer destroying relayd %" PRIu64, index); + + /* Get relayd reference if exists. */ + relayd = consumer_find_relayd(index); + if (relayd == NULL) { + DBG("Unable to find relayd %" PRIu64, index); + ret_code = LTTNG_ERR_NO_CONSUMER; + } + + /* + * Each relayd socket pair has a refcount of stream attached to it + * which tells if the relayd is still active or not depending on the + * refcount value. + * + * This will set the destroy flag of the relayd object and destroy it + * if the refcount reaches zero when called. + * + * The destroy can happen either here or when a stream fd hangs up. + */ + if (relayd) { + consumer_flag_relayd_for_destroy(relayd); + } + + goto end_msg_sessiond; + } + case LTTNG_CONSUMER_UPDATE_STREAM: + { + rcu_read_unlock(); + return -ENOSYS; + } + case LTTNG_CONSUMER_DATA_PENDING: + { + int ret, is_data_pending; + uint64_t id = msg.u.data_pending.session_id; + + DBG("UST consumer data pending command for id %" PRIu64, id); + + is_data_pending = consumer_data_pending(id); + + /* Send back returned value to session daemon */ + ret = lttcomm_send_unix_sock(sock, &is_data_pending, + sizeof(is_data_pending)); + if (ret < 0) { + DBG("Error when sending the data pending ret code: %d", ret); + } - switch (msg.cmd_type) { - case LTTNG_CONSUMER_ADD_RELAYD_SOCKET: - { - ret = consumer_add_relayd_socket(msg.u.relayd_sock.net_index, - msg.u.relayd_sock.type, ctx, sock, consumer_sockpoll, - &msg.u.relayd_sock.sock); - goto end_nosignal; + /* + * No need to send back a status message since the data pending + * returned value is the response. + */ + break; } - case LTTNG_CONSUMER_ADD_CHANNEL: + case LTTNG_CONSUMER_ASK_CHANNEL_CREATION: { - struct lttng_consumer_channel *new_channel; - int fds[1]; - size_t nb_fd = 1; + int ret; + struct ustctl_consumer_channel_attr attr; + + /* Create a plain object and reserve a channel key. */ + channel = allocate_channel(msg.u.ask_channel.session_id, + msg.u.ask_channel.pathname, msg.u.ask_channel.name, + msg.u.ask_channel.uid, msg.u.ask_channel.gid, + msg.u.ask_channel.relayd_id, msg.u.ask_channel.key, + (enum lttng_event_output) msg.u.ask_channel.output); + if (!channel) { + goto end_channel_error; + } - DBG("UST Consumer adding channel"); + /* Build channel attributes from received message. */ + attr.subbuf_size = msg.u.ask_channel.subbuf_size; + attr.num_subbuf = msg.u.ask_channel.num_subbuf; + attr.overwrite = msg.u.ask_channel.overwrite; + attr.switch_timer_interval = msg.u.ask_channel.switch_timer_interval; + attr.read_timer_interval = msg.u.ask_channel.read_timer_interval; + attr.chan_id = msg.u.ask_channel.chan_id; + memcpy(attr.uuid, msg.u.ask_channel.uuid, sizeof(attr.uuid)); - /* block */ - if (lttng_consumer_poll_socket(consumer_sockpoll) < 0) { - rcu_read_unlock(); - return -EINTR; + /* Translate the event output type to UST. */ + switch (channel->output) { + case LTTNG_EVENT_SPLICE: + /* Splice not supported so fallback on mmap(). */ + case LTTNG_EVENT_MMAP: + default: + attr.output = CONSUMER_CHANNEL_MMAP; + break; + }; + + /* Translate and save channel type. */ + switch (msg.u.ask_channel.type) { + case LTTNG_UST_CHAN_PER_CPU: + channel->type = CONSUMER_CHANNEL_TYPE_DATA; + attr.type = LTTNG_UST_CHAN_PER_CPU; + break; + case LTTNG_UST_CHAN_METADATA: + channel->type = CONSUMER_CHANNEL_TYPE_METADATA; + attr.type = LTTNG_UST_CHAN_METADATA; + break; + default: + assert(0); + goto error_fatal; + }; + + ret = ask_channel(ctx, sock, channel, &attr); + if (ret < 0) { + goto end_channel_error; } - ret = lttcomm_recv_fds_unix_sock(sock, fds, nb_fd); - if (ret != sizeof(fds)) { - lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_ERROR_RECV_FD); - rcu_read_unlock(); - return ret; + + /* + * Add the channel to the internal state AFTER all streams were created + * and successfully sent to session daemon. This way, all streams must + * be ready before this channel is visible to the threads. + */ + ret = add_channel(channel, ctx); + if (ret < 0) { + goto end_channel_error; } - DBG("consumer_add_channel %d", msg.u.channel.channel_key); - new_channel = consumer_allocate_channel(msg.u.channel.channel_key, - fds[0], -1, - msg.u.channel.mmap_len, - msg.u.channel.max_sb_size, - msg.u.channel.nb_init_streams); - if (new_channel == NULL) { - lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_OUTFD_ERROR); + /* + * Channel and streams are now created. Inform the session daemon that + * everything went well and should wait to receive the channel and + * streams with ustctl API. + */ + ret = consumer_send_status_channel(sock, channel); + if (ret < 0) { + /* + * There is probably a problem on the socket so the poll will get + * it and clean everything up. + */ goto end_nosignal; } - if (ctx->on_recv_channel != NULL) { - ret = ctx->on_recv_channel(new_channel); - if (ret == 0) { - consumer_add_channel(new_channel); - } else if (ret < 0) { - goto end_nosignal; + + if (msg.u.ask_channel.type == LTTNG_UST_CHAN_METADATA) { + ret = consumer_metadata_cache_allocate(channel); + if (ret < 0) { + ERR("Allocating metadata cache"); + goto end_channel_error; } - } else { - consumer_add_channel(new_channel); + consumer_timer_switch_start(channel, attr.switch_timer_interval); + attr.switch_timer_interval = 0; } - goto end_nosignal; + + break; } - case LTTNG_CONSUMER_ADD_STREAM: + case LTTNG_CONSUMER_GET_CHANNEL: { - struct lttng_consumer_stream *new_stream; - int fds[2], stream_pipe; - size_t nb_fd = 2; - struct consumer_relayd_sock_pair *relayd = NULL; - int alloc_ret = 0; + int ret, relayd_err = 0; + uint64_t key = msg.u.get_channel.key; + struct lttng_consumer_channel *channel; - DBG("UST Consumer adding stream"); + channel = consumer_find_channel(key); + if (!channel) { + ERR("UST consumer get channel key %lu not found", key); + ret_code = LTTNG_ERR_UST_CHAN_NOT_FOUND; + goto end_msg_sessiond; + } - /* block */ - if (lttng_consumer_poll_socket(consumer_sockpoll) < 0) { - rcu_read_unlock(); - return -EINTR; - } - ret = lttcomm_recv_fds_unix_sock(sock, fds, nb_fd); - if (ret != sizeof(fds)) { - lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_ERROR_RECV_FD); - rcu_read_unlock(); - return ret; - } - - DBG("Consumer command ADD_STREAM chan %d stream %d", - msg.u.stream.channel_key, msg.u.stream.stream_key); - - assert(msg.u.stream.output == LTTNG_EVENT_MMAP); - new_stream = consumer_allocate_stream(msg.u.stream.channel_key, - msg.u.stream.stream_key, - fds[0], fds[1], - msg.u.stream.state, - msg.u.stream.mmap_len, - msg.u.stream.output, - msg.u.stream.path_name, - msg.u.stream.uid, - msg.u.stream.gid, - msg.u.stream.net_index, - msg.u.stream.metadata_flag, - msg.u.stream.session_id, - &alloc_ret); - if (new_stream == NULL) { - switch (alloc_ret) { - case -ENOMEM: - case -EINVAL: - default: - lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_OUTFD_ERROR); - break; - case -ENOENT: + /* Inform sessiond that we are about to send channel and streams. */ + ret = consumer_send_status_msg(sock, LTTNG_OK); + if (ret < 0) { + /* Somehow, the session daemon is not responding anymore. */ + goto end_nosignal; + } + + /* Send everything to sessiond. */ + ret = send_sessiond_channel(sock, channel, ctx, &relayd_err); + if (ret < 0) { + if (relayd_err) { /* - * We could not find the channel. Can happen if cpu hotplug - * happens while tearing down. + * We were unable to send to the relayd the stream so avoid + * sending back a fatal error to the thread since this is OK + * and the consumer can continue its work. */ - DBG3("Could not find channel"); - break; + ret_code = LTTNG_ERR_RELAYD_CONNECT_FAIL; + goto end_msg_sessiond; } - goto end_nosignal; + /* + * The communicaton was broken hence there is a bad state between + * the consumer and sessiond so stop everything. + */ + goto error_fatal; } - /* The stream is not metadata. Get relayd reference if exists. */ - relayd = consumer_find_relayd(msg.u.stream.net_index); - if (relayd != NULL) { - pthread_mutex_lock(&relayd->ctrl_sock_mutex); - /* Add stream on the relayd */ - ret = relayd_add_stream(&relayd->control_sock, - msg.u.stream.name, msg.u.stream.path_name, - &new_stream->relayd_stream_id); - pthread_mutex_unlock(&relayd->ctrl_sock_mutex); - if (ret < 0) { - consumer_del_stream(new_stream, NULL); - goto end_nosignal; - } - } else if (msg.u.stream.net_index != -1) { - ERR("Network sequence index %d unknown. Not adding stream.", - msg.u.stream.net_index); - consumer_del_stream(new_stream, NULL); - goto end_nosignal; + ret = send_streams_to_thread(channel, ctx); + if (ret < 0) { + /* + * If we are unable to send the stream to the thread, there is + * a big problem so just stop everything. + */ + goto error_fatal; } + /* List MUST be empty after or else it could be reused. */ + assert(cds_list_empty(&channel->streams.head)); - /* Do actions once stream has been received. */ - if (ctx->on_recv_stream) { - ret = ctx->on_recv_stream(new_stream); - if (ret < 0) { - consumer_del_stream(new_stream, NULL); - goto end_nosignal; - } + goto end_msg_sessiond; + } + case LTTNG_CONSUMER_DESTROY_CHANNEL: + { + uint64_t key = msg.u.destroy_channel.key; + struct lttng_consumer_channel *channel; + + channel = consumer_find_channel(key); + if (!channel) { + ERR("UST consumer get channel key %lu not found", key); + ret_code = LTTNG_ERR_UST_CHAN_NOT_FOUND; + goto end_msg_sessiond; } - /* Get the right pipe where the stream will be sent. */ - if (new_stream->metadata_flag) { - stream_pipe = ctx->consumer_metadata_pipe[1]; - } else { - stream_pipe = ctx->consumer_data_pipe[1]; + destroy_channel(channel); + + goto end_msg_sessiond; + } + case LTTNG_CONSUMER_CLOSE_METADATA: + { + int ret; + + ret = close_metadata(msg.u.close_metadata.key); + if (ret != 0) { + ret_code = ret; } - do { - ret = write(stream_pipe, &new_stream, sizeof(new_stream)); - } while (ret < 0 && errno == EINTR); - if (ret < 0) { - PERROR("Consumer write %s stream to pipe %d", - new_stream->metadata_flag ? "metadata" : "data", - stream_pipe); - consumer_del_stream(new_stream, NULL); - goto end_nosignal; + goto end_msg_sessiond; + } + case LTTNG_CONSUMER_FLUSH_CHANNEL: + { + int ret; + + ret = flush_channel(msg.u.flush_channel.key); + if (ret != 0) { + ret_code = ret; } - DBG("UST consumer ADD_STREAM %s (%d,%d) with relayd id %" PRIu64, - msg.u.stream.path_name, fds[0], fds[1], - new_stream->relayd_stream_id); - break; + goto end_msg_sessiond; } - case LTTNG_CONSUMER_DESTROY_RELAYD: + case LTTNG_CONSUMER_PUSH_METADATA: { - uint64_t index = msg.u.destroy_relayd.net_seq_idx; - struct consumer_relayd_sock_pair *relayd; + int ret; + uint64_t len = msg.u.push_metadata.len; + uint64_t key = msg.u.push_metadata.key; + uint64_t offset = msg.u.push_metadata.target_offset; + struct lttng_consumer_channel *channel; - DBG("UST consumer destroying relayd %" PRIu64, index); + DBG("UST consumer push metadata key %lu of len %lu", key, len); - /* Get relayd reference if exists. */ - relayd = consumer_find_relayd(index); - if (relayd == NULL) { - ERR("Unable to find relayd %" PRIu64, index); - goto end_nosignal; + channel = consumer_find_channel(key); + if (!channel) { + ERR("UST consumer push metadata %lu not found", key); + ret_code = LTTNG_ERR_UST_CHAN_NOT_FOUND; } - /* - * Each relayd socket pair has a refcount of stream attached to it - * which tells if the relayd is still active or not depending on the - * refcount value. - * - * This will set the destroy flag of the relayd object and destroy it - * if the refcount reaches zero when called. - * - * The destroy can happen either here or when a stream fd hangs up. - */ - consumer_flag_relayd_for_destroy(relayd); + /* Tell session daemon we are ready to receive the metadata. */ + ret = consumer_send_status_msg(sock, LTTNG_OK); + if (ret < 0) { + /* Somehow, the session daemon is not responding anymore. */ + goto error_fatal; + } - goto end_nosignal; - } - case LTTNG_CONSUMER_UPDATE_STREAM: - { - rcu_read_unlock(); - return -ENOSYS; + /* Wait for more data. */ + if (lttng_consumer_poll_socket(consumer_sockpoll) < 0) { + goto end_nosignal; + } + + ret = lttng_ustconsumer_recv_metadata(sock, key, offset, + len, channel); + if (ret < 0) { + /* error receiving from sessiond */ + goto end_nosignal; + } else { + ret_code = ret; + goto end_msg_sessiond; + } } - case LTTNG_CONSUMER_DATA_AVAILABLE: + case LTTNG_CONSUMER_SETUP_METADATA: { - rcu_read_unlock(); - return -ENOSYS; + int ret; + + ret = setup_metadata(ctx, msg.u.setup_metadata.key); + if (ret) { + ret_code = ret; + } + goto end_msg_sessiond; } default: break; @@ -327,83 +1079,118 @@ end_nosignal: * shutdown during the recv() or send() call. */ return 1; + +end_msg_sessiond: + /* + * The returned value here is not useful since either way we'll return 1 to + * the caller because the session daemon socket management is done + * elsewhere. Returning a negative code or 0 will shutdown the consumer. + */ + (void) consumer_send_status_msg(sock, ret_code); + rcu_read_unlock(); + return 1; +end_channel_error: + if (channel) { + /* + * Free channel here since no one has a reference to it. We don't + * free after that because a stream can store this pointer. + */ + destroy_channel(channel); + } + /* We have to send a status channel message indicating an error. */ + ret = consumer_send_status_channel(sock, NULL); + if (ret < 0) { + /* Stop everything if session daemon can not be notified. */ + goto error_fatal; + } + rcu_read_unlock(); + return 1; +error_fatal: + rcu_read_unlock(); + /* This will issue a consumer stop. */ + return -1; } -int lttng_ustconsumer_allocate_channel(struct lttng_consumer_channel *chan) +/* + * Wrapper over the mmap() read offset from ust-ctl library. Since this can be + * compiled out, we isolate it in this library. + */ +int lttng_ustctl_get_mmap_read_offset(struct lttng_consumer_stream *stream, + unsigned long *off) { - struct lttng_ust_object_data obj; - - obj.handle = -1; - obj.shm_fd = chan->shm_fd; - obj.wait_fd = chan->wait_fd; - obj.memory_map_size = chan->mmap_len; - chan->handle = ustctl_map_channel(&obj); - if (!chan->handle) { - return -ENOMEM; - } - chan->wait_fd_is_copy = 1; - chan->shm_fd = -1; + assert(stream); + assert(stream->ustream); - return 0; + return ustctl_get_mmap_read_offset(stream->ustream, off); } -void lttng_ustconsumer_on_stream_hangup(struct lttng_consumer_stream *stream) +/* + * Wrapper over the mmap() read offset from ust-ctl library. Since this can be + * compiled out, we isolate it in this library. + */ +void *lttng_ustctl_get_mmap_base(struct lttng_consumer_stream *stream) { - ustctl_flush_buffer(stream->chan->handle, stream->buf, 0); - stream->hangup_flush_done = 1; + assert(stream); + assert(stream->ustream); + + return ustctl_get_mmap_base(stream->ustream); } -void lttng_ustconsumer_del_channel(struct lttng_consumer_channel *chan) +/* + * Take a snapshot for a specific fd + * + * Returns 0 on success, < 0 on error + */ +int lttng_ustconsumer_take_snapshot(struct lttng_consumer_stream *stream) { - ustctl_unmap_channel(chan->handle); + assert(stream); + assert(stream->ustream); + + return ustctl_snapshot(stream->ustream); } -int lttng_ustconsumer_add_stream(struct lttng_consumer_stream *stream) +/* + * Get the produced position + * + * Returns 0 on success, < 0 on error + */ +int lttng_ustconsumer_get_produced_snapshot( + struct lttng_consumer_stream *stream, unsigned long *pos) { - struct lttng_ust_object_data obj; - int ret; - - obj.handle = -1; - obj.shm_fd = stream->shm_fd; - obj.wait_fd = stream->wait_fd; - obj.memory_map_size = stream->mmap_len; - ret = ustctl_add_stream(stream->chan->handle, &obj); - if (ret) { - ERR("UST ctl add_stream failed with ret %d", ret); - goto error; - } + assert(stream); + assert(stream->ustream); + assert(pos); - stream->buf = ustctl_open_stream_read(stream->chan->handle, stream->cpu); - if (!stream->buf) { - ERR("UST ctl open_stream_read failed"); - ret = -EBUSY; - goto error; - } + return ustctl_snapshot_get_produced(stream->ustream, pos); +} - /* ustctl_open_stream_read has closed the shm fd. */ - stream->wait_fd_is_copy = 1; - stream->shm_fd = -1; +/* + * Called when the stream signal the consumer that it has hang up. + */ +void lttng_ustconsumer_on_stream_hangup(struct lttng_consumer_stream *stream) +{ + assert(stream); + assert(stream->ustream); - stream->mmap_base = ustctl_get_mmap_base(stream->chan->handle, stream->buf); - if (!stream->mmap_base) { - ERR("UST ctl get_mmap_base failed"); - ret = -EINVAL; - goto mmap_error; - } + ustctl_flush_buffer(stream->ustream, 0); + stream->hangup_flush_done = 1; +} - return 0; +void lttng_ustconsumer_del_channel(struct lttng_consumer_channel *chan) +{ + assert(chan); + assert(chan->uchan); -mmap_error: - ustctl_close_stream_read(stream->chan->handle, stream->buf); -error: - return ret; + ustctl_destroy_channel(chan->uchan); } void lttng_ustconsumer_del_stream(struct lttng_consumer_stream *stream) { - ustctl_close_stream_read(stream->chan->handle, stream->buf); -} + assert(stream); + assert(stream->ustream); + ustctl_destroy_stream(stream->ustream); +} int lttng_ustconsumer_read_subbuffer(struct lttng_consumer_stream *stream, struct lttng_consumer_local_data *ctx) @@ -411,16 +1198,23 @@ int lttng_ustconsumer_read_subbuffer(struct lttng_consumer_stream *stream, unsigned long len, subbuf_size, padding; int err; long ret = 0; - struct lttng_ust_shm_handle *handle; - struct lttng_ust_lib_ring_buffer *buf; char dummy; - ssize_t readlen; + struct ustctl_consumer_stream *ustream; + + assert(stream); + assert(stream->ustream); + assert(ctx); + + DBG2("In UST read_subbuffer (wait_fd: %d, name: %s)", stream->wait_fd, + stream->name); - DBG("In read_subbuffer (wait_fd: %d, stream key: %d)", - stream->wait_fd, stream->key); + /* Ease our life for what's next. */ + ustream = stream->ustream; /* We can consume the 1 byte written into the wait_fd by UST */ if (!stream->hangup_flush_done) { + ssize_t readlen; + do { readlen = read(stream->wait_fd, &dummy, 1); } while (readlen == -1 && errno == EINTR); @@ -430,10 +1224,8 @@ int lttng_ustconsumer_read_subbuffer(struct lttng_consumer_stream *stream, } } - buf = stream->buf; - handle = stream->chan->handle; /* Get the next subbuffer */ - err = ustctl_get_next_subbuf(handle, buf); + err = ustctl_get_next_subbuf(ustream); if (err != 0) { ret = err; /* ustctl_get_next_subbuf returns negative, caller expect positive. */ /* @@ -443,16 +1235,16 @@ int lttng_ustconsumer_read_subbuffer(struct lttng_consumer_stream *stream, * would issue wakeups. */ DBG("Reserving sub buffer failed (everything is normal, " - "it is due to concurrency)"); + "it is due to concurrency) [ret: %d]", err); goto end; } - assert(stream->output == LTTNG_EVENT_MMAP); + assert(stream->chan->output == CONSUMER_CHANNEL_MMAP); /* Get the full padded subbuffer size */ - err = ustctl_get_padded_subbuf_size(handle, buf, &len); + err = ustctl_get_padded_subbuf_size(ustream, &len); assert(err == 0); /* Get subbuffer data size (without padding) */ - err = ustctl_get_subbuf_size(handle, buf, &subbuf_size); + err = ustctl_get_subbuf_size(ustream, &subbuf_size); assert(err == 0); /* Make sure we don't get a subbuffer size bigger than the padded */ @@ -465,50 +1257,233 @@ int lttng_ustconsumer_read_subbuffer(struct lttng_consumer_stream *stream, * 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 != -1) || - (ret != len && stream->net_seq_idx == -1)) { + if ((ret != subbuf_size && stream->net_seq_idx != (uint64_t) -1ULL) || + (ret != len && stream->net_seq_idx == (uint64_t) -1ULL)) { /* * Display the error but continue processing to try to release the - * subbuffer + * subbuffer. This is a DBG statement since any unexpected kill or + * signal, the application gets unregistered, relayd gets closed or + * anything that affects the buffer lifetime will trigger this error. + * So, for the sake of the user, don't print this error since it can + * happen and it is OK with the code flow. */ - ERR("Error writing to tracefile " + DBG("Error writing to tracefile " "(ret: %zd != len: %lu != subbuf_size: %lu)", ret, len, subbuf_size); } - err = ustctl_put_next_subbuf(handle, buf); + err = ustctl_put_next_subbuf(ustream); assert(err == 0); + end: return ret; } +/* + * Called when a stream is created. + */ int lttng_ustconsumer_on_recv_stream(struct lttng_consumer_stream *stream) { int ret; + char full_path[PATH_MAX]; /* Opening the tracefile in write mode */ - if (stream->path_name != NULL && stream->net_seq_idx == -1) { - ret = run_as_open(stream->path_name, - O_WRONLY|O_CREAT|O_TRUNC, - S_IRWXU|S_IRWXG|S_IRWXO, - stream->uid, stream->gid); - if (ret < 0) { - ERR("Opening %s", stream->path_name); - PERROR("open"); - goto error; - } - stream->out_fd = ret; + if (stream->net_seq_idx != (uint64_t) -1ULL) { + goto end; } - ret = lttng_ustconsumer_add_stream(stream); - if (ret) { - consumer_del_stream(stream, NULL); - ret = -1; + ret = snprintf(full_path, sizeof(full_path), "%s/%s", + stream->chan->pathname, stream->name); + if (ret < 0) { + PERROR("snprintf on_recv_stream"); + goto error; + } + + ret = run_as_open(full_path, O_WRONLY | O_CREAT | O_TRUNC, + S_IRWXU | S_IRWXG | S_IRWXO, stream->uid, stream->gid); + if (ret < 0) { + PERROR("open stream path %s", full_path); goto error; } + stream->out_fd = ret; +end: /* we return 0 to let the library handle the FD internally */ return 0; error: return ret; } + +/* + * Check if data is still being extracted from the buffers for a specific + * stream. Consumer data lock MUST be acquired before calling this function + * and the stream lock. + * + * Return 1 if the traced data are still getting read else 0 meaning that the + * data is available for trace viewer reading. + */ +int lttng_ustconsumer_data_pending(struct lttng_consumer_stream *stream) +{ + int ret; + + assert(stream); + assert(stream->ustream); + + DBG("UST consumer checking data pending"); + + ret = ustctl_get_next_subbuf(stream->ustream); + if (ret == 0) { + /* There is still data so let's put back this subbuffer. */ + ret = ustctl_put_subbuf(stream->ustream); + assert(ret == 0); + ret = 1; /* Data is pending */ + goto end; + } + + /* Data is NOT pending so ready to be read. */ + ret = 0; + +end: + return ret; +} + +/* + * Close every metadata stream wait fd of the metadata hash table. This + * function MUST be used very carefully so not to run into a race between the + * metadata thread handling streams and this function closing their wait fd. + * + * For UST, this is used when the session daemon hangs up. Its the metadata + * producer so calling this is safe because we are assured that no state change + * can occur in the metadata thread for the streams in the hash table. + */ +void lttng_ustconsumer_close_metadata(struct lttng_ht *metadata_ht) +{ + int ret; + struct lttng_ht_iter iter; + struct lttng_consumer_stream *stream; + + assert(metadata_ht); + assert(metadata_ht->ht); + + DBG("UST consumer closing all metadata streams"); + + rcu_read_lock(); + cds_lfht_for_each_entry(metadata_ht->ht, &iter.iter, stream, + node.node) { + int fd = stream->wait_fd; + + /* + * Whatever happens here we have to continue to try to close every + * streams. Let's report at least the error on failure. + */ + ret = ustctl_stream_close_wakeup_fd(stream->ustream); + if (ret) { + ERR("Unable to close metadata stream fd %d ret %d", fd, ret); + } + DBG("Metadata wait fd %d closed", fd); + } + rcu_read_unlock(); +} + +void lttng_ustconsumer_close_stream_wakeup(struct lttng_consumer_stream *stream) +{ + int ret; + + ret = ustctl_stream_close_wakeup_fd(stream->ustream); + if (ret < 0) { + ERR("Unable to close wakeup fd"); + } +} + +int lttng_ustconsumer_request_metadata(struct lttng_consumer_local_data *ctx, + struct lttng_consumer_channel *channel) +{ + struct lttcomm_metadata_request_msg request; + struct lttcomm_consumer_msg msg; + enum lttng_error_code ret_code = LTTNG_OK; + uint64_t len, key, offset; + int ret; + + assert(channel); + assert(channel->metadata_cache); + + /* send the metadata request to sessiond */ + switch (consumer_data.type) { + case LTTNG_CONSUMER64_UST: + request.bits_per_long = 64; + break; + case LTTNG_CONSUMER32_UST: + request.bits_per_long = 32; + break; + default: + request.bits_per_long = 0; + break; + } + + request.session_id = channel->session_id; + request.uid = channel->uid; + request.key = channel->key; + DBG("Sending metadata request to sessiond, session %" PRIu64, + channel->session_id); + + ret = lttcomm_send_unix_sock(ctx->consumer_metadata_socket, &request, + sizeof(request)); + if (ret < 0) { + ERR("Asking metadata to sessiond"); + goto end; + } + + /* Receive the metadata from sessiond */ + ret = lttcomm_recv_unix_sock(ctx->consumer_metadata_socket, &msg, + sizeof(msg)); + if (ret != sizeof(msg)) { + DBG("Consumer received unexpected message size %d (expects %lu)", + ret, sizeof(msg)); + lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_ERROR_RECV_CMD); + /* + * The ret value might 0 meaning an orderly shutdown but this is ok + * since the caller handles this. + */ + goto end; + } + + if (msg.cmd_type == LTTNG_ERR_UND) { + /* No registry found */ + (void) consumer_send_status_msg(ctx->consumer_metadata_socket, + ret_code); + ret = 0; + goto end; + } else if (msg.cmd_type != LTTNG_CONSUMER_PUSH_METADATA) { + ERR("Unexpected cmd_type received %d", msg.cmd_type); + ret = -1; + goto end; + } + + len = msg.u.push_metadata.len; + key = msg.u.push_metadata.key; + offset = msg.u.push_metadata.target_offset; + + assert(key == channel->key); + if (len == 0) { + DBG("No new metadata to receive for key %" PRIu64, key); + } + + /* Tell session daemon we are ready to receive the metadata. */ + ret = consumer_send_status_msg(ctx->consumer_metadata_socket, + LTTNG_OK); + if (ret < 0 || len == 0) { + /* + * Somehow, the session daemon is not responding anymore or there is + * nothing to receive. + */ + goto end; + } + + ret_code = lttng_ustconsumer_recv_metadata(ctx->consumer_metadata_socket, + key, offset, len, channel); + (void) consumer_send_status_msg(ctx->consumer_metadata_socket, ret_code); + ret = 0; + +end: + return ret; +}