X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fconsumer.c;h=152064078d34b354263a79992e93d965a5b738a4;hp=221c348df055722918793e32617b6812dcfbc680;hb=0c759fc95033a3d6d7cb939f39dd643ce7e127ee;hpb=56591bac20c0f3b728c95d92702d243de838bdc4 diff --git a/src/common/consumer.c b/src/common/consumer.c index 221c348df..152064078 100644 --- a/src/common/consumer.c +++ b/src/common/consumer.c @@ -30,15 +30,18 @@ #include #include +#include #include #include #include +#include #include #include #include #include #include #include +#include #include "consumer.h" #include "consumer-stream.h" @@ -91,22 +94,33 @@ static void notify_thread_lttng_pipe(struct lttng_pipe *pipe) (void) lttng_pipe_write(pipe, &null_stream, sizeof(null_stream)); } +static void notify_health_quit_pipe(int *pipe) +{ + ssize_t ret; + + ret = lttng_write(pipe[1], "4", 1); + if (ret < 1) { + PERROR("write consumer health quit"); + } +} + static void notify_channel_pipe(struct lttng_consumer_local_data *ctx, struct lttng_consumer_channel *chan, uint64_t key, enum consumer_channel_action action) { struct consumer_channel_msg msg; - int ret; + ssize_t ret; memset(&msg, 0, sizeof(msg)); msg.action = action; msg.chan = chan; msg.key = key; - do { - ret = write(ctx->consumer_channel_pipe[1], &msg, sizeof(msg)); - } while (ret < 0 && errno == EINTR); + ret = lttng_write(ctx->consumer_channel_pipe[1], &msg, sizeof(msg)); + if (ret < sizeof(msg)) { + PERROR("notify_channel_pipe write error"); + } } void notify_thread_del_channel(struct lttng_consumer_local_data *ctx, @@ -121,17 +135,18 @@ static int read_channel_pipe(struct lttng_consumer_local_data *ctx, enum consumer_channel_action *action) { struct consumer_channel_msg msg; - int ret; + ssize_t ret; - do { - ret = read(ctx->consumer_channel_pipe[0], &msg, sizeof(msg)); - } while (ret < 0 && errno == EINTR); - if (ret > 0) { - *action = msg.action; - *chan = msg.chan; - *key = msg.key; + ret = lttng_read(ctx->consumer_channel_pipe[0], &msg, sizeof(msg)); + if (ret < sizeof(msg)) { + ret = -1; + goto error; } - return ret; + *action = msg.action; + *chan = msg.chan; + *key = msg.key; +error: + return (int) ret; } /* @@ -304,6 +319,10 @@ void consumer_del_channel(struct lttng_consumer_channel *channel) consumer_stream_destroy(stream, NULL); } + if (channel->live_timer_enabled == 1) { + consumer_timer_live_stop(channel); + } + switch (consumer_data.type) { case LTTNG_CONSUMER_KERNEL: break; @@ -498,6 +517,7 @@ struct lttng_consumer_stream *consumer_allocate_stream(uint64_t channel_key, stream->key = stream_key; stream->out_fd = -1; stream->out_fd_offset = 0; + stream->output_written = 0; stream->state = state; stream->uid = uid; stream->gid = gid; @@ -505,6 +525,7 @@ struct lttng_consumer_stream *consumer_allocate_stream(uint64_t channel_key, stream->session_id = session_id; stream->monitor = monitor; stream->endpoint_status = CONSUMER_ENDPOINT_ACTIVE; + stream->index_fd = -1; pthread_mutex_init(&stream->lock, NULL); /* If channel is the metadata, flag this stream as metadata. */ @@ -512,6 +533,9 @@ struct lttng_consumer_stream *consumer_allocate_stream(uint64_t channel_key, stream->metadata_flag = 1; /* Metadata is flat out. */ strncpy(stream->name, DEFAULT_METADATA_NAME, sizeof(stream->name)); + /* Live rendez-vous point. */ + pthread_cond_init(&stream->metadata_rdv, NULL); + pthread_mutex_init(&stream->metadata_rdv_lock, NULL); } else { /* Format stream name to _ */ ret = snprintf(stream->name, sizeof(stream->name), "%s_%d", @@ -726,6 +750,7 @@ int consumer_send_relayd_stream(struct lttng_consumer_stream *stream, if (ret < 0) { goto end; } + uatomic_inc(&relayd->refcount); stream->sent_to_relayd = 1; } else { @@ -836,7 +861,8 @@ struct lttng_consumer_channel *consumer_allocate_channel(uint64_t key, uint64_t tracefile_size, uint64_t tracefile_count, uint64_t session_id_per_pid, - unsigned int monitor) + unsigned int monitor, + unsigned int live_timer_interval) { struct lttng_consumer_channel *channel; @@ -853,13 +879,27 @@ struct lttng_consumer_channel *consumer_allocate_channel(uint64_t key, channel->uid = uid; channel->gid = gid; channel->relayd_id = relayd_id; - channel->output = output; channel->tracefile_size = tracefile_size; channel->tracefile_count = tracefile_count; channel->monitor = monitor; + channel->live_timer_interval = live_timer_interval; pthread_mutex_init(&channel->lock, NULL); pthread_mutex_init(&channel->timer_lock, NULL); + switch (output) { + case LTTNG_EVENT_SPLICE: + channel->output = CONSUMER_CHANNEL_SPLICE; + break; + case LTTNG_EVENT_MMAP: + channel->output = CONSUMER_CHANNEL_MMAP; + break; + default: + assert(0); + free(channel); + channel = NULL; + goto end; + } + /* * In monitor mode, the streams associated with the channel will be put in * a special list ONLY owned by this channel. So, the refcount is set to 1 @@ -1090,12 +1130,11 @@ void lttng_consumer_cleanup(void) */ void lttng_consumer_should_exit(struct lttng_consumer_local_data *ctx) { - int ret; + ssize_t ret; + consumer_quit = 1; - do { - ret = write(ctx->consumer_should_quit[1], "4", 1); - } while (ret < 0 && errno == EINTR); - if (ret < 0 || ret != 1) { + ret = lttng_write(ctx->consumer_should_quit[1], "4", 1); + if (ret < 1) { PERROR("write consumer quit"); } @@ -1269,15 +1308,13 @@ static int write_relayd_metadata_id(int fd, struct lttng_consumer_stream *stream, struct consumer_relayd_sock_pair *relayd, unsigned long padding) { - int ret; + ssize_t ret; struct lttcomm_relayd_metadata_payload hdr; hdr.stream_id = htobe64(stream->relayd_stream_id); hdr.padding_size = htobe32(padding); - do { - ret = write(fd, (void *) &hdr, sizeof(hdr)); - } while (ret < 0 && errno == EINTR); - if (ret < 0 || ret != sizeof(hdr)) { + ret = lttng_write(fd, (void *) &hdr, sizeof(hdr)); + if (ret < sizeof(hdr)) { /* * This error means that the fd's end is closed so ignore the perror * not to clubber the error output since this can happen in a normal @@ -1299,7 +1336,7 @@ static int write_relayd_metadata_id(int fd, stream->relayd_stream_id, padding); end: - return ret; + return (int) ret; } /* @@ -1316,7 +1353,8 @@ end: ssize_t lttng_consumer_on_read_subbuffer_mmap( struct lttng_consumer_local_data *ctx, struct lttng_consumer_stream *stream, unsigned long len, - unsigned long padding) + unsigned long padding, + struct lttng_packet_index *index) { unsigned long mmap_offset; void *mmap_base; @@ -1423,24 +1461,40 @@ ssize_t lttng_consumer_on_read_subbuffer_mmap( ret = utils_rotate_stream_file(stream->chan->pathname, stream->name, stream->chan->tracefile_size, stream->chan->tracefile_count, stream->uid, stream->gid, - stream->out_fd, &(stream->tracefile_count_current)); + stream->out_fd, &(stream->tracefile_count_current), + &stream->out_fd); if (ret < 0) { ERR("Rotating output file"); goto end; } - outfd = stream->out_fd = ret; + outfd = stream->out_fd; + + if (stream->index_fd >= 0) { + ret = index_create_file(stream->chan->pathname, + stream->name, stream->uid, stream->gid, + stream->chan->tracefile_size, + stream->tracefile_count_current); + if (ret < 0) { + goto end; + } + stream->index_fd = ret; + } + /* Reset current size because we just perform a rotation. */ stream->tracefile_size_current = 0; + stream->out_fd_offset = 0; + orig_offset = 0; } stream->tracefile_size_current += len; + if (index) { + index->offset = htobe64(stream->out_fd_offset); + } } while (len > 0) { - do { - ret = write(outfd, mmap_base + mmap_offset, len); - } while (ret < 0 && errno == EINTR); + ret = lttng_write(outfd, mmap_base + mmap_offset, len); DBG("Consumer mmap write() ret %zd (len %lu)", ret, len); - if (ret < 0) { + if (ret < len) { /* * This is possible if the fd is closed on the other side (outfd) * or any write problem. It can be verbose a bit for a normal @@ -1473,6 +1527,7 @@ ssize_t lttng_consumer_on_read_subbuffer_mmap( SYNC_FILE_RANGE_WRITE); stream->out_fd_offset += ret; } + stream->output_written += ret; written += ret; } lttng_consumer_sync_trace_file(stream, orig_offset); @@ -1506,7 +1561,8 @@ end: ssize_t lttng_consumer_on_read_subbuffer_splice( struct lttng_consumer_local_data *ctx, struct lttng_consumer_stream *stream, unsigned long len, - unsigned long padding) + unsigned long padding, + struct lttng_packet_index *index) { ssize_t ret = 0, written = 0, ret_splice = 0; loff_t offset = 0; @@ -1606,16 +1662,32 @@ ssize_t lttng_consumer_on_read_subbuffer_splice( ret = utils_rotate_stream_file(stream->chan->pathname, stream->name, stream->chan->tracefile_size, stream->chan->tracefile_count, stream->uid, stream->gid, - stream->out_fd, &(stream->tracefile_count_current)); + stream->out_fd, &(stream->tracefile_count_current), + &stream->out_fd); if (ret < 0) { ERR("Rotating output file"); goto end; } - outfd = stream->out_fd = ret; + outfd = stream->out_fd; + + if (stream->index_fd >= 0) { + ret = index_create_file(stream->chan->pathname, + stream->name, stream->uid, stream->gid, + stream->chan->tracefile_size, + stream->tracefile_count_current); + if (ret < 0) { + goto end; + } + stream->index_fd = ret; + } + /* Reset current size because we just perform a rotation. */ stream->tracefile_size_current = 0; + stream->out_fd_offset = 0; + orig_offset = 0; } stream->tracefile_size_current += len; + index->offset = htobe64(stream->out_fd_offset); } while (len > 0) { @@ -1684,6 +1756,7 @@ ssize_t lttng_consumer_on_read_subbuffer_splice( SYNC_FILE_RANGE_WRITE); stream->out_fd_offset += ret_splice; } + stream->output_written += ret_splice; written += ret_splice; } lttng_consumer_sync_trace_file(stream, orig_offset); @@ -2130,7 +2203,7 @@ static void validate_endpoint_status_metadata_stream( */ void *consumer_thread_metadata_poll(void *data) { - int ret, i, pollfd; + int ret, i, pollfd, err = -1; uint32_t revents, nb_fd; struct lttng_consumer_stream *stream = NULL; struct lttng_ht_iter iter; @@ -2141,6 +2214,10 @@ void *consumer_thread_metadata_poll(void *data) rcu_register_thread(); + health_register(health_consumerd, HEALTH_CONSUMERD_TYPE_METADATA); + + health_code_update(); + metadata_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); if (!metadata_ht) { /* ENOMEM at this point. Better to bail out. */ @@ -2166,14 +2243,19 @@ void *consumer_thread_metadata_poll(void *data) DBG("Metadata main loop started"); while (1) { + health_code_update(); + /* Only the metadata pipe is set */ if (LTTNG_POLL_GETNB(&events) == 0 && consumer_quit == 1) { + err = 0; /* All is OK */ goto end; } restart: DBG("Metadata poll wait with %d fd(s)", LTTNG_POLL_GETNB(&events)); + health_poll_entry(); ret = lttng_poll_wait(&events, -1); + health_poll_exit(); DBG("Metadata event catched in thread"); if (ret < 0) { if (errno == EINTR) { @@ -2187,14 +2269,11 @@ restart: /* From here, the event is a metadata wait fd */ for (i = 0; i < nb_fd; i++) { + health_code_update(); + revents = LTTNG_POLL_GETEV(&events, i); pollfd = LTTNG_POLL_GETFD(&events, i); - /* Just don't waste time if no returned events for the fd */ - if (!revents) { - continue; - } - if (pollfd == lttng_pipe_get_readfd(ctx->consumer_metadata_pipe)) { if (revents & (LPOLLERR | LPOLLHUP )) { DBG("Metadata thread pipe hung up"); @@ -2211,8 +2290,8 @@ restart: pipe_len = lttng_pipe_read(ctx->consumer_metadata_pipe, &stream, sizeof(stream)); - if (pipe_len < 0) { - ERR("read metadata stream, ret: %zd", pipe_len); + if (pipe_len < sizeof(stream)) { + PERROR("read metadata stream"); /* * Continue here to handle the rest of the streams. */ @@ -2261,6 +2340,8 @@ restart: /* We just flushed the stream now read it. */ do { + health_code_update(); + len = ctx->on_buffer_ready(stream, ctx); /* * We don't check the return value here since if we get @@ -2283,6 +2364,8 @@ restart: assert(stream->wait_fd == pollfd); do { + health_code_update(); + len = ctx->on_buffer_ready(stream, ctx); /* * We don't check the return value here since if we get @@ -2305,6 +2388,8 @@ restart: } } + /* All is OK */ + err = 0; error: end: DBG("Metadata poll thread exiting"); @@ -2313,6 +2398,11 @@ end: end_poll: destroy_stream_ht(metadata_ht); end_ht: + if (err) { + health_error(); + ERR("Health error occurred in %s", __func__); + } + health_unregister(health_consumerd); rcu_unregister_thread(); return NULL; } @@ -2323,7 +2413,7 @@ end_ht: */ void *consumer_thread_data_poll(void *data) { - int num_rdy, num_hup, high_prio, ret, i; + int num_rdy, num_hup, high_prio, ret, i, err = -1; struct pollfd *pollfd = NULL; /* local view of the streams */ struct lttng_consumer_stream **local_stream = NULL, *new_stream = NULL; @@ -2334,6 +2424,10 @@ void *consumer_thread_data_poll(void *data) rcu_register_thread(); + health_register(health_consumerd, HEALTH_CONSUMERD_TYPE_DATA); + + health_code_update(); + data_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); if (data_ht == NULL) { /* ENOMEM at this point. Better to bail out. */ @@ -2347,6 +2441,8 @@ void *consumer_thread_data_poll(void *data) } while (1) { + health_code_update(); + high_prio = 0; num_hup = 0; @@ -2393,12 +2489,15 @@ void *consumer_thread_data_poll(void *data) /* No FDs and consumer_quit, consumer_cleanup the thread */ if (nb_fd == 0 && consumer_quit == 1) { + err = 0; /* All is OK */ goto end; } /* poll on the array of fds */ restart: DBG("polling on %d fd", nb_fd + 1); + health_poll_entry(); num_rdy = poll(pollfd, nb_fd + 1, -1); + health_poll_exit(); DBG("poll num_rdy : %d", num_rdy); if (num_rdy == -1) { /* @@ -2426,8 +2525,8 @@ void *consumer_thread_data_poll(void *data) DBG("consumer_data_pipe wake up"); pipe_readlen = lttng_pipe_read(ctx->consumer_data_pipe, &new_stream, sizeof(new_stream)); - if (pipe_readlen < 0) { - ERR("Consumer data pipe ret %zd", pipe_readlen); + if (pipe_readlen < sizeof(new_stream)) { + PERROR("Consumer data pipe"); /* Continue so we can at least handle the current stream(s). */ continue; } @@ -2448,6 +2547,8 @@ void *consumer_thread_data_poll(void *data) /* Take care of high priority channels first. */ for (i = 0; i < nb_fd; i++) { + health_code_update(); + if (local_stream[i] == NULL) { continue; } @@ -2476,6 +2577,8 @@ void *consumer_thread_data_poll(void *data) /* Take care of low priority channels. */ for (i = 0; i < nb_fd; i++) { + health_code_update(); + if (local_stream[i] == NULL) { continue; } @@ -2496,6 +2599,8 @@ void *consumer_thread_data_poll(void *data) /* Handle hangup and errors */ for (i = 0; i < nb_fd; i++) { + health_code_update(); + if (local_stream[i] == NULL) { continue; } @@ -2541,6 +2646,8 @@ void *consumer_thread_data_poll(void *data) } } } + /* All is OK */ + err = 0; end: DBG("polling thread exiting"); free(pollfd); @@ -2558,6 +2665,12 @@ end: destroy_data_stream_ht(data_ht); + if (err) { + health_error(); + ERR("Health error occurred in %s", __func__); + } + health_unregister(health_consumerd); + rcu_unregister_thread(); return NULL; } @@ -2639,7 +2752,7 @@ static void destroy_channel_ht(struct lttng_ht *ht) */ void *consumer_thread_channel_poll(void *data) { - int ret, i, pollfd; + int ret, i, pollfd, err = -1; uint32_t revents, nb_fd; struct lttng_consumer_channel *chan = NULL; struct lttng_ht_iter iter; @@ -2650,6 +2763,10 @@ void *consumer_thread_channel_poll(void *data) rcu_register_thread(); + health_register(health_consumerd, HEALTH_CONSUMERD_TYPE_CHANNEL); + + health_code_update(); + channel_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); if (!channel_ht) { /* ENOMEM at this point. Better to bail out. */ @@ -2674,14 +2791,19 @@ void *consumer_thread_channel_poll(void *data) DBG("Channel main loop started"); while (1) { + health_code_update(); + /* Only the channel pipe is set */ if (LTTNG_POLL_GETNB(&events) == 0 && consumer_quit == 1) { + err = 0; /* All is OK */ goto end; } restart: DBG("Channel poll wait with %d fd(s)", LTTNG_POLL_GETNB(&events)); + health_poll_entry(); ret = lttng_poll_wait(&events, -1); + health_poll_exit(); DBG("Channel event catched in thread"); if (ret < 0) { if (errno == EINTR) { @@ -2695,6 +2817,8 @@ restart: /* From here, the event is a channel wait fd */ for (i = 0; i < nb_fd; i++) { + health_code_update(); + revents = LTTNG_POLL_GETEV(&events, i); pollfd = LTTNG_POLL_GETFD(&events, i); @@ -2761,6 +2885,8 @@ restart: /* Delete streams that might have been left in the stream list. */ cds_list_for_each_entry_safe(stream, stmp, &chan->streams.head, send_node) { + health_code_update(); + cds_list_del(&stream->send_node); lttng_ustconsumer_del_stream(stream); uatomic_sub(&stream->chan->refcount, 1); @@ -2833,12 +2959,19 @@ restart: } } + /* All is OK */ + err = 0; end: lttng_poll_clean(&events); end_poll: destroy_channel_ht(channel_ht); end_ht: DBG("Channel poll thread exiting"); + if (err) { + health_error(); + ERR("Health error occurred in %s", __func__); + } + health_unregister(health_consumerd); rcu_unregister_thread(); return NULL; } @@ -2876,7 +3009,7 @@ error: */ void *consumer_thread_sessiond_poll(void *data) { - int sock = -1, client_socket, ret; + int sock = -1, client_socket, ret, err = -1; /* * structure to poll for incoming data on communication socket avoids * making blocking sockets. @@ -2886,6 +3019,10 @@ void *consumer_thread_sessiond_poll(void *data) rcu_register_thread(); + health_register(health_consumerd, HEALTH_CONSUMERD_TYPE_SESSIOND); + + health_code_update(); + DBG("Creating command socket %s", ctx->consumer_command_sock_path); unlink(ctx->consumer_command_sock_path); client_socket = lttcomm_create_unix_sock(ctx->consumer_command_sock_path); @@ -2946,7 +3083,12 @@ void *consumer_thread_sessiond_poll(void *data) consumer_sockpoll[1].events = POLLIN | POLLPRI; while (1) { - if (lttng_consumer_poll_socket(consumer_sockpoll) < 0) { + health_code_update(); + + health_poll_entry(); + ret = lttng_consumer_poll_socket(consumer_sockpoll); + health_poll_exit(); + if (ret < 0) { goto end; } DBG("Incoming command on sock"); @@ -2961,14 +3103,19 @@ void *consumer_thread_sessiond_poll(void *data) * ERR() here. */ DBG("Communication interrupted on command socket"); + err = 0; goto end; } if (consumer_quit) { DBG("consumer_thread_receive_fds received quit from signal"); + err = 0; /* All is OK */ goto end; } DBG("received command on sock"); } + /* All is OK */ + err = 0; + end: DBG("Consumer thread sessiond poll exiting"); @@ -2994,6 +3141,8 @@ end: notify_channel_pipe(ctx, NULL, -1, CONSUMER_CHANNEL_QUIT); + notify_health_quit_pipe(health_quit_pipe); + /* Cleaning up possibly open sockets. */ if (sock >= 0) { ret = close(sock); @@ -3008,6 +3157,12 @@ end: } } + if (err) { + health_error(); + ERR("Health error occurred in %s", __func__); + } + health_unregister(health_consumerd); + rcu_unregister_thread(); return NULL; } @@ -3018,6 +3173,9 @@ ssize_t lttng_consumer_read_subbuffer(struct lttng_consumer_stream *stream, ssize_t ret; pthread_mutex_lock(&stream->lock); + if (stream->metadata_flag) { + pthread_mutex_lock(&stream->metadata_rdv_lock); + } switch (consumer_data.type) { case LTTNG_CONSUMER_KERNEL: @@ -3034,6 +3192,10 @@ ssize_t lttng_consumer_read_subbuffer(struct lttng_consumer_stream *stream, break; } + if (stream->metadata_flag) { + pthread_cond_broadcast(&stream->metadata_rdv); + pthread_mutex_unlock(&stream->metadata_rdv_lock); + } pthread_mutex_unlock(&stream->lock); return ret; } @@ -3073,10 +3235,11 @@ void lttng_consumer_init(void) int consumer_add_relayd_socket(uint64_t net_seq_idx, int sock_type, struct lttng_consumer_local_data *ctx, int sock, struct pollfd *consumer_sockpoll, - struct lttcomm_relayd_sock *relayd_sock, uint64_t sessiond_id) + struct lttcomm_relayd_sock *relayd_sock, uint64_t sessiond_id, + uint64_t relayd_session_id) { int fd = -1, ret = -1, relayd_created = 0; - enum lttng_error_code ret_code = LTTNG_OK; + enum lttcomm_return_code ret_code = LTTCOMM_CONSUMERD_SUCCESS; struct consumer_relayd_sock_pair *relayd = NULL; assert(ctx); @@ -3112,7 +3275,7 @@ int consumer_add_relayd_socket(uint64_t net_seq_idx, int sock_type, } /* First send a status message before receiving the fds. */ - ret = consumer_send_status_msg(sock, LTTNG_OK); + ret = consumer_send_status_msg(sock, LTTCOMM_CONSUMERD_SUCCESS); if (ret < 0) { /* Somehow, the session daemon is not responding anymore. */ lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_FATAL); @@ -3173,29 +3336,7 @@ int consumer_add_relayd_socket(uint64_t net_seq_idx, int sock_type, relayd->control_sock.major = relayd_sock->major; relayd->control_sock.minor = relayd_sock->minor; - /* - * Create a session on the relayd and store the returned id. Lock the - * control socket mutex if the relayd was NOT created before. - */ - if (!relayd_created) { - pthread_mutex_lock(&relayd->ctrl_sock_mutex); - } - ret = relayd_create_session(&relayd->control_sock, - &relayd->relayd_session_id); - if (!relayd_created) { - pthread_mutex_unlock(&relayd->ctrl_sock_mutex); - } - if (ret < 0) { - /* - * Close all sockets of a relayd object. It will be freed if it was - * created at the error code path or else it will be garbage - * collect. - */ - (void) relayd_close(&relayd->control_sock); - (void) relayd_close(&relayd->data_sock); - ret_code = LTTCOMM_CONSUMERD_RELAYD_FAIL; - goto error; - } + relayd->relayd_session_id = relayd_session_id; break; case LTTNG_STREAM_DATA: @@ -3396,6 +3537,15 @@ int consumer_data_pending(uint64_t id) */ ret = cds_lfht_is_node_deleted(&stream->node.node); if (!ret) { + /* + * An empty output file is not valid. We need at least one packet + * generated per stream, even if it contains no event, so it + * contains at least one packet header. + */ + if (stream->output_written == 0) { + pthread_mutex_unlock(&stream->lock); + goto data_pending; + } /* Check the stream if there is data in the buffers. */ ret = data_pending(stream); if (ret == 1) { @@ -3486,9 +3636,9 @@ int consumer_send_status_channel(int sock, assert(sock >= 0); if (!channel) { - msg.ret_code = -LTTNG_ERR_UST_CHAN_FAIL; + msg.ret_code = LTTCOMM_CONSUMERD_CHANNEL_FAIL; } else { - msg.ret_code = LTTNG_OK; + msg.ret_code = LTTCOMM_CONSUMERD_SUCCESS; msg.key = channel->key; msg.stream_count = channel->streams.count; }