X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fcommon%2Fconsumer.c;h=b942778b32e9a768f7da0029507b52af10478804;hb=d02b8372bf598bcd71a42823e3beabdeba1b0281;hp=6abd8b1e86de34c71d330ac68726846dd971da3b;hpb=1fc79fb475198741b09a13b5397f018dff4b1aec;p=lttng-tools.git diff --git a/src/common/consumer.c b/src/common/consumer.c index 6abd8b1e8..b942778b3 100644 --- a/src/common/consumer.c +++ b/src/common/consumer.c @@ -30,6 +30,7 @@ #include #include +#include #include #include #include @@ -44,7 +45,7 @@ #include "consumer.h" #include "consumer-stream.h" -#include "../bin/lttng-consumerd/health-consumerd.h" +#include "consumer-testpoint.h" struct lttng_consumer_global_data consumer_data = { .stream_count = 0, @@ -94,22 +95,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, @@ -124,17 +136,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; } /* @@ -756,6 +769,44 @@ end: return ret; } +/* + * Find a relayd and send the streams sent message + * + * Returns 0 on success, < 0 on error + */ +int consumer_send_relayd_streams_sent(uint64_t net_seq_idx) +{ + int ret = 0; + struct consumer_relayd_sock_pair *relayd; + + assert(net_seq_idx != -1ULL); + + /* The stream is not metadata. Get relayd reference if exists. */ + rcu_read_lock(); + relayd = consumer_find_relayd(net_seq_idx); + if (relayd != NULL) { + /* Add stream on the relayd */ + pthread_mutex_lock(&relayd->ctrl_sock_mutex); + ret = relayd_streams_sent(&relayd->control_sock); + pthread_mutex_unlock(&relayd->ctrl_sock_mutex); + if (ret < 0) { + goto end; + } + } else { + ERR("Relayd ID %" PRIu64 " unknown. Can't send streams_sent.", + net_seq_idx); + ret = -1; + goto end; + } + + ret = 0; + DBG("All streams sent relayd id %" PRIu64, net_seq_idx); + +end: + rcu_read_unlock(); + return ret; +} + /* * Find a relayd and close the stream */ @@ -867,7 +918,6 @@ 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; @@ -875,6 +925,20 @@ struct lttng_consumer_channel *consumer_allocate_channel(uint64_t key, 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 @@ -1105,12 +1169,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"); } @@ -1249,6 +1312,57 @@ error: return NULL; } +/* + * Iterate over all streams of the hashtable and free them properly. + */ +static void destroy_data_stream_ht(struct lttng_ht *ht) +{ + struct lttng_ht_iter iter; + struct lttng_consumer_stream *stream; + + if (ht == NULL) { + return; + } + + rcu_read_lock(); + cds_lfht_for_each_entry(ht->ht, &iter.iter, stream, node.node) { + /* + * Ignore return value since we are currently cleaning up so any error + * can't be handled. + */ + (void) consumer_del_stream(stream, ht); + } + rcu_read_unlock(); + + lttng_ht_destroy(ht); +} + +/* + * Iterate over all streams of the metadata hashtable and free them + * properly. + */ +static void destroy_metadata_stream_ht(struct lttng_ht *ht) +{ + struct lttng_ht_iter iter; + struct lttng_consumer_stream *stream; + + if (ht == NULL) { + return; + } + + rcu_read_lock(); + cds_lfht_for_each_entry(ht->ht, &iter.iter, stream, node.node) { + /* + * Ignore return value since we are currently cleaning up so any error + * can't be handled. + */ + (void) consumer_del_metadata_stream(stream, ht); + } + rcu_read_unlock(); + + lttng_ht_destroy(ht); +} + /* * Close all fds associated with the instance and free the context. */ @@ -1258,6 +1372,9 @@ void lttng_consumer_destroy(struct lttng_consumer_local_data *ctx) DBG("Consumer destroying it. Closing everything."); + destroy_data_stream_ht(data_ht); + destroy_metadata_stream_ht(metadata_ht); + ret = close(ctx->consumer_error_socket); if (ret) { PERROR("close"); @@ -1284,15 +1401,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 @@ -1314,7 +1429,7 @@ static int write_relayd_metadata_id(int fd, stream->relayd_stream_id, padding); end: - return ret; + return (int) ret; } /* @@ -1332,7 +1447,7 @@ 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, - struct lttng_packet_index *index) + struct ctf_packet_index *index) { unsigned long mmap_offset; void *mmap_base; @@ -1469,46 +1584,49 @@ ssize_t lttng_consumer_on_read_subbuffer_mmap( } } - while (len > 0) { - do { - ret = write(outfd, mmap_base + mmap_offset, len); - } while (ret < 0 && errno == EINTR); - DBG("Consumer mmap write() ret %zd (len %lu)", ret, len); + /* + * This call guarantee that len or less is returned. It's impossible to + * receive a ret value that is bigger than len. + */ + ret = lttng_write(outfd, mmap_base + mmap_offset, len); + DBG("Consumer mmap write() ret %zd (len %lu)", ret, len); + if (ret < 0 || ((size_t) ret != len)) { + /* + * Report error to caller if nothing was written else at least send the + * amount written. + */ if (ret < 0) { - /* - * 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 - * execution if for instance the relayd is stopped abruptly. This - * can happen so set this to a DBG statement. - */ - DBG("Error in file write mmap"); - if (written == 0) { - written = -errno; - } - /* Socket operation failed. We consider the relayd dead */ - if (errno == EPIPE || errno == EINVAL) { - relayd_hang_up = 1; - goto write_error; - } - goto end; - } else if (ret > len) { - PERROR("Error in file write (ret %zd > len %lu)", ret, len); - written += ret; - goto end; + written = -errno; } else { - len -= ret; - mmap_offset += ret; + written = ret; } - /* This call is useless on a socket so better save a syscall. */ - if (!relayd) { - /* This won't block, but will start writeout asynchronously */ - lttng_sync_file_range(outfd, stream->out_fd_offset, ret, - SYNC_FILE_RANGE_WRITE); - stream->out_fd_offset += ret; + /* Socket operation failed. We consider the relayd dead */ + if (errno == EPIPE || errno == EINVAL) { + /* + * 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 execution if for instance the relayd is stopped + * abruptly. This can happen so set this to a DBG statement. + */ + DBG("Consumer mmap write detected relayd hang up"); + relayd_hang_up = 1; + goto write_error; } - stream->output_written += ret; - written += ret; + + /* Unhandled error, print it and stop function right now. */ + PERROR("Error in write mmap (ret %zd != len %lu)", ret, len); + goto end; + } + stream->output_written += ret; + written = ret; + + /* This call is useless on a socket so better save a syscall. */ + if (!relayd) { + /* This won't block, but will start writeout asynchronously */ + lttng_sync_file_range(outfd, stream->out_fd_offset, len, + SYNC_FILE_RANGE_WRITE); + stream->out_fd_offset += len; } lttng_consumer_sync_trace_file(stream, orig_offset); @@ -1542,7 +1660,7 @@ 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, - struct lttng_packet_index *index) + struct ctf_packet_index *index) { ssize_t ret = 0, written = 0, ret_splice = 0; loff_t offset = 0; @@ -1677,11 +1795,11 @@ ssize_t lttng_consumer_on_read_subbuffer_splice( SPLICE_F_MOVE | SPLICE_F_MORE); DBG("splice chan to pipe, ret %zd", ret_splice); if (ret_splice < 0) { - PERROR("Error in relay splice"); + ret = errno; if (written == 0) { written = ret_splice; } - ret = errno; + PERROR("Error in relay splice"); goto splice_error; } @@ -1707,27 +1825,32 @@ ssize_t lttng_consumer_on_read_subbuffer_splice( ret_splice, SPLICE_F_MOVE | SPLICE_F_MORE); DBG("Consumer splice pipe to file, ret %zd", ret_splice); if (ret_splice < 0) { - PERROR("Error in file splice"); + ret = errno; if (written == 0) { written = ret_splice; } /* Socket operation failed. We consider the relayd dead */ - if (errno == EBADF || errno == EPIPE) { + if (errno == EBADF || errno == EPIPE || errno == ESPIPE) { WARN("Remote relayd disconnected. Stopping"); relayd_hang_up = 1; goto write_error; } - ret = errno; + PERROR("Error in file splice"); goto splice_error; } else if (ret_splice > len) { - errno = EINVAL; - PERROR("Wrote more data than requested %zd (len: %lu)", - ret_splice, len); + /* + * We don't expect this code path to be executed but you never know + * so this is an extra protection agains a buggy splice(). + */ written += ret_splice; ret = errno; + PERROR("Wrote more data than requested %zd (len: %lu)", ret_splice, + len); goto splice_error; + } else { + /* All good, update current len and continue. */ + len -= ret_splice; } - len -= ret_splice; /* This call is useless on a socket so better save a syscall. */ if (!relayd) { @@ -1740,9 +1863,6 @@ ssize_t lttng_consumer_on_read_subbuffer_splice( written += ret_splice; } lttng_consumer_sync_trace_file(stream, orig_offset); - - ret = ret_splice; - goto end; write_error: @@ -1836,60 +1956,6 @@ int lttng_consumer_recv_cmd(struct lttng_consumer_local_data *ctx, } } -/* - * Iterate over all streams of the hashtable and free them properly. - * - * WARNING: *MUST* be used with data stream only. - */ -static void destroy_data_stream_ht(struct lttng_ht *ht) -{ - struct lttng_ht_iter iter; - struct lttng_consumer_stream *stream; - - if (ht == NULL) { - return; - } - - rcu_read_lock(); - cds_lfht_for_each_entry(ht->ht, &iter.iter, stream, node.node) { - /* - * Ignore return value since we are currently cleaning up so any error - * can't be handled. - */ - (void) consumer_del_stream(stream, ht); - } - rcu_read_unlock(); - - lttng_ht_destroy(ht); -} - -/* - * Iterate over all streams of the hashtable and free them properly. - * - * XXX: Should not be only for metadata stream or else use an other name. - */ -static void destroy_stream_ht(struct lttng_ht *ht) -{ - struct lttng_ht_iter iter; - struct lttng_consumer_stream *stream; - - if (ht == NULL) { - return; - } - - rcu_read_lock(); - cds_lfht_for_each_entry(ht->ht, &iter.iter, stream, node.node) { - /* - * Ignore return value since we are currently cleaning up so any error - * can't be handled. - */ - (void) consumer_del_metadata_stream(stream, ht); - } - rcu_read_unlock(); - - lttng_ht_destroy(ht); -} - void lttng_consumer_close_metadata(void) { switch (consumer_data.type) { @@ -2196,12 +2262,12 @@ void *consumer_thread_metadata_poll(void *data) health_register(health_consumerd, HEALTH_CONSUMERD_TYPE_METADATA); - metadata_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); - if (!metadata_ht) { - /* ENOMEM at this point. Better to bail out. */ - goto end_ht; + if (testpoint(consumerd_thread_metadata)) { + goto error_testpoint; } + health_code_update(); + DBG("Thread metadata poll started"); /* Size is set to 1 for the consumer_metadata pipe */ @@ -2221,6 +2287,8 @@ 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 */ @@ -2229,7 +2297,9 @@ void *consumer_thread_metadata_poll(void *data) 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) { @@ -2243,6 +2313,8 @@ 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); @@ -2262,8 +2334,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. */ @@ -2312,6 +2384,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 @@ -2334,6 +2408,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 @@ -2364,8 +2440,7 @@ end: lttng_poll_clean(&events); end_poll: - destroy_stream_ht(metadata_ht); -end_ht: +error_testpoint: if (err) { health_error(); ERR("Health error occurred in %s", __func__); @@ -2394,12 +2469,12 @@ void *consumer_thread_data_poll(void *data) health_register(health_consumerd, HEALTH_CONSUMERD_TYPE_DATA); - data_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); - if (data_ht == NULL) { - /* ENOMEM at this point. Better to bail out. */ - goto end; + if (testpoint(consumerd_thread_data)) { + goto error_testpoint; } + health_code_update(); + local_stream = zmalloc(sizeof(struct lttng_consumer_stream *)); if (local_stream == NULL) { PERROR("local_stream malloc"); @@ -2407,6 +2482,8 @@ void *consumer_thread_data_poll(void *data) } while (1) { + health_code_update(); + high_prio = 0; num_hup = 0; @@ -2459,7 +2536,9 @@ void *consumer_thread_data_poll(void *data) /* 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) { /* @@ -2487,8 +2566,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; } @@ -2509,6 +2588,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; } @@ -2537,6 +2618,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; } @@ -2557,6 +2640,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; } @@ -2619,8 +2704,7 @@ end: */ (void) lttng_pipe_write_close(ctx->consumer_metadata_pipe); - destroy_data_stream_ht(data_ht); - +error_testpoint: if (err) { health_error(); ERR("Health error occurred in %s", __func__); @@ -2721,6 +2805,12 @@ void *consumer_thread_channel_poll(void *data) health_register(health_consumerd, HEALTH_CONSUMERD_TYPE_CHANNEL); + if (testpoint(consumerd_thread_channel)) { + goto error_testpoint; + } + + health_code_update(); + channel_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); if (!channel_ht) { /* ENOMEM at this point. Better to bail out. */ @@ -2745,6 +2835,8 @@ 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 */ @@ -2753,7 +2845,9 @@ void *consumer_thread_channel_poll(void *data) 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) { @@ -2767,6 +2861,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); @@ -2833,6 +2929,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); @@ -2912,6 +3010,7 @@ end: end_poll: destroy_channel_ht(channel_ht); end_ht: +error_testpoint: DBG("Channel poll thread exiting"); if (err) { health_error(); @@ -2967,6 +3066,12 @@ void *consumer_thread_sessiond_poll(void *data) health_register(health_consumerd, HEALTH_CONSUMERD_TYPE_SESSIOND); + if (testpoint(consumerd_thread_sessiond)) { + goto error_testpoint; + } + + 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); @@ -3027,7 +3132,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"); @@ -3080,6 +3190,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); @@ -3094,6 +3206,7 @@ end: } } +error_testpoint: if (err) { health_error(); ERR("Health error occurred in %s", __func__); @@ -3155,12 +3268,42 @@ int lttng_consumer_on_recv_stream(struct lttng_consumer_stream *stream) /* * Allocate and set consumer data hash tables. */ -void lttng_consumer_init(void) +int lttng_consumer_init(void) { consumer_data.channel_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); + if (!consumer_data.channel_ht) { + goto error; + } + consumer_data.relayd_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); + if (!consumer_data.relayd_ht) { + goto error; + } + consumer_data.stream_list_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); + if (!consumer_data.stream_list_ht) { + goto error; + } + consumer_data.stream_per_chan_id_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); + if (!consumer_data.stream_per_chan_id_ht) { + goto error; + } + + data_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); + if (!data_ht) { + goto error; + } + + metadata_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); + if (!metadata_ht) { + goto error; + } + + return 0; + +error: + return -1; } /* @@ -3176,7 +3319,7 @@ int consumer_add_relayd_socket(uint64_t net_seq_idx, int sock_type, 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); @@ -3212,7 +3355,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); @@ -3573,9 +3716,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; }