#include "kernel-consumer.h"
#include "lttng-sessiond.h"
#include "utils.h"
-#include "syscall.h"
+#include "lttng-syscall.h"
#include "agent.h"
#include "buffer-registry.h"
#include "notification-thread.h"
#include "rotate.h"
#include "rotation-thread.h"
#include "sessiond-timer.h"
+#include "agent-thread.h"
#include "cmd.h"
*
* The consumer socket lock must be held by the caller.
*/
-static int send_consumer_relayd_socket(enum lttng_domain_type domain,
- unsigned int session_id, struct lttng_uri *relayd_uri,
+static int send_consumer_relayd_socket(unsigned int session_id,
+ struct lttng_uri *relayd_uri,
struct consumer_output *consumer,
struct consumer_socket *consumer_sock,
char *session_name, char *hostname, int session_live_timer)
/* Sending control relayd socket. */
if (!sock->control_sock_sent) {
- ret = send_consumer_relayd_socket(domain, session_id,
+ ret = send_consumer_relayd_socket(session_id,
&consumer->dst.net.control, consumer, sock,
session_name, hostname, session_live_timer);
if (ret != LTTNG_OK) {
/* Sending data relayd socket. */
if (!sock->data_sock_sent) {
- ret = send_consumer_relayd_socket(domain, session_id,
+ ret = send_consumer_relayd_socket(session_id,
&consumer->dst.net.data, consumer, sock,
session_name, hostname, session_live_timer);
if (ret != LTTNG_OK) {
}
/* Quiescent wait after starting trace */
- kernel_wait_quiescent(kernel_tracer_fd);
+ kernel_wait_quiescent(wpipe);
ksess->active = 1;
break;
}
case LTTNG_DOMAIN_UST:
+ break;
case LTTNG_DOMAIN_JUL:
case LTTNG_DOMAIN_LOG4J:
case LTTNG_DOMAIN_PYTHON:
+ if (!agent_tracing_is_enabled()) {
+ DBG("Attempted to enable a channel in an agent domain but the agent thread is not running");
+ ret = LTTNG_ERR_AGENT_TRACING_DISABLED;
+ goto error;
+ }
break;
default:
ret = LTTNG_ERR_UNKNOWN_DOMAIN;
assert(usess);
+ if (!agent_tracing_is_enabled()) {
+ DBG("Attempted to enable an event in an agent domain but the agent thread is not running");
+ ret = LTTNG_ERR_AGENT_TRACING_DISABLED;
+ goto error;
+ }
+
agt = trace_ust_find_agent(usess, domain->type);
if (!agt) {
agt = agent_create(domain->type);
{
int ret;
- session->rotate_count++;
+ session->current_archive_id++;
/*
* The currently active tracing path is now the folder we
goto end;
}
end:
- session->rotate_count--;
+ session->current_archive_id--;
return ret;
}
sessiond_rotate_timer_stop(session);
}
- if (session->rotate_count > 0 && !session->rotate_pending) {
+ if (session->current_archive_id > 0 && !session->rotate_pending) {
ret = rename_active_chunk(session);
if (ret) {
/*
int clear_metadata_file(int fd)
{
int ret;
+ off_t lseek_ret;
- ret = lseek(fd, 0, SEEK_SET);
- if (ret < 0) {
+ lseek_ret = lseek(fd, 0, SEEK_SET);
+ if (lseek_ret < 0) {
PERROR("lseek");
+ ret = -1;
goto end;
}
}
/* Special case for the first rotation. */
- if (session->rotate_count == 0) {
+ if (session->current_archive_id == 0) {
const char *base_path = NULL;
/* Either one of the two sessions is enough to get the root path. */
}
DBG("Current rotate path %s", session->rotation_chunk.current_rotate_path);
- session->rotate_count++;
+ session->current_archive_id++;
session->rotate_pending = true;
session->rotation_state = LTTNG_ROTATION_STATE_ONGOING;
sizeof(session->rotation_chunk.active_tracing_path),
"%s/%s-%" PRIu64,
session_get_base_path(session),
- datetime, session->rotate_count + 1);
+ datetime, session->current_archive_id + 1);
if (ret < 0 || ret == sizeof(session->rotation_chunk.active_tracing_path)) {
ERR("Failed to format active kernel tracing path in rotate session command");
ret = -LTTNG_ERR_UNK;
ret = snprintf(session->kernel_session->consumer->chunk_path,
sizeof(session->kernel_session->consumer->chunk_path),
"/%s-%" PRIu64, datetime,
- session->rotate_count + 1);
+ session->current_archive_id + 1);
if (ret < 0 || ret == sizeof(session->kernel_session->consumer->chunk_path)) {
ERR("Failed to format the kernel consumer's sub-directory in rotate session command");
ret = -LTTNG_ERR_UNK;
ret = snprintf(session->rotation_chunk.active_tracing_path,
PATH_MAX, "%s/%s-%" PRIu64,
session_get_base_path(session),
- datetime, session->rotate_count + 1);
+ datetime, session->current_archive_id + 1);
if (ret < 0) {
ERR("Failed to format active UST tracing path in rotate session command");
ret = -LTTNG_ERR_UNK;
}
ret = snprintf(session->ust_session->consumer->chunk_path,
PATH_MAX, "/%s-%" PRIu64, datetime,
- session->rotate_count + 1);
+ session->current_archive_id + 1);
if (ret < 0) {
ERR("Failed to format the UST consumer's sub-directory in rotate session command");
ret = -LTTNG_ERR_UNK;
}
if (rotate_return) {
- rotate_return->rotation_id = session->rotate_count;
+ rotate_return->rotation_id = session->current_archive_id;
}
- DBG("Cmd rotate session %s, rotate_id %" PRIu64 " sent", session->name,
- session->rotate_count);
+ DBG("Cmd rotate session %s, current_archive_id %" PRIu64 " sent",
+ session->name, session->current_archive_id);
ret = LTTNG_OK;
end:
assert(session);
DBG("Cmd rotate_get_info session %s, rotation id %" PRIu64, session->name,
- session->rotate_count);
+ session->current_archive_id);
- if (session->rotate_count != rotation_id) {
+ if (session->current_archive_id != rotation_id) {
info_return->status = (int32_t) LTTNG_ROTATION_STATE_EXPIRED;
ret = LTTNG_OK;
goto end;
rotation_id, session->name);
break;
case LTTNG_ROTATION_STATE_COMPLETED:
- ret = lttng_strncpy(info_return->path,
+ {
+ char *current_tracing_path_reply;
+ size_t current_tracing_path_reply_len;
+
+ switch (session_get_consumer_destination_type(session)) {
+ case CONSUMER_DST_LOCAL:
+ current_tracing_path_reply =
+ info_return->location.local.absolute_path;
+ current_tracing_path_reply_len =
+ sizeof(info_return->location.local.absolute_path);
+ info_return->location_type =
+ (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL;
+ break;
+ case CONSUMER_DST_NET:
+ current_tracing_path_reply =
+ info_return->location.relay.relative_path;
+ current_tracing_path_reply_len =
+ sizeof(info_return->location.relay.relative_path);
+ /* Currently the only supported relay protocol. */
+ info_return->location.relay.protocol =
+ (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_RELAY_PROTOCOL_TYPE_TCP;
+
+ ret = lttng_strncpy(info_return->location.relay.host,
+ session_get_net_consumer_hostname(session),
+ sizeof(info_return->location.relay.host));
+ if (ret) {
+ ERR("Failed to host name to rotate_get_info reply");
+ info_return->status = LTTNG_ROTATION_STATUS_ERROR;
+ ret = -LTTNG_ERR_UNK;
+ goto end;
+ }
+
+ session_get_net_consumer_ports(session,
+ &info_return->location.relay.ports.control,
+ &info_return->location.relay.ports.data);
+ info_return->location_type =
+ (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY;
+ break;
+ default:
+ abort();
+ }
+ ret = lttng_strncpy(current_tracing_path_reply,
session->rotation_chunk.current_rotate_path,
- sizeof(info_return->path));
+ current_tracing_path_reply_len);
if (ret) {
- ERR("Failed to copy active tracing path to rotate_get_info reply");
+ ERR("Failed to copy current tracing path to rotate_get_info reply");
info_return->status = LTTNG_ROTATION_STATUS_ERROR;
ret = -LTTNG_ERR_UNK;
goto end;
}
+
break;
+ }
case LTTNG_ROTATION_STATE_ERROR:
DBG("Reporting that an error occurred during rotation %" PRIu64 " of session %s",
rotation_id, session->name);
const char *path;
if (!session->snapshot_mode) {
- if (session->rotate_count == 0) {
+ if (session->current_archive_id == 0) {
if (session->kernel_session) {
path = session_get_base_path(session);
} else if (session->ust_session) {
projects / lttng-tools.git / blobdiff