#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
* 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;
print_sessions();
}
-static int noop_close(void *data, int *fds)
+static int noop_close(void *data __attribute__((unused)),
+ int *fds __attribute__((unused)))
{
return 0;
}
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;
/*
* 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;
/*
* 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;
/* Continue thread execution */
break;
}
- new_conn = caa_container_of(node, struct relay_connection, qnode);
+ new_conn = lttng::utils::container_of(node, &relay_connection::qnode);
DBG("Dispatching request waiting on sock %d", new_conn->sock->fd);
*
* 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)
{
/*
* 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)
{
/*
* 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)
{
* 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)
{
* 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;
/*
* 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)
{
/*
* 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)
{
* 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)
{
*
* 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)
{
*
* 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)
{
*
* 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;
sizeof(rotate_streams.stream_count));
rotate_streams = (typeof(rotate_streams)) {
.stream_count = be32toh(rotate_streams.stream_count),
+ .new_chunk_id = LTTNG_OPTIONAL_INIT_UNSET,
};
/*
* 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)
{
/*
* 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)
{
/*
* 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)
{
/*
* 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)
{
/*
* 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)
{
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;
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;
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;
}
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;
}
/*
* 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;
"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);
/* 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");
projects / lttng-tools.git / blobdiff