/*
- * Copyright (C) 2012 - David Goulet <dgoulet@efficios.com>
+ * Copyright (C) 2012 David Goulet <dgoulet@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 <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
return false;
}
+static
+bool relayd_supports_get_configuration(const struct lttcomm_relayd_sock *sock)
+{
+ if (sock->major > 2) {
+ return true;
+ } else if (sock->major == 2 && sock->minor >= 12) {
+ return true;
+ }
+ return false;
+}
+
/*
* Send command. Fill up the header and append the data.
*/
/* The three names are sent with a '\0' delimiter between them. */
session_name_len = strlen(session_name) + 1;
hostname_len = strlen(hostname) + 1;
- base_path_len = base_path ? strlen(base_path) + 1 : 0;
+ base_path_len = strlen(base_path) + 1;
msg_length = sizeof(*msg) + session_name_len + hostname_len + base_path_len;
msg = zmalloc(msg_length);
goto error;
}
- assert(session_name_len <= UINT32_MAX);
+ LTTNG_ASSERT(session_name_len <= UINT32_MAX);
msg->session_name_len = htobe32(session_name_len);
- assert(hostname_len <= UINT32_MAX);
+ LTTNG_ASSERT(hostname_len <= UINT32_MAX);
msg->hostname_len = htobe32(hostname_len);
- assert(base_path_len <= UINT32_MAX);
+ LTTNG_ASSERT(base_path_len <= UINT32_MAX);
msg->base_path_len = htobe32(base_path_len);
dst = msg->names;
goto error;
}
dst += hostname_len;
- if (base_path && lttng_strncpy(dst, base_path, base_path_len)) {
+ if (lttng_strncpy(dst, base_path, base_path_len)) {
ret = -1;
goto error;
}
int ret;
struct lttcomm_relayd_create_session_reply_2_11 reply = {};
- assert(rsock);
- assert(relayd_session_id);
+ LTTNG_ASSERT(rsock);
+ LTTNG_ASSERT(relayd_session_id);
DBG("Relayd create session");
goto error;
}
- assert(channel_name_len <= UINT32_MAX);
+ LTTNG_ASSERT(channel_name_len <= UINT32_MAX);
msg->channel_name_len = htobe32(channel_name_len);
- assert(pathname_len <= UINT32_MAX);
+ LTTNG_ASSERT(pathname_len <= UINT32_MAX);
msg->pathname_len = htobe32(pathname_len);
if (lttng_strncpy(msg->names, channel_name, channel_name_len)) {
* On success return 0 else return ret_code negative value.
*/
int relayd_add_stream(struct lttcomm_relayd_sock *rsock, const char *channel_name,
- const char *pathname, uint64_t *stream_id,
+ const char *domain_name, const char *_pathname, uint64_t *stream_id,
uint64_t tracefile_size, uint64_t tracefile_count,
struct lttng_trace_chunk *trace_chunk)
{
int ret;
struct lttcomm_relayd_status_stream reply;
+ char pathname[RELAYD_COMM_LTTNG_PATH_MAX];
/* Code flow error. Safety net. */
- assert(rsock);
- assert(channel_name);
- assert(pathname);
- assert(trace_chunk);
+ LTTNG_ASSERT(rsock);
+ LTTNG_ASSERT(channel_name);
+ LTTNG_ASSERT(domain_name);
+ LTTNG_ASSERT(_pathname);
+ LTTNG_ASSERT(trace_chunk);
DBG("Relayd adding stream for channel name %s", channel_name);
/* Compat with relayd 2.1 */
if (rsock->minor == 1) {
/* For 2.1 */
- ret = relayd_add_stream_2_1(rsock, channel_name, pathname);
+ ret = relayd_add_stream_2_1(rsock, channel_name, _pathname);
} else if (rsock->minor > 1 && rsock->minor < 11) {
/* From 2.2 to 2.10 */
- ret = relayd_add_stream_2_2(rsock, channel_name, pathname,
+ ret = relayd_add_stream_2_2(rsock, channel_name, _pathname,
tracefile_size, tracefile_count);
} else {
+ const char *separator;
enum lttng_trace_chunk_status chunk_status;
uint64_t chunk_id;
+ if (_pathname[0] == '\0') {
+ separator = "";
+ } else {
+ separator = "/";
+ }
+
+ ret = snprintf(pathname, RELAYD_COMM_LTTNG_PATH_MAX, "%s%s%s",
+ domain_name, separator, _pathname);
+ if (ret <= 0 || ret >= RELAYD_COMM_LTTNG_PATH_MAX) {
+ ERR("Failed to format stream path: %s",
+ ret <= 0 ? "formatting error" :
+ "path exceeds maximal allowed length");
+ ret = -1;
+ goto error;
+ }
+
chunk_status = lttng_trace_chunk_get_id(trace_chunk,
&chunk_id);
- assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
+ LTTNG_ASSERT(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
/* From 2.11 to ...*/
ret = relayd_add_stream_2_11(rsock, channel_name, pathname,
struct lttcomm_relayd_generic_reply reply;
/* Code flow error. Safety net. */
- assert(rsock);
+ LTTNG_ASSERT(rsock);
DBG("Relayd sending streams sent.");
struct lttcomm_relayd_version msg;
/* Code flow error. Safety net. */
- assert(rsock);
+ LTTNG_ASSERT(rsock);
DBG("Relayd version check for major.minor %u.%u", rsock->major,
rsock->minor);
int ret;
/* Code flow error. Safety net. */
- assert(rsock);
+ LTTNG_ASSERT(rsock);
DBG("Relayd sending metadata of size %zu", len);
int relayd_connect(struct lttcomm_relayd_sock *rsock)
{
/* Code flow error. Safety net. */
- assert(rsock);
+ LTTNG_ASSERT(rsock);
if (!rsock->sock.ops) {
/*
int ret;
/* Code flow error. Safety net. */
- assert(rsock);
+ LTTNG_ASSERT(rsock);
/* An invalid fd is fine, return success. */
if (rsock->sock.fd < 0) {
int ret;
/* Code flow error. Safety net. */
- assert(rsock);
- assert(hdr);
+ LTTNG_ASSERT(rsock);
+ LTTNG_ASSERT(hdr);
if (rsock->sock.fd < 0) {
return -ECONNRESET;
struct lttcomm_relayd_generic_reply reply;
/* Code flow error. Safety net. */
- assert(rsock);
+ LTTNG_ASSERT(rsock);
DBG("Relayd closing stream id %" PRIu64, stream_id);
struct lttcomm_relayd_generic_reply reply;
/* Code flow error. Safety net. */
- assert(rsock);
+ LTTNG_ASSERT(rsock);
DBG("Relayd data pending for stream id %" PRIu64, stream_id);
struct lttcomm_relayd_generic_reply reply;
/* Code flow error. Safety net. */
- assert(rsock);
+ LTTNG_ASSERT(rsock);
DBG("Relayd checking quiescent control state");
struct lttcomm_relayd_generic_reply reply;
/* Code flow error. Safety net. */
- assert(rsock);
+ LTTNG_ASSERT(rsock);
DBG("Relayd begin data pending");
struct lttcomm_relayd_generic_reply reply;
/* Code flow error. Safety net. */
- assert(rsock);
+ LTTNG_ASSERT(rsock);
DBG("Relayd end data pending");
struct lttcomm_relayd_generic_reply reply;
/* Code flow error. Safety net. */
- assert(rsock);
+ LTTNG_ASSERT(rsock);
if (rsock->minor < 4) {
DBG("Not sending indexes before protocol 2.4");
struct lttcomm_relayd_generic_reply reply;
/* Code flow error. Safety net. */
- assert(rsock);
+ LTTNG_ASSERT(rsock);
/* Should have been prevented by the sessiond. */
if (rsock->minor < 8) {
lttng_dynamic_buffer_init(&payload);
/* Code flow error. Safety net. */
- assert(sock);
+ LTTNG_ASSERT(sock);
if (new_chunk_id) {
ret = snprintf(new_chunk_id_buf, sizeof(new_chunk_id_buf),
position->rotate_at_seq_num),
};
- DBG("Rotate stream %" PRIu64 "at sequence number %" PRIu64,
+ DBG("Rotate stream %" PRIu64 " at sequence number %" PRIu64,
position->stream_id,
position->rotate_at_seq_num);
ret = lttng_dynamic_buffer_append(&payload, &comm_position,
if (!relayd_supports_chunks(sock)) {
DBG("Refusing to check for trace chunk existence: relayd does not support chunks");
+ /* The chunk will never exist */
+ *chunk_exists = false;
goto end;
}
end:
return ret;
}
+
+int relayd_get_configuration(struct lttcomm_relayd_sock *sock,
+ uint64_t query_flags,
+ uint64_t *result_flags)
+{
+ int ret = 0;
+ struct lttcomm_relayd_get_configuration msg = (typeof(msg)) {
+ .query_flags = htobe64(query_flags),
+ };
+ struct lttcomm_relayd_get_configuration_reply reply = {};
+
+ if (!relayd_supports_get_configuration(sock)) {
+ DBG("Refusing to get relayd configuration (unsupported by relayd)");
+ if (query_flags) {
+ ret = -1;
+ goto end;
+ }
+ *result_flags = 0;
+ goto end;
+ }
+
+ ret = send_command(sock, RELAYD_GET_CONFIGURATION, &msg, sizeof(msg),
+ 0);
+ if (ret < 0) {
+ ERR("Failed to send get configuration command to relay daemon");
+ goto end;
+ }
+
+ ret = recv_reply(sock, &reply, sizeof(reply));
+ if (ret < 0) {
+ ERR("Failed to receive relay daemon get configuration command reply");
+ goto end;
+ }
+
+ reply.generic.ret_code = be32toh(reply.generic.ret_code);
+ if (reply.generic.ret_code != LTTNG_OK) {
+ ret = -1;
+ ERR("Relayd get configuration replied error %d",
+ reply.generic.ret_code);
+ } else {
+ reply.relayd_configuration_flags =
+ be64toh(reply.relayd_configuration_flags);
+ ret = 0;
+ DBG("Relayd successfully got configuration: query_flags = %" PRIu64
+ ", results_flags = %" PRIu64, query_flags,
+ reply.relayd_configuration_flags);
+ *result_flags = reply.relayd_configuration_flags;
+ }
+end:
+ return ret;
+}
projects / lttng-tools.git / blobdiff