* object reference is not needed anymore.
*/
struct consumer_socket *consumer_find_socket_by_bitness(int bits,
- struct consumer_output *consumer)
+ const struct consumer_output *consumer)
{
int consumer_fd;
struct consumer_socket *socket = NULL;
* returned consumer_socket.
*/
struct consumer_socket *consumer_find_socket(int key,
- struct consumer_output *consumer)
+ const struct consumer_output *consumer)
{
struct lttng_ht_iter iter;
struct lttng_ht_node_ulong *node;
}
/*
- * Delte consumer socket to consumer output object. Read side lock must be
+ * Delete consumer socket to consumer output object. Read side lock must be
* acquired before calling this function.
*/
void consumer_del_socket(struct consumer_socket *sock,
int64_t blocking_timeout,
const char *root_shm_path,
const char *shm_path,
- struct lttng_trace_chunk *trace_chunk)
+ struct lttng_trace_chunk *trace_chunk,
+ const struct lttng_credentials *buffer_credentials)
{
assert(msg);
msg->u.ask_channel.buffer_credentials.uid = UINT32_MAX;
msg->u.ask_channel.buffer_credentials.gid = UINT32_MAX;
- if (monitor) {
- assert(trace_chunk);
- }
-
if (trace_chunk) {
uint64_t chunk_id;
enum lttng_trace_chunk_status chunk_status;
- struct lttng_credentials chunk_credentials;
chunk_status = lttng_trace_chunk_get_id(trace_chunk, &chunk_id);
assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
LTTNG_OPTIONAL_SET(&msg->u.ask_channel.chunk_id, chunk_id);
-
- chunk_status = lttng_trace_chunk_get_credentials(trace_chunk,
- &chunk_credentials);
- assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
- msg->u.ask_channel.buffer_credentials.uid =
- chunk_credentials.uid;
- msg->u.ask_channel.buffer_credentials.gid =
- chunk_credentials.gid;
}
+ msg->u.ask_channel.buffer_credentials.uid = buffer_credentials->uid;
+ msg->u.ask_channel.buffer_credentials.gid = buffer_credentials->gid;
msg->cmd_type = LTTNG_CONSUMER_ASK_CHANNEL_CREATION;
msg->u.ask_channel.subbuf_size = subbuf_size;
struct lttcomm_relayd_sock *rsock, struct consumer_output *consumer,
enum lttng_stream_type type, uint64_t session_id,
const char *session_name, const char *hostname,
- int session_live_timer)
+ const char *base_path, int session_live_timer,
+ const uint64_t *current_chunk_id, time_t session_creation_time)
{
int ret;
struct lttcomm_consumer_msg msg;
if (type == LTTNG_STREAM_CONTROL) {
ret = relayd_create_session(rsock,
&msg.u.relayd_sock.relayd_session_id,
- session_name, hostname, session_live_timer,
+ session_name, hostname, base_path,
+ session_live_timer,
consumer->snapshot, session_id,
- sessiond_uuid);
+ sessiond_uuid, current_chunk_id,
+ session_creation_time);
if (ret < 0) {
/* Close the control socket. */
(void) relayd_close(rsock);
* Returns LTTNG_OK on success or else an LTTng error code.
*/
enum lttng_error_code consumer_snapshot_channel(struct consumer_socket *socket,
- uint64_t key, const struct snapshot_output *output, int metadata,
+ uint64_t key, const struct consumer_output *output, int metadata,
uid_t uid, gid_t gid, const char *channel_path, int wait,
uint64_t nb_packets_per_stream)
{
assert(socket);
assert(output);
- assert(output->consumer);
DBG("Consumer snapshot channel key %" PRIu64, key);
msg.u.snapshot_channel.nb_packets_per_stream = nb_packets_per_stream;
msg.u.snapshot_channel.metadata = metadata;
- if (output->consumer->type == CONSUMER_DST_NET) {
+ if (output->type == CONSUMER_DST_NET) {
msg.u.snapshot_channel.relayd_id =
- output->consumer->net_seq_index;
+ output->net_seq_index;
msg.u.snapshot_channel.use_relayd = 1;
} else {
msg.u.snapshot_channel.relayd_id = (uint64_t) -1ULL;
const struct lttng_directory_handle *chunk_directory_handle;
int chunk_dirfd;
const char *chunk_name;
- bool chunk_name_overriden;
+ bool chunk_name_overridden;
uint64_t chunk_id;
time_t creation_timestamp;
char creation_timestamp_buffer[ISO8601_STR_LEN];
}
chunk_status = lttng_trace_chunk_get_name(chunk, &chunk_name,
- &chunk_name_overriden);
+ &chunk_name_overridden);
if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK &&
chunk_status != LTTNG_TRACE_CHUNK_STATUS_NONE) {
ERR("Failed to get name of trace chunk");
ret = -LTTNG_ERR_FATAL;
goto error;
}
- if (chunk_name_overriden) {
+ if (chunk_name_overridden) {
ret = lttng_strncpy(msg.u.create_trace_chunk.override_name,
chunk_name,
sizeof(msg.u.create_trace_chunk.override_name));
goto error;
}
msg.u.create_trace_chunk.chunk_id = chunk_id;
- /* Only used for logging purposes. */
if (chunk_has_local_output) {
chunk_status = lttng_trace_chunk_get_chunk_directory_handle(
chunk_dirfd = lttng_directory_handle_get_dirfd(
chunk_directory_handle);
assert(chunk_dirfd >= 0);
- }
- chunk_status = lttng_trace_chunk_get_credentials(chunk,
- &chunk_credentials);
- if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
- /*
- * Not associating credentials to a sessiond chunk is a fatal
- * internal error.
- */
- ret = -LTTNG_ERR_FATAL;
- goto error;
+ chunk_status = lttng_trace_chunk_get_credentials(
+ chunk, &chunk_credentials);
+ if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
+ /*
+ * Not associating credentials to a sessiond chunk is a
+ * fatal internal error.
+ */
+ ret = -LTTNG_ERR_FATAL;
+ goto error;
+ }
+ msg.u.create_trace_chunk.credentials.value.uid =
+ chunk_credentials.uid;
+ msg.u.create_trace_chunk.credentials.value.gid =
+ chunk_credentials.gid;
+ msg.u.create_trace_chunk.credentials.is_set = 1;
}
- msg.u.create_trace_chunk.credentials.uid = chunk_credentials.uid;
- msg.u.create_trace_chunk.credentials.gid = chunk_credentials.gid;
DBG("Sending consumer create trace chunk command: relayd_id = %" PRId64
", session_id = %" PRIu64 ", chunk_id = %" PRIu64
int ret;
enum lttng_trace_chunk_status chunk_status;
struct lttcomm_consumer_msg msg = {
- .cmd_type = LTTNG_CONSUMER_CLOSE_TRACE_CHUNK,
- .u.close_trace_chunk.session_id = session_id,
+ .cmd_type = LTTNG_CONSUMER_CLOSE_TRACE_CHUNK,
+ .u.close_trace_chunk.session_id = session_id,
};
uint64_t chunk_id;
time_t close_timestamp;
+ enum lttng_trace_chunk_command_type close_command;
+ const char *close_command_name = "none";
assert(socket);
if (relayd_id != -1ULL) {
- LTTNG_OPTIONAL_SET(&msg.u.close_trace_chunk.relayd_id,
- relayd_id);
+ LTTNG_OPTIONAL_SET(
+ &msg.u.close_trace_chunk.relayd_id, relayd_id);
+ }
+
+ chunk_status = lttng_trace_chunk_get_close_command(
+ chunk, &close_command);
+ switch (chunk_status) {
+ case LTTNG_TRACE_CHUNK_STATUS_OK:
+ LTTNG_OPTIONAL_SET(&msg.u.close_trace_chunk.close_command,
+ (uint32_t) close_command);
+ break;
+ case LTTNG_TRACE_CHUNK_STATUS_NONE:
+ break;
+ default:
+ ERR("Failed to get trace chunk close command");
+ ret = -1;
+ goto error;
}
chunk_status = lttng_trace_chunk_get_id(chunk, &chunk_id);
assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
msg.u.close_trace_chunk.close_timestamp = (uint64_t) close_timestamp;
+ if (msg.u.close_trace_chunk.close_command.is_set) {
+ close_command_name = lttng_trace_chunk_command_type_get_name(
+ close_command);
+ }
DBG("Sending consumer close trace chunk command: relayd_id = %" PRId64
- ", session_id = %" PRIu64
- ", chunk_id = %" PRIu64,
- relayd_id, session_id, chunk_id);
+ ", session_id = %" PRIu64 ", chunk_id = %" PRIu64
+ ", close command = \"%s\"",
+ relayd_id, session_id, chunk_id, close_command_name);
health_code_update();
ret = consumer_send_msg(socket, &msg);
projects / lttng-tools.git / blobdiff