Rename C++ header files to .hpp
[lttng-tools.git] / src / bin / lttng-relayd / main.cpp
index adbf3f3b4c18be0693770903599934588c0c37e5..e1c74e358ebff36c9426cba3c2cc82a1ece4b3c8 100644 (file)
 #include <algorithm>
 
 #include <lttng/lttng.h>
-#include <common/common.h>
-#include <common/compat/poll.h>
-#include <common/compat/socket.h>
-#include <common/compat/endian.h>
-#include <common/compat/getenv.h>
-#include <common/defaults.h>
-#include <common/daemonize.h>
-#include <common/futex.h>
-#include <common/sessiond-comm/sessiond-comm.h>
-#include <common/sessiond-comm/inet.h>
-#include <common/sessiond-comm/relayd.h>
-#include <common/uri.h>
-#include <common/utils.h>
-#include <common/align.h>
-#include <common/ini-config/ini-config.h>
-#include <common/dynamic-buffer.h>
-#include <common/buffer-view.h>
-#include <common/string-utils/format.h>
-#include <common/fd-tracker/fd-tracker.h>
-#include <common/fd-tracker/utils.h>
-
-#include "backward-compatibility-group-by.h"
-#include "cmd.h"
-#include "connection.h"
-#include "ctf-trace.h"
-#include "health-relayd.h"
-#include "index.h"
-#include "live.h"
-#include "lttng-relayd.h"
-#include "session.h"
-#include "sessiond-trace-chunks.h"
-#include "stream.h"
-#include "tcp_keep_alive.h"
-#include "testpoint.h"
-#include "tracefile-array.h"
-#include "utils.h"
-#include "version.h"
-#include "viewer-stream.h"
+#include <common/common.hpp>
+#include <common/compat/poll.hpp>
+#include <common/compat/socket.hpp>
+#include <common/compat/endian.hpp>
+#include <common/compat/getenv.hpp>
+#include <common/defaults.hpp>
+#include <common/daemonize.hpp>
+#include <common/futex.hpp>
+#include <common/sessiond-comm/sessiond-comm.hpp>
+#include <common/sessiond-comm/inet.hpp>
+#include <common/sessiond-comm/relayd.hpp>
+#include <common/uri.hpp>
+#include <common/utils.hpp>
+#include <common/path.hpp>
+#include <common/align.hpp>
+#include <common/ini-config/ini-config.hpp>
+#include <common/dynamic-buffer.hpp>
+#include <common/buffer-view.hpp>
+#include <common/string-utils/format.hpp>
+#include <common/fd-tracker/fd-tracker.hpp>
+#include <common/fd-tracker/utils.hpp>
+
+#include "backward-compatibility-group-by.hpp"
+#include "cmd.hpp"
+#include "connection.hpp"
+#include "ctf-trace.hpp"
+#include "health-relayd.hpp"
+#include "index.hpp"
+#include "live.hpp"
+#include "lttng-relayd.hpp"
+#include "session.hpp"
+#include "sessiond-trace-chunks.hpp"
+#include "stream.hpp"
+#include "tcp_keep_alive.hpp"
+#include "testpoint.hpp"
+#include "tracefile-array.hpp"
+#include "utils.hpp"
+#include "version.hpp"
+#include "viewer-stream.hpp"
 
 static const char *help_msg =
 #ifdef LTTNG_EMBED_HELP
@@ -404,7 +405,8 @@ end:
  * See config_entry_handler_cb comment in common/config/session-config.h for the
  * return value conventions.
  */
-static int config_entry_handler(const struct config_entry *entry, void *unused)
+static int config_entry_handler(const struct config_entry *entry,
+               void *unused __attribute__((unused)))
 {
        int ret = 0, i;
 
@@ -675,7 +677,8 @@ static void print_global_objects(void)
        print_sessions();
 }
 
-static int noop_close(void *data, int *fds)
+static int noop_close(void *data __attribute__((unused)),
+               int *fds __attribute__((unused)))
 {
        return 0;
 }
@@ -972,7 +975,7 @@ end:
        return ret;
 }
 
-static int close_sock(void *data, int *in_fd)
+static int close_sock(void *data, int *in_fd __attribute__((unused)))
 {
        struct lttcomm_sock *sock = (lttcomm_sock *) data;
 
@@ -1084,7 +1087,7 @@ end:
 /*
  * This thread manages the listening for new connections on the network
  */
-static void *relay_thread_listener(void *data)
+static void *relay_thread_listener(void *data __attribute__((unused)))
 {
        int i, ret, pollfd, err = -1;
        uint32_t revents, nb_fd;
@@ -1288,7 +1291,7 @@ error_sock_control:
 /*
  * This thread manages the dispatching of the requests to worker threads
  */
-static void *relay_thread_dispatcher(void *data)
+static void *relay_thread_dispatcher(void *data __attribute__((unused)))
 {
        int err = -1;
        ssize_t ret;
@@ -1375,7 +1378,8 @@ static bool session_streams_have_index(const struct relay_session *session)
  *
  * On success, send back the session id or else return a negative value.
  */
-static int relay_create_session(const struct lttcomm_relayd_hdr *recv_hdr,
+static int relay_create_session(
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
                const struct lttng_buffer_view *payload)
 {
@@ -1567,7 +1571,8 @@ end:
 /*
  * relay_add_stream: allocate a new stream for a session
  */
-static int relay_add_stream(const struct lttcomm_relayd_hdr *recv_hdr,
+static int relay_add_stream(
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
                const struct lttng_buffer_view *payload)
 {
@@ -1706,7 +1711,8 @@ end_no_session:
 /*
  * relay_close_stream: close a specific stream
  */
-static int relay_close_stream(const struct lttcomm_relayd_hdr *recv_hdr,
+static int relay_close_stream(
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
                const struct lttng_buffer_view *payload)
 {
@@ -1758,24 +1764,6 @@ static int relay_close_stream(const struct lttcomm_relayd_hdr *recv_hdr,
         *        request.
         */
        try_stream_close(stream);
-       if (stream->is_metadata) {
-               struct relay_viewer_stream *vstream;
-
-               vstream = viewer_stream_get_by_id(stream->stream_handle);
-               if (vstream) {
-                       if (stream->no_new_metadata_notified) {
-                               /*
-                                * Since all the metadata has been sent to the
-                                * viewer and that we have a request to close
-                                * its stream, we can safely teardown the
-                                * corresponding metadata viewer stream.
-                                */
-                               viewer_stream_put(vstream);
-                       }
-                       /* Put local reference. */
-                       viewer_stream_put(vstream);
-               }
-       }
        stream_put(stream);
        ret = 0;
 
@@ -1802,7 +1790,8 @@ end_no_session:
  * relay_reset_metadata: reset a metadata stream
  */
 static
-int relay_reset_metadata(const struct lttcomm_relayd_hdr *recv_hdr,
+int relay_reset_metadata(
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
                const struct lttng_buffer_view *payload)
 {
@@ -1901,9 +1890,10 @@ static void relay_unknown_command(struct relay_connection *conn)
  * relay_start: send an acknowledgment to the client to tell if we are
  * ready to receive data. We are ready if a session is established.
  */
-static int relay_start(const struct lttcomm_relayd_hdr *recv_hdr,
+static int relay_start(
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
-               const struct lttng_buffer_view *payload)
+               const struct lttng_buffer_view *payload __attribute__((unused)))
 {
        int ret = 0;
        ssize_t send_ret;
@@ -1994,7 +1984,8 @@ end:
 /*
  * relay_send_version: send relayd version number
  */
-static int relay_send_version(const struct lttcomm_relayd_hdr *recv_hdr,
+static int relay_send_version(
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
                const struct lttng_buffer_view *payload)
 {
@@ -2064,7 +2055,8 @@ end:
 /*
  * Check for data pending for a given stream id from the session daemon.
  */
-static int relay_data_pending(const struct lttcomm_relayd_hdr *recv_hdr,
+static int relay_data_pending(
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
                const struct lttng_buffer_view *payload)
 {
@@ -2153,7 +2145,8 @@ end_no_session:
  * the control socket has been handled. So, this is why we simply return
  * OK here.
  */
-static int relay_quiescent_control(const struct lttcomm_relayd_hdr *recv_hdr,
+static int relay_quiescent_control(
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
                const struct lttng_buffer_view *payload)
 {
@@ -2293,7 +2286,8 @@ end_no_session:
  *
  * Return to the client if there is data in flight or not with a ret_code.
  */
-static int relay_end_data_pending(const struct lttcomm_relayd_hdr *recv_hdr,
+static int relay_end_data_pending(
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
                const struct lttng_buffer_view *payload)
 {
@@ -2385,7 +2379,8 @@ end_no_session:
  *
  * Return 0 on success else a negative value.
  */
-static int relay_recv_index(const struct lttcomm_relayd_hdr *recv_hdr,
+static int relay_recv_index(
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
                const struct lttng_buffer_view *payload)
 {
@@ -2473,9 +2468,10 @@ end_no_session:
  *
  * Return 0 on success else a negative value.
  */
-static int relay_streams_sent(const struct lttcomm_relayd_hdr *recv_hdr,
+static int relay_streams_sent(
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
-               const struct lttng_buffer_view *payload)
+               const struct lttng_buffer_view *payload __attribute__((unused)))
 {
        int ret;
        ssize_t send_ret;
@@ -2547,6 +2543,7 @@ static ssize_t relay_unpack_rotate_streams_header(
                        sizeof(rotate_streams.stream_count));
        rotate_streams = (typeof(rotate_streams)) {
                .stream_count = be32toh(rotate_streams.stream_count),
+               .new_chunk_id = LTTNG_OPTIONAL_INIT_UNSET,
        };
 
        /*
@@ -2637,7 +2634,7 @@ error:
  * session rotation feature (not the tracefile rotation feature).
  */
 static int relay_rotate_session_streams(
-               const struct lttcomm_relayd_hdr *recv_hdr,
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
                const struct lttng_buffer_view *payload)
 {
@@ -2681,7 +2678,10 @@ static int relay_rotate_session_streams(
                 */
                next_trace_chunk = sessiond_trace_chunk_registry_get_chunk(
                                sessiond_trace_chunk_registry,
-                               session->sessiond_uuid, session->id,
+                               session->sessiond_uuid,
+                               conn->session->id_sessiond.is_set ?
+                                       conn->session->id_sessiond.value :
+                                       conn->session->id,
                                rotate_streams.new_chunk_id.value);
                if (!next_trace_chunk) {
                        char uuid_str[LTTNG_UUID_STR_LEN];
@@ -2772,7 +2772,8 @@ end_no_reply:
 /*
  * relay_create_trace_chunk: create a new trace chunk
  */
-static int relay_create_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
+static int relay_create_trace_chunk(
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
                const struct lttng_buffer_view *payload)
 {
@@ -2812,6 +2813,8 @@ static int relay_create_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
        msg->creation_timestamp = be64toh(msg->creation_timestamp);
        msg->override_name_length = be32toh(msg->override_name_length);
 
+       pthread_mutex_lock(&conn->session->lock);
+       session->ongoing_rotation = true;
        if (session->current_trace_chunk &&
                        !lttng_trace_chunk_get_name_overridden(session->current_trace_chunk)) {
                chunk_status = lttng_trace_chunk_rename_path(session->current_trace_chunk,
@@ -2823,7 +2826,6 @@ static int relay_create_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
                        goto end;
                }
        }
-       session->ongoing_rotation = true;
        if (!session->current_trace_chunk) {
                if (!session->has_rotated) {
                        new_path = "";
@@ -2902,7 +2904,9 @@ static int relay_create_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
        published_chunk = sessiond_trace_chunk_registry_publish_chunk(
                        sessiond_trace_chunk_registry,
                        conn->session->sessiond_uuid,
-                       conn->session->id,
+                       conn->session->id_sessiond.is_set ?
+                               conn->session->id_sessiond.value :
+                               conn->session->id,
                        chunk);
        if (!published_chunk) {
                char uuid_str[LTTNG_UUID_STR_LEN];
@@ -2917,7 +2921,6 @@ static int relay_create_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
                goto end;
        }
 
-       pthread_mutex_lock(&conn->session->lock);
        if (conn->session->pending_closure_trace_chunk) {
                /*
                 * Invalid; this means a second create_trace_chunk command was
@@ -2926,7 +2929,7 @@ static int relay_create_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
                ERR("Invalid trace chunk close command received; a trace chunk is already waiting for a trace chunk close command");
                reply_code = LTTNG_ERR_INVALID_PROTOCOL;
                ret = -1;
-               goto end_unlock_session;
+               goto end;
        }
        conn->session->pending_closure_trace_chunk =
                        conn->session->current_trace_chunk;
@@ -2935,9 +2938,8 @@ static int relay_create_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
        if (!conn->session->pending_closure_trace_chunk) {
                session->ongoing_rotation = false;
        }
-end_unlock_session:
-       pthread_mutex_unlock(&conn->session->lock);
 end:
+       pthread_mutex_unlock(&conn->session->lock);
        reply.ret_code = htobe32((uint32_t) reply_code);
        send_ret = conn->sock->ops->sendmsg(conn->sock,
                        &reply,
@@ -2957,7 +2959,8 @@ end_no_reply:
 /*
  * relay_close_trace_chunk: close a trace chunk
  */
-static int relay_close_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
+static int relay_close_trace_chunk(
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
                const struct lttng_buffer_view *payload)
 {
@@ -3010,7 +3013,9 @@ static int relay_close_trace_chunk(const struct lttcomm_relayd_hdr *recv_hdr,
        chunk = sessiond_trace_chunk_registry_get_chunk(
                        sessiond_trace_chunk_registry,
                        conn->session->sessiond_uuid,
-                       conn->session->id,
+                       conn->session->id_sessiond.is_set ?
+                               conn->session->id_sessiond.value :
+                               conn->session->id,
                        chunk_id);
        if (!chunk) {
                char uuid_str[LTTNG_UUID_STR_LEN];
@@ -3211,7 +3216,8 @@ end_no_reply:
 /*
  * relay_trace_chunk_exists: check if a trace chunk exists
  */
-static int relay_trace_chunk_exists(const struct lttcomm_relayd_hdr *recv_hdr,
+static int relay_trace_chunk_exists(
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
                const struct lttng_buffer_view *payload)
 {
@@ -3274,7 +3280,8 @@ end_no_reply:
 /*
  * relay_get_configuration: query whether feature is available
  */
-static int relay_get_configuration(const struct lttcomm_relayd_hdr *recv_hdr,
+static int relay_get_configuration(
+               const struct lttcomm_relayd_hdr *recv_hdr __attribute__((unused)),
                struct relay_connection *conn,
                const struct lttng_buffer_view *payload)
 {
@@ -3320,86 +3327,68 @@ end_no_reply:
        return ret;
 }
 
-#define DBG_CMD(cmd_name, conn) \
-               DBG3("Processing \"%s\" command for socket %i", cmd_name, conn->sock->fd);
-
 static int relay_process_control_command(struct relay_connection *conn,
                const struct lttcomm_relayd_hdr *header,
                const struct lttng_buffer_view *payload)
 {
        int ret = 0;
 
+       DBG3("Processing \"%s\" command for socket %i",
+                       lttcomm_relayd_command_str((lttcomm_relayd_command) header->cmd),
+                       conn->sock->fd);
        switch (header->cmd) {
        case RELAYD_CREATE_SESSION:
-               DBG_CMD("RELAYD_CREATE_SESSION", conn);
                ret = relay_create_session(header, conn, payload);
                break;
        case RELAYD_ADD_STREAM:
-               DBG_CMD("RELAYD_ADD_STREAM", conn);
                ret = relay_add_stream(header, conn, payload);
                break;
        case RELAYD_START_DATA:
-               DBG_CMD("RELAYD_START_DATA", conn);
                ret = relay_start(header, conn, payload);
                break;
        case RELAYD_SEND_METADATA:
-               DBG_CMD("RELAYD_SEND_METADATA", conn);
                ret = relay_recv_metadata(header, conn, payload);
                break;
        case RELAYD_VERSION:
-               DBG_CMD("RELAYD_VERSION", conn);
                ret = relay_send_version(header, conn, payload);
                break;
        case RELAYD_CLOSE_STREAM:
-               DBG_CMD("RELAYD_CLOSE_STREAM", conn);
                ret = relay_close_stream(header, conn, payload);
                break;
        case RELAYD_DATA_PENDING:
-               DBG_CMD("RELAYD_DATA_PENDING", conn);
                ret = relay_data_pending(header, conn, payload);
                break;
        case RELAYD_QUIESCENT_CONTROL:
-               DBG_CMD("RELAYD_QUIESCENT_CONTROL", conn);
                ret = relay_quiescent_control(header, conn, payload);
                break;
        case RELAYD_BEGIN_DATA_PENDING:
-               DBG_CMD("RELAYD_BEGIN_DATA_PENDING", conn);
                ret = relay_begin_data_pending(header, conn, payload);
                break;
        case RELAYD_END_DATA_PENDING:
-               DBG_CMD("RELAYD_END_DATA_PENDING", conn);
                ret = relay_end_data_pending(header, conn, payload);
                break;
        case RELAYD_SEND_INDEX:
-               DBG_CMD("RELAYD_SEND_INDEX", conn);
                ret = relay_recv_index(header, conn, payload);
                break;
        case RELAYD_STREAMS_SENT:
-               DBG_CMD("RELAYD_STREAMS_SENT", conn);
                ret = relay_streams_sent(header, conn, payload);
                break;
        case RELAYD_RESET_METADATA:
-               DBG_CMD("RELAYD_RESET_METADATA", conn);
                ret = relay_reset_metadata(header, conn, payload);
                break;
        case RELAYD_ROTATE_STREAMS:
-               DBG_CMD("RELAYD_ROTATE_STREAMS", conn);
                ret = relay_rotate_session_streams(header, conn, payload);
                break;
        case RELAYD_CREATE_TRACE_CHUNK:
-               DBG_CMD("RELAYD_CREATE_TRACE_CHUNK", conn);
                ret = relay_create_trace_chunk(header, conn, payload);
                break;
        case RELAYD_CLOSE_TRACE_CHUNK:
-               DBG_CMD("RELAYD_CLOSE_TRACE_CHUNK", conn);
                ret = relay_close_trace_chunk(header, conn, payload);
                break;
        case RELAYD_TRACE_CHUNK_EXISTS:
-               DBG_CMD("RELAYD_TRACE_CHUNK_EXISTS", conn);
                ret = relay_trace_chunk_exists(header, conn, payload);
                break;
        case RELAYD_GET_CONFIGURATION:
-               DBG_CMD("RELAYD_GET_CONFIGURATION", conn);
                ret = relay_get_configuration(header, conn, payload);
                break;
        case RELAYD_UPDATE_SYNC_INFO:
@@ -3434,7 +3423,10 @@ static enum relay_connection_status relay_process_control_receive_payload(
                        reception_buffer->data + state->received,
                        state->left_to_receive, MSG_DONTWAIT);
        if (ret < 0) {
+               DIAGNOSTIC_PUSH
+               DIAGNOSTIC_IGNORE_LOGICAL_OP
                if (errno != EAGAIN && errno != EWOULDBLOCK) {
+               DIAGNOSTIC_POP
                        PERROR("Unable to receive command payload on sock %d",
                                        conn->sock->fd);
                        status = RELAY_CONNECTION_STATUS_ERROR;
@@ -3507,7 +3499,10 @@ static enum relay_connection_status relay_process_control_receive_header(
                        reception_buffer->data + state->received,
                        state->left_to_receive, MSG_DONTWAIT);
        if (ret < 0) {
+               DIAGNOSTIC_PUSH
+               DIAGNOSTIC_IGNORE_LOGICAL_OP
                if (errno != EAGAIN && errno != EWOULDBLOCK) {
+               DIAGNOSTIC_POP
                        PERROR("Unable to receive control command header on sock %d",
                                        conn->sock->fd);
                        status = RELAY_CONNECTION_STATUS_ERROR;
@@ -3547,9 +3542,9 @@ static enum relay_connection_status relay_process_control_receive_header(
        memcpy(&conn->protocol.ctrl.state.receive_payload.header,
                        &header, sizeof(header));
 
-       DBG("Done receiving control command header: fd = %i, cmd = %" PRIu32 ", cmd_version = %" PRIu32 ", payload size = %" PRIu64 " bytes",
-                       conn->sock->fd, header.cmd, header.cmd_version,
-                       header.data_size);
+       DBG("Done receiving control command header: fd = %i, cmd = %s, cmd_version = %" PRIu32 ", payload size = %" PRIu64 " bytes",
+                       conn->sock->fd, lttcomm_relayd_command_str((enum lttcomm_relayd_command) header.cmd),
+                       header.cmd_version, header.data_size);
 
        if (header.data_size > DEFAULT_NETWORK_RELAYD_CTRL_MAX_PAYLOAD_SIZE) {
                ERR("Command header indicates a payload (%" PRIu64 " bytes) that exceeds the maximal payload size allowed on a control connection.",
@@ -3618,7 +3613,10 @@ static enum relay_connection_status relay_process_data_receive_header(
                        state->header_reception_buffer + state->received,
                        state->left_to_receive, MSG_DONTWAIT);
        if (ret < 0) {
+               DIAGNOSTIC_PUSH
+               DIAGNOSTIC_IGNORE_LOGICAL_OP
                if (errno != EAGAIN && errno != EWOULDBLOCK) {
+               DIAGNOSTIC_POP
                        PERROR("Unable to receive data header on sock %d", conn->sock->fd);
                        status = RELAY_CONNECTION_STATUS_ERROR;
                }
@@ -3745,7 +3743,10 @@ static enum relay_connection_status relay_process_data_receive_payload(
                ret = conn->sock->ops->recvmsg(conn->sock, data_buffer,
                                recv_size, MSG_DONTWAIT);
                if (ret < 0) {
+                       DIAGNOSTIC_PUSH
+                       DIAGNOSTIC_IGNORE_LOGICAL_OP
                        if (errno != EAGAIN && errno != EWOULDBLOCK) {
+                       DIAGNOSTIC_POP
                                PERROR("Socket %d error", conn->sock->fd);
                                status = RELAY_CONNECTION_STATUS_ERROR;
                        }
@@ -3914,7 +3915,7 @@ static void relay_thread_close_connection(struct lttng_poll_event *events,
 /*
  * This thread does the actual work
  */
-static void *relay_thread_worker(void *data)
+static void *relay_thread_worker(void *data __attribute__((unused)))
 {
        int ret, err = -1, last_seen_data_fd = -1;
        uint32_t nb_fd;
@@ -4242,7 +4243,7 @@ static int create_relay_conn_pipe(void)
                        "Relayd connection pipe", relay_conn_pipe);
 }
 
-static int stdio_open(void *data, int *fds)
+static int stdio_open(void *data __attribute__((unused)), int *fds)
 {
        fds[0] = fileno(stdout);
        fds[1] = fileno(stderr);
@@ -4441,7 +4442,7 @@ int main(int argc, char **argv)
 
        /* Create thread to manage the client socket */
        ret = pthread_create(&health_thread, default_pthread_attr(),
-                       thread_manage_health, (void *) NULL);
+                       thread_manage_health_relayd, (void *) NULL);
        if (ret) {
                errno = ret;
                PERROR("pthread_create health");
This page took 0.030512 seconds and 4 git commands to generate.