#include "lttng-relayd.h"
#include "lttng-viewer.h"
#include "utils.h"
+#include "health-relayd.h"
static struct lttng_uri *live_uri;
{
DBG("Cleaning up");
- /* Close thread quit pipes */
- utils_close_pipe(live_thread_quit_pipe);
free(live_uri);
}
futex_nto1_wake(&viewer_cmd_queue.futex);
}
-/*
- * Init thread quit pipe.
- *
- * Return -1 on error or 0 if all pipes are created.
- */
-static
-int init_thread_quit_pipe(void)
-{
- int ret;
-
- ret = utils_create_pipe_cloexec(live_thread_quit_pipe);
-
- return ret;
-}
-
/*
* Create a poll set with O_CLOEXEC and add the thread quit pipe to the set.
*/
DBG("[thread] Relay live listener started");
+ health_register(health_relayd, HEALTH_RELAYD_TYPE_LIVE_LISTENER);
+
+ health_code_update();
+
live_control_sock = init_socket(live_uri);
if (!live_control_sock) {
goto error_sock_control;
}
while (1) {
+ health_code_update();
+
DBG("Listener accepting live viewers connections");
restart:
+ health_poll_entry();
ret = lttng_poll_wait(&events, -1);
+ health_poll_exit();
if (ret < 0) {
/*
* Restart interrupted system call.
DBG("Relay new viewer connection received");
for (i = 0; i < nb_fd; i++) {
+ health_code_update();
+
/* Fetch once the poll data */
revents = LTTNG_POLL_GETEV(&events, i);
pollfd = LTTNG_POLL_GETFD(&events, i);
lttcomm_destroy_sock(live_control_sock);
error_sock_control:
if (err) {
+ health_error();
DBG("Live viewer listener thread exited with error");
}
+ health_unregister(health_relayd);
DBG("Live viewer listener thread cleanup complete");
stop_threads();
return NULL;
static
void *thread_dispatcher(void *data)
{
- int ret;
+ int ret, err = -1;
struct cds_wfq_node *node;
struct relay_command *relay_cmd = NULL;
DBG("[thread] Live viewer relay dispatcher started");
+ health_register(health_relayd, HEALTH_RELAYD_TYPE_LIVE_DISPATCHER);
+
+ health_code_update();
+
while (!CMM_LOAD_SHARED(live_dispatch_thread_exit)) {
+ health_code_update();
+
/* Atomically prepare the queue futex */
futex_nto1_prepare(&viewer_cmd_queue.futex);
do {
+ health_code_update();
+
/* Dequeue commands */
node = cds_wfq_dequeue_blocking(&viewer_cmd_queue.queue);
if (node == NULL) {
} while (node != NULL);
/* Futex wait on queue. Blocking call on futex() */
+ health_poll_entry();
futex_nto1_wait(&viewer_cmd_queue.futex);
+ health_poll_exit();
}
+ /* Normal exit, no error */
+ err = 0;
+
error:
+ if (err) {
+ health_error();
+ ERR("Health error occurred in %s", __func__);
+ }
+ health_unregister(health_relayd);
DBG("Live viewer dispatch thread dying");
stop_threads();
return NULL;
cmd->version_check_done = 1;
+ health_code_update();
+
/* Get version from the other side. */
ret = cmd->sock->ops->recvmsg(cmd->sock, &msg, sizeof(msg), 0);
if (ret < 0 || ret != sizeof(msg)) {
goto end;
}
+ health_code_update();
+
reply.major = RELAYD_VERSION_COMM_MAJOR;
reply.minor = RELAYD_VERSION_COMM_MINOR;
if (cmd->type == RELAY_VIEWER_COMMAND) {
reply.viewer_session_id = htobe64(++last_relay_viewer_session_id);
}
+
+ health_code_update();
+
ret = cmd->sock->ops->sendmsg(cmd->sock, &reply,
sizeof(struct lttng_viewer_connect), 0);
if (ret < 0) {
ERR("Relay sending version");
}
+ health_code_update();
+
DBG("Version check done using protocol %u.%u", cmd->major, cmd->minor);
ret = 0;
cds_lfht_count_nodes(sessions_ht->ht, &approx_before, &count, &approx_after);
session_list.sessions_count = htobe32(count);
+ health_code_update();
+
ret = cmd->sock->ops->sendmsg(cmd->sock, &session_list,
sizeof(session_list), 0);
if (ret < 0) {
goto end_unlock;
}
+ health_code_update();
+
cds_lfht_for_each_entry(sessions_ht->ht, &iter.iter, node, node) {
+ health_code_update();
+
node = lttng_ht_iter_get_node_ulong(&iter);
if (!node) {
goto end_unlock;
send_session.live_timer = htobe32(session->live_timer);
send_session.clients = htobe32(session->viewer_attached);
+ health_code_update();
+
ret = cmd->sock->ops->sendmsg(cmd->sock, &send_session,
sizeof(send_session), 0);
if (ret < 0) {
goto end_unlock;
}
}
+ health_code_update();
+
rcu_read_unlock();
ret = 0;
goto end;
* Returns 0 on success or a negative value on error.
*/
static
-int init_viewer_stream(struct relay_stream *stream,
- struct lttng_ht *viewer_streams_ht)
+int init_viewer_stream(struct relay_stream *stream)
{
int ret;
struct relay_viewer_stream *viewer_stream;
assert(stream);
- assert(viewer_streams_ht);
viewer_stream = zmalloc(sizeof(*viewer_stream));
if (!viewer_stream) {
*/
static
int viewer_attach_session(struct relay_command *cmd,
- struct lttng_ht *sessions_ht,
- struct lttng_ht *viewer_streams_ht)
+ struct lttng_ht *sessions_ht)
{
int ret, send_streams = 0, nb_streams = 0;
struct lttng_viewer_attach_session_request request;
assert(cmd);
assert(sessions_ht);
- assert(viewer_streams_ht);
DBG("Attach session received");
goto end_no_session;
}
+ health_code_update();
+
ret = cmd->sock->ops->recvmsg(cmd->sock, &request, sizeof(request), 0);
if (ret < 0 || ret != sizeof(request)) {
if (ret == 0) {
goto error;
}
+ health_code_update();
+
rcu_read_lock();
lttng_ht_lookup(sessions_ht,
(void *)((unsigned long) be64toh(request.session_id)), &iter);
}
session = caa_container_of(node, struct relay_session, session_n);
- if (cmd->session == session) {
+ if (cmd->session_id == session->id) {
/* Same viewer already attached, just send the stream list. */
send_streams = 1;
response.status = htobe32(VIEWER_ATTACH_OK);
session->viewer_attached++;
send_streams = 1;
response.status = htobe32(VIEWER_ATTACH_OK);
+ cmd->session_id = session->id;
cmd->session = session;
}
cds_lfht_for_each_entry(relay_streams_ht->ht, &iter.iter, node, node) {
struct relay_viewer_stream *vstream;
+ health_code_update();
+
node = lttng_ht_iter_get_node_ulong(&iter);
if (!node) {
continue;
continue;
}
- vstream = live_find_viewer_stream_by_id(stream->stream_handle,
- viewer_streams_ht);
+ vstream = live_find_viewer_stream_by_id(stream->stream_handle);
if (!vstream) {
- ret = init_viewer_stream(stream, viewer_streams_ht);
+ ret = init_viewer_stream(stream);
if (ret < 0) {
goto end_unlock;
}
}
send_reply:
+ health_code_update();
ret = cmd->sock->ops->sendmsg(cmd->sock, &response, sizeof(response), 0);
if (ret < 0) {
ERR("Relay sending viewer attach response");
goto end_unlock;
}
+ health_code_update();
/*
* Unknown or busy session, just return gracefully, the viewer knows what
/* We should only be there if we have a session to attach to. */
assert(session);
cds_lfht_for_each_entry(viewer_streams_ht->ht, &iter.iter, node, node) {
+ health_code_update();
+
node64 = lttng_ht_iter_get_node_u64(&iter);
if (!node64) {
continue;
DBG("Opening index file %s in read only, (fd: %d)", fullpath, ret);
do {
+ health_code_update();
ret = read(stream->index_read_fd, &hdr, sizeof(hdr));
} while (ret < 0 && errno == EINTR);
if (ret < 0) {
*
* RCU read side lock MUST be acquired.
*/
-struct relay_viewer_stream *live_find_viewer_stream_by_id(uint64_t stream_id,
- struct lttng_ht *viewer_streams_ht)
+struct relay_viewer_stream *live_find_viewer_stream_by_id(uint64_t stream_id)
{
struct lttng_ht_node_u64 *node;
struct lttng_ht_iter iter;
struct relay_viewer_stream *stream = NULL;
- assert(viewer_streams_ht);
-
lttng_ht_lookup(viewer_streams_ht, &stream_id, &iter);
node = lttng_ht_iter_get_node_u64(&iter);
if (node == NULL) {
*/
static
int viewer_get_next_index(struct relay_command *cmd,
- struct lttng_ht *viewer_streams_ht, struct lttng_ht *sessions_ht)
+ struct lttng_ht *sessions_ht)
{
int ret;
struct lttng_viewer_get_next_index request_index;
struct relay_stream *rstream;
assert(cmd);
- assert(viewer_streams_ht);
assert(sessions_ht);
DBG("Viewer get next index");
goto end_no_session;
}
+ health_code_update();
ret = cmd->sock->ops->recvmsg(cmd->sock, &request_index,
sizeof(request_index), 0);
if (ret < 0 || ret != sizeof(request_index)) {
ERR("Relay didn't receive the whole packet");
goto end;
}
+ health_code_update();
rcu_read_lock();
- vstream = live_find_viewer_stream_by_id(be64toh(request_index.stream_id),
- viewer_streams_ht);
+ vstream = live_find_viewer_stream_by_id(be64toh(request_index.stream_id));
if (!vstream) {
ret = -1;
goto end_unlock;
}
do {
+ health_code_update();
ret = read(vstream->index_read_fd, &packet_index,
sizeof(packet_index));
} while (ret < 0 && errno == EINTR);
send_reply:
viewer_index.flags = htobe32(viewer_index.flags);
+ health_code_update();
ret = cmd->sock->ops->sendmsg(cmd->sock, &viewer_index,
sizeof(viewer_index), 0);
if (ret < 0) {
ERR("Relay index to viewer");
goto end_unlock;
}
+ health_code_update();
DBG("Index %" PRIu64 "for stream %" PRIu64 "sent",
vstream->last_sent_index, vstream->stream_handle);
* Return 0 on success or else a negative value.
*/
static
-int viewer_get_packet(struct relay_command *cmd,
- struct lttng_ht *viewer_streams_ht)
+int viewer_get_packet(struct relay_command *cmd)
{
int ret, send_data = 0;
char *data = NULL;
struct relay_viewer_stream *stream;
assert(cmd);
- assert(viewer_streams_ht);
DBG2("Relay get data packet");
goto end;
}
+ health_code_update();
ret = cmd->sock->ops->recvmsg(cmd->sock, &get_packet_info,
sizeof(get_packet_info), 0);
if (ret < 0 || ret != sizeof(get_packet_info)) {
ERR("Relay didn't receive the whole packet");
goto end;
}
+ health_code_update();
rcu_read_lock();
- stream = live_find_viewer_stream_by_id(be64toh(get_packet_info.stream_id),
- viewer_streams_ht);
+ stream = live_find_viewer_stream_by_id(be64toh(get_packet_info.stream_id));
if (!stream) {
goto error;
}
send_reply:
reply.flags = htobe32(reply.flags);
+
+ health_code_update();
ret = cmd->sock->ops->sendmsg(cmd->sock, &reply, sizeof(reply), 0);
if (ret < 0) {
ERR("Relay data header to viewer");
goto end_unlock;
}
+ health_code_update();
if (send_data) {
+ health_code_update();
ret = cmd->sock->ops->sendmsg(cmd->sock, data, len, 0);
if (ret < 0) {
ERR("Relay send data to viewer");
goto end_unlock;
}
+ health_code_update();
}
DBG("Sent %u bytes for stream %" PRIu64, len,
* Return 0 on success else a negative value.
*/
static
-int viewer_get_metadata(struct relay_command *cmd,
- struct lttng_ht *viewer_streams_ht)
+int viewer_get_metadata(struct relay_command *cmd)
{
int ret = 0;
ssize_t read_len;
struct relay_viewer_stream *stream;
assert(cmd);
- assert(viewer_streams_ht);
DBG("Relay get metadata");
goto end;
}
+ health_code_update();
ret = cmd->sock->ops->recvmsg(cmd->sock, &request,
sizeof(request), 0);
if (ret < 0 || ret != sizeof(request)) {
ERR("Relay didn't receive the whole packet");
goto end;
}
+ health_code_update();
rcu_read_lock();
- stream = live_find_viewer_stream_by_id(be64toh(request.stream_id),
- viewer_streams_ht);
+ stream = live_find_viewer_stream_by_id(be64toh(request.stream_id));
if (!stream || !stream->metadata_flag) {
ERR("Invalid metadata stream");
goto error;
reply.status = htobe32(VIEWER_METADATA_ERR);
send_reply:
+ health_code_update();
ret = cmd->sock->ops->sendmsg(cmd->sock, &reply, sizeof(reply), 0);
if (ret < 0) {
ERR("Relay data header to viewer");
goto end_unlock;
}
+ health_code_update();
if (len > 0) {
ret = cmd->sock->ops->sendmsg(cmd->sock, data, len, 0);
*/
static
int process_control(struct lttng_viewer_cmd *recv_hdr,
- struct relay_command *cmd, struct lttng_ht *sessions_ht,
- struct lttng_ht *viewer_streams_ht)
+ struct relay_command *cmd, struct lttng_ht *sessions_ht)
{
int ret = 0;
ret = viewer_list_sessions(cmd, sessions_ht);
break;
case VIEWER_ATTACH_SESSION:
- ret = viewer_attach_session(cmd, sessions_ht,
- viewer_streams_ht);
+ ret = viewer_attach_session(cmd, sessions_ht);
break;
case VIEWER_GET_NEXT_INDEX:
- ret = viewer_get_next_index(cmd, viewer_streams_ht, sessions_ht);
+ ret = viewer_get_next_index(cmd, sessions_ht);
break;
case VIEWER_GET_PACKET:
- ret = viewer_get_packet(cmd, viewer_streams_ht);
+ ret = viewer_get_packet(cmd);
break;
case VIEWER_GET_METADATA:
- ret = viewer_get_metadata(cmd, viewer_streams_ht);
+ ret = viewer_get_metadata(cmd);
break;
default:
ERR("Received unknown viewer command (%u)", be32toh(recv_hdr->cmd));
}
do {
+ health_code_update();
ret = read(fd, relay_connection, sizeof(*relay_connection));
} while (ret < 0 && errno == EINTR);
if (ret < 0 || ret < sizeof(*relay_connection)) {
}
static
-void viewer_del_streams(struct lttng_ht *viewer_streams_ht,
- struct relay_session *session)
+void viewer_del_streams(uint64_t session_id)
{
int ret;
struct relay_viewer_stream *stream;
struct lttng_ht_node_u64 *node;
struct lttng_ht_iter iter;
- assert(viewer_streams_ht);
- assert(session);
-
rcu_read_lock();
cds_lfht_for_each_entry(viewer_streams_ht->ht, &iter.iter, node, node) {
+ health_code_update();
+
node = lttng_ht_iter_get_node_u64(&iter);
if (!node) {
continue;
}
stream = caa_container_of(node, struct relay_viewer_stream, stream_n);
- if (stream->session_id != session->id) {
+ if (stream->session_id != session_id) {
continue;
}
*/
static
void del_connection(struct lttng_ht *relay_connections_ht,
- struct lttng_ht_iter *iter, struct relay_command *relay_connection,
- struct lttng_ht *viewer_streams_ht)
+ struct lttng_ht_iter *iter, struct relay_command *relay_connection)
{
int ret;
assert(relay_connections_ht);
assert(iter);
assert(relay_connection);
- assert(viewer_streams_ht);
ret = lttng_ht_del(relay_connections_ht, iter);
assert(!ret);
- if (relay_connection->session) {
- viewer_del_streams(viewer_streams_ht, relay_connection->session);
- }
+ viewer_del_streams(relay_connection->session_id);
call_rcu(&relay_connection->rcu_node, deferred_free_connection);
}
struct lttng_viewer_cmd recv_hdr;
struct relay_local_data *relay_ctx = (struct relay_local_data *) data;
struct lttng_ht *sessions_ht = relay_ctx->sessions_ht;
- struct lttng_ht *viewer_streams_ht = relay_ctx->viewer_streams_ht;
DBG("[thread] Live viewer relay worker started");
rcu_register_thread();
+ health_register(health_relayd, HEALTH_RELAYD_TYPE_LIVE_WORKER);
+
/* table of connections indexed on socket */
relay_connections_ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
if (!relay_connections_ht) {
while (1) {
int i;
+ health_code_update();
+
/* Infinite blocking call, waiting for transmission */
DBG3("Relayd live viewer worker thread polling...");
+ health_poll_entry();
ret = lttng_poll_wait(&events, -1);
+ health_poll_exit();
if (ret < 0) {
/*
* Restart interrupted system call.
uint32_t revents = LTTNG_POLL_GETEV(&events, i);
int pollfd = LTTNG_POLL_GETFD(&events, i);
+ health_code_update();
+
/* Thread quit pipe has been closed. Killing thread. */
ret = check_thread_quit_pipe(pollfd, revents);
if (ret) {
sock_n);
if (revents & (LPOLLERR)) {
- ERR("VIEWER POLL ERROR");
cleanup_poll_connection(&events, pollfd);
del_connection(relay_connections_ht, &iter,
- relay_connection, viewer_streams_ht);
+ relay_connection);
} else if (revents & (LPOLLHUP | LPOLLRDHUP)) {
DBG("Viewer socket %d hung up", pollfd);
cleanup_poll_connection(&events, pollfd);
del_connection(relay_connections_ht, &iter,
- relay_connection, viewer_streams_ht);
+ relay_connection);
} else if (revents & LPOLLIN) {
ret = relay_connection->sock->ops->recvmsg(
relay_connection->sock, &recv_hdr,
if (ret <= 0) {
cleanup_poll_connection(&events, pollfd);
del_connection( relay_connections_ht, &iter,
- relay_connection, viewer_streams_ht);
+ relay_connection);
DBG("Viewer control connection closed with %d",
pollfd);
} else {
relay_connection->session->id);
}
ret = process_control(&recv_hdr, relay_connection,
- sessions_ht, viewer_streams_ht);
+ sessions_ht);
if (ret < 0) {
/* Clear the session on error. */
cleanup_poll_connection(&events, pollfd);
del_connection(relay_connections_ht, &iter,
- relay_connection, viewer_streams_ht);
+ relay_connection);
DBG("Viewer connection closed with %d", pollfd);
}
}
/* empty the hash table and free the memory */
rcu_read_lock();
cds_lfht_for_each_entry(relay_connections_ht->ht, &iter.iter, node, node) {
+ health_code_update();
+
node = lttng_ht_iter_get_node_ulong(&iter);
if (!node) {
continue;
relay_connection = caa_container_of(node, struct relay_command,
sock_n);
- del_connection(relay_connections_ht, &iter, relay_connection,
- viewer_streams_ht);
+ del_connection(relay_connections_ht, &iter, relay_connection);
}
rcu_read_unlock();
error_poll_create:
DBG("Viewer worker thread exited with error");
}
DBG("Viewer worker thread cleanup complete");
+ if (err) {
+ health_error();
+ ERR("Health error occurred in %s", __func__);
+ }
+ health_unregister(health_relayd);
stop_threads();
rcu_unregister_thread();
return NULL;
* main
*/
int live_start_threads(struct lttng_uri *uri,
- struct relay_local_data *relay_ctx)
+ struct relay_local_data *relay_ctx, int quit_pipe[2])
{
int ret = 0;
void *status;
assert(uri);
live_uri = uri;
- /* Create thread quit pipe */
- if ((ret = init_thread_quit_pipe()) < 0) {
- goto error;
- }
+ live_thread_quit_pipe[0] = quit_pipe[0];
+ live_thread_quit_pipe[1] = quit_pipe[1];
/* Check if daemon is UID = 0 */
is_root = !getuid();
projects / lttng-tools.git / blobdiff