/*
- * Copyright (C) 2013 - Julien Desfossez <jdesfossez@efficios.com>
- * David Goulet <dgoulet@efficios.com>
- * 2015 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ * Copyright (C) 2013 Julien Desfossez <jdesfossez@efficios.com>
+ * Copyright (C) 2013 David Goulet <dgoulet@efficios.com>
+ * Copyright (C) 2015 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
*
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License, version 2 only,
- * as published by the Free Software Foundation.
+ * SPDX-License-Identifier: GPL-2.0-only
*
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#define _LGPL_SOURCE
+#include <fcntl.h>
#include <getopt.h>
#include <grp.h>
+#include <inttypes.h>
#include <limits.h>
#include <pthread.h>
#include <signal.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
-#include <inttypes.h>
+#include <unistd.h>
#include <urcu/futex.h>
-#include <urcu/uatomic.h>
#include <urcu/rculist.h>
-#include <unistd.h>
-#include <fcntl.h>
+#include <urcu/uatomic.h>
-#include <lttng/lttng.h>
#include <common/common.h>
+#include <common/compat/endian.h>
#include <common/compat/poll.h>
#include <common/compat/socket.h>
-#include <common/compat/endian.h>
#include <common/defaults.h>
+#include <common/fd-tracker/utils.h>
+#include <common/fs-handle.h>
#include <common/futex.h>
#include <common/index/index.h>
-#include <common/sessiond-comm/sessiond-comm.h>
#include <common/sessiond-comm/inet.h>
#include <common/sessiond-comm/relayd.h>
+#include <common/sessiond-comm/sessiond-comm.h>
#include <common/uri.h>
#include <common/utils.h>
-#include <common/fd-tracker/utils.h>
+#include <lttng/lttng.h>
#include "cmd.h"
+#include "connection.h"
+#include "ctf-trace.h"
+#include "health-relayd.h"
#include "live.h"
#include "lttng-relayd.h"
-#include "utils.h"
-#include "health-relayd.h"
-#include "testpoint.h"
-#include "viewer-stream.h"
-#include "stream.h"
#include "session.h"
-#include "ctf-trace.h"
-#include "connection.h"
+#include "stream.h"
+#include "testpoint.h"
+#include "utils.h"
#include "viewer-session.h"
+#include "viewer-stream.h"
#define SESSION_BUF_DEFAULT_COUNT 16
uint64_t session_id, unsigned int ignore_sent_flag)
{
ssize_t ret;
- struct lttng_viewer_stream send_stream;
struct lttng_ht_iter iter;
struct relay_viewer_stream *vstream;
cds_lfht_for_each_entry(viewer_streams_ht->ht, &iter.iter, vstream,
stream_n.node) {
struct ctf_trace *ctf_trace;
+ struct lttng_viewer_stream send_stream = {};
health_code_update();
ret = fd_tracker_util_poll_create(the_fd_tracker,
name, events, 1, LTTNG_CLOEXEC);
+ if (ret) {
+ PERROR("Failed to create \"%s\" poll file descriptor", name);
+ goto error;
+ }
/* Add quit pipe */
ret = lttng_poll_add(events, thread_quit_pipe[0], LPOLLIN | LPOLLERR);
ret = fd_tracker_open_unsuspendable_fd(the_fd_tracker, &sock_fd,
(const char **) (formated_name ? &formated_name : NULL),
1, create_sock, sock);
- free(formated_name);
+ if (ret) {
+ PERROR("Failed to create \"%s\" socket",
+ formated_name ?: "Unknown");
+ goto error;
+ }
DBG("Listening on %s socket %d", name, sock->fd);
ret = sock->ops->bind(sock);
}
+ free(formated_name);
return sock;
error:
if (sock) {
lttcomm_destroy_sock(sock);
}
+ free(formated_name);
return NULL;
}
DBG("[thread] Relay live listener started");
+ rcu_register_thread();
health_register(health_relayd, HEALTH_RELAYD_TYPE_LIVE_LISTENER);
health_code_update();
DBG("Live viewer listener thread exited with error");
}
health_unregister(health_relayd);
+ rcu_unregister_thread();
DBG("Live viewer listener thread cleanup complete");
if (lttng_relay_stop_threads()) {
ERR("Error stopping threads");
goto send_reply;
}
- if (rstream->trace_chunk) {
- uint64_t rchunk_id, vchunk_id;
+ if (rstream->trace_chunk && !lttng_trace_chunk_ids_equal(
+ conn->viewer_session->current_trace_chunk,
+ rstream->trace_chunk)) {
+ DBG("Relay stream and viewer chunk ids differ");
- /*
- * If the relay stream is not yet closed, ensure the viewer
- * chunk matches the relay chunk after clear.
- */
- if (lttng_trace_chunk_get_id(rstream->trace_chunk,
- &rchunk_id) != LTTNG_TRACE_CHUNK_STATUS_OK) {
- viewer_index.status = htobe32(LTTNG_VIEWER_INDEX_ERR);
- goto send_reply;
- }
- if (lttng_trace_chunk_get_id(
- conn->viewer_session->current_trace_chunk,
- &vchunk_id) != LTTNG_TRACE_CHUNK_STATUS_OK) {
+ ret = viewer_session_set_trace_chunk_copy(
+ conn->viewer_session,
+ rstream->trace_chunk);
+ if (ret) {
viewer_index.status = htobe32(LTTNG_VIEWER_INDEX_ERR);
goto send_reply;
}
-
- if (rchunk_id != vchunk_id) {
- DBG("Relay and viewer chunk ids differ: "
- "rchunk_id %" PRIu64 " vchunk_id %" PRIu64,
- rchunk_id, vchunk_id);
-
- lttng_trace_chunk_put(
- conn->viewer_session->current_trace_chunk);
- conn->viewer_session->current_trace_chunk = NULL;
- ret = viewer_session_set_trace_chunk_copy(
- conn->viewer_session,
- rstream->trace_chunk);
- if (ret) {
- viewer_index.status =
- htobe32(LTTNG_VIEWER_INDEX_ERR);
- goto send_reply;
- }
- }
}
if (conn->viewer_session->current_trace_chunk !=
vstream->stream_file.trace_chunk) {
* overwrite caused by tracefile rotation (in association with
* unlink performed before overwrite).
*/
- if (!vstream->stream_file.fd) {
- int fd;
+ if (!vstream->stream_file.handle) {
char file_path[LTTNG_PATH_MAX];
enum lttng_trace_chunk_status status;
+ struct fs_handle *fs_handle;
ret = utils_stream_file_path(rstream->path_name,
rstream->channel_name, rstream->tracefile_size,
* missing if the stream has been closed (application exits with
* per-pid buffers) and a clear command has been performed.
*/
- status = lttng_trace_chunk_open_file(
+ status = lttng_trace_chunk_open_fs_handle(
vstream->stream_file.trace_chunk,
- file_path, O_RDONLY, 0, &fd, true);
+ file_path, O_RDONLY, 0, &fs_handle, true);
if (status != LTTNG_TRACE_CHUNK_STATUS_OK) {
if (status == LTTNG_TRACE_CHUNK_STATUS_NO_FILE &&
rstream->closed) {
PERROR("Failed to open trace file for viewer stream");
goto error_put;
}
- vstream->stream_file.fd = stream_fd_create(fd);
- if (!vstream->stream_file.fd) {
- if (close(fd)) {
- PERROR("Failed to close viewer stream file");
- }
- goto error_put;
- }
+ vstream->stream_file.handle = fs_handle;
}
ret = check_new_streams(conn);
ret = lttng_index_file_read(vstream->index_file, &packet_index);
if (ret) {
- ERR("Relay error reading index file %d",
- vstream->index_file->fd);
+ ERR("Relay error reading index file");
viewer_index.status = htobe32(LTTNG_VIEWER_INDEX_ERR);
goto send_reply;
} else {
uint32_t reply_size = sizeof(reply_header);
uint32_t packet_data_len = 0;
ssize_t read_len;
+ uint64_t stream_id;
DBG2("Relay get data packet");
/* From this point on, the error label can be reached. */
memset(&reply_header, 0, sizeof(reply_header));
+ stream_id = (uint64_t) be64toh(get_packet_info.stream_id);
- vstream = viewer_stream_get_by_id(be64toh(get_packet_info.stream_id));
+ vstream = viewer_stream_get_by_id(stream_id);
if (!vstream) {
DBG("Client requested packet of unknown stream id %" PRIu64,
- (uint64_t) be64toh(get_packet_info.stream_id));
+ stream_id);
reply_header.status = htobe32(LTTNG_VIEWER_GET_PACKET_ERR);
goto send_reply_nolock;
} else {
}
pthread_mutex_lock(&vstream->stream->lock);
- lseek_ret = lseek(vstream->stream_file.fd->fd,
+ lseek_ret = fs_handle_seek(vstream->stream_file.handle,
be64toh(get_packet_info.offset), SEEK_SET);
if (lseek_ret < 0) {
- PERROR("lseek fd %d to offset %" PRIu64,
- vstream->stream_file.fd->fd,
+ PERROR("Failed to seek file system handle of viewer stream %" PRIu64
+ " to offset %" PRIu64,
+ stream_id,
(uint64_t) be64toh(get_packet_info.offset));
goto error;
}
- read_len = lttng_read(vstream->stream_file.fd->fd,
+ read_len = fs_handle_read(vstream->stream_file.handle,
reply + sizeof(reply_header), packet_data_len);
if (read_len < packet_data_len) {
- PERROR("Relay reading trace file, fd: %d, offset: %" PRIu64,
- vstream->stream_file.fd->fd,
+ PERROR("Failed to read from file system handle of viewer stream id %" PRIu64
+ ", offset: %" PRIu64,
+ stream_id,
(uint64_t) be64toh(get_packet_info.offset));
goto error;
}
goto end_free;
}
- DBG("Sent %u bytes for stream %" PRIu64, reply_size,
- (uint64_t) be64toh(get_packet_info.stream_id));
+ DBG("Sent %u bytes for stream %" PRIu64, reply_size, stream_id);
end_free:
free(reply);
int viewer_get_metadata(struct relay_connection *conn)
{
int ret = 0;
+ int fd = -1;
ssize_t read_len;
uint64_t len = 0;
char *data = NULL;
goto send_reply;
}
+ if (vstream->stream->trace_chunk &&
+ !lttng_trace_chunk_ids_equal(
+ conn->viewer_session->current_trace_chunk,
+ vstream->stream->trace_chunk)) {
+ /* A rotation has occurred on the relay stream. */
+ DBG("Metadata relay stream and viewer chunk ids differ");
+
+ ret = viewer_session_set_trace_chunk_copy(
+ conn->viewer_session,
+ vstream->stream->trace_chunk);
+ if (ret) {
+ reply.status = htobe32(LTTNG_VIEWER_METADATA_ERR);
+ goto send_reply;
+ }
+ }
+
+ if (conn->viewer_session->current_trace_chunk !=
+ vstream->stream_file.trace_chunk) {
+ bool acquired_reference;
+
+ DBG("Viewer session and viewer stream chunk differ: "
+ "vsession chunk %p vstream chunk %p",
+ conn->viewer_session->current_trace_chunk,
+ vstream->stream_file.trace_chunk);
+ lttng_trace_chunk_put(vstream->stream_file.trace_chunk);
+ acquired_reference = lttng_trace_chunk_get(conn->viewer_session->current_trace_chunk);
+ assert(acquired_reference);
+ vstream->stream_file.trace_chunk =
+ conn->viewer_session->current_trace_chunk;
+ viewer_stream_close_files(vstream);
+ }
+
len = vstream->stream->metadata_received - vstream->metadata_sent;
- /* first time, we open the metadata file */
- if (!vstream->stream_file.fd) {
- int fd;
+ /*
+ * Either this is the first time the metadata file is read, or a
+ * rotation of the corresponding relay stream has occured.
+ */
+ if (!vstream->stream_file.handle && len > 0) {
+ struct fs_handle *fs_handle;
char file_path[LTTNG_PATH_MAX];
enum lttng_trace_chunk_status status;
struct relay_stream *rstream = vstream->stream;
* missing if the stream has been closed (application exits with
* per-pid buffers) and a clear command has been performed.
*/
- status = lttng_trace_chunk_open_file(
+ status = lttng_trace_chunk_open_fs_handle(
vstream->stream_file.trace_chunk,
- file_path, O_RDONLY, 0, &fd, true);
+ file_path, O_RDONLY, 0, &fs_handle, true);
if (status != LTTNG_TRACE_CHUNK_STATUS_OK) {
if (status == LTTNG_TRACE_CHUNK_STATUS_NO_FILE) {
reply.status = htobe32(LTTNG_VIEWER_NO_NEW_METADATA);
PERROR("Failed to open metadata file for viewer stream");
goto error;
}
- vstream->stream_file.fd = stream_fd_create(fd);
- if (!vstream->stream_file.fd) {
- if (close(fd)) {
- PERROR("Failed to close viewer metadata file");
+ vstream->stream_file.handle = fs_handle;
+
+ if (vstream->metadata_sent != 0) {
+ /*
+ * The client does not expect to receive any metadata
+ * it has received and metadata files in successive
+ * chunks must be a strict superset of one another.
+ *
+ * Skip the first `metadata_sent` bytes to ensure
+ * they are not sent a second time to the client.
+ *
+ * Baring a block layer error or an internal error,
+ * this seek should not fail as
+ * `vstream->stream->metadata_received` is reset when
+ * a relay stream is rotated. If this is reached, it is
+ * safe to assume that
+ * `metadata_received` > `metadata_sent`.
+ */
+ const off_t seek_ret = fs_handle_seek(fs_handle,
+ vstream->metadata_sent, SEEK_SET);
+
+ if (seek_ret < 0) {
+ PERROR("Failed to seek metadata viewer stream file to `sent` position: pos = %" PRId64,
+ vstream->metadata_sent);
+ reply.status = htobe32(LTTNG_VIEWER_METADATA_ERR);
+ goto send_reply;
}
- goto error;
}
}
goto error;
}
- read_len = lttng_read(vstream->stream_file.fd->fd, data, len);
- if (read_len < len) {
- PERROR("Relay reading metadata file");
+ fd = fs_handle_get_fd(vstream->stream_file.handle);
+ if (fd < 0) {
+ ERR("Failed to restore viewer stream file system handle");
goto error;
}
+ read_len = lttng_read(fd, data, len);
+ fs_handle_put_fd(vstream->stream_file.handle);
+ fd = -1;
+ if (read_len < len) {
+ if (read_len < 0) {
+ PERROR("Failed to read metadata file");
+ goto error;
+ } else {
+ /*
+ * A clear has been performed which prevents the relay
+ * from sending `len` bytes of metadata.
+ *
+ * It is important not to send any metadata if we
+ * couldn't read all the available metadata in one shot:
+ * sending partial metadata can cause the client to
+ * attempt to parse an incomplete (incoherent) metadata
+ * stream, which would result in an error.
+ */
+ const off_t seek_ret = fs_handle_seek(
+ vstream->stream_file.handle, -read_len,
+ SEEK_CUR);
+
+ DBG("Failed to read metadata: requested = %" PRIu64 ", got = %zd",
+ len, read_len);
+ read_len = 0;
+ len = 0;
+ if (seek_ret < 0) {
+ PERROR("Failed to restore metadata file position after partial read");
+ ret = -1;
+ goto error;
+ }
+ }
+ }
vstream->metadata_sent += read_len;
reply.status = htobe32(LTTNG_VIEWER_METADATA_OK);
projects / lttng-tools.git / blobdiff