/*
- * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
+ * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
*
- * 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
void *user_data;
};
+struct ltt_session_clear_notifier_element {
+ ltt_session_clear_notifier notifier;
+ void *user_data;
+};
+
/*
* NOTES:
*
CONSUMER_DST_LOCAL;
session->ust_session->current_trace_chunk = new_trace_chunk;
- if (is_local_trace) {
+ if (is_local_trace) {
enum lttng_error_code ret_error_code;
ret_error_code = ust_app_create_channel_subdirectories(
if (ret_error_code != LTTNG_OK) {
goto error;
}
- }
+ }
cds_lfht_for_each_entry(
session->ust_session->consumer->socks->ht,
&iter, socket, node.node) {
session->id, new_trace_chunk,
DEFAULT_UST_TRACE_DIR);
pthread_mutex_unlock(socket->lock);
- if (ret) {
+ if (ret) {
goto error;
- }
- }
- }
+ }
+ }
+ }
if (session->kernel_session) {
const uint64_t relayd_id =
session->kernel_session->consumer->net_seq_index;
if (ret_error_code != LTTNG_OK) {
goto error;
}
- }
+ }
cds_lfht_for_each_entry(
session->kernel_session->consumer->socks->ht,
&iter, socket, node.node) {
session->id, new_trace_chunk,
DEFAULT_KERNEL_TRACE_DIR);
pthread_mutex_unlock(socket->lock);
- if (ret) {
+ if (ret) {
goto error;
- }
- }
- }
+ }
+ }
+ }
/*
* Update local current trace chunk state last, only if all remote
if (session->kernel_session) {
session->kernel_session->current_trace_chunk = NULL;
}
- /*
+ /*
* Release references taken in the case where all references could not
* be acquired.
*/
};
uint64_t next_chunk_id;
const struct consumer_output *output;
+ const char *new_path;
if (consumer_output_override) {
output = consumer_output_override;
next_chunk_id = session->most_recent_chunk_id.is_set ?
session->most_recent_chunk_id.value + 1 : 0;
+ if (session->current_trace_chunk &&
+ !lttng_trace_chunk_get_name_overridden(session->current_trace_chunk)) {
+ chunk_status = lttng_trace_chunk_rename_path(session->current_trace_chunk,
+ DEFAULT_CHUNK_TMP_OLD_DIRECTORY);
+ if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
+ goto error;
+ }
+ }
+ if (!session->current_trace_chunk) {
+ if (!session->rotated) {
+ new_path = "";
+ } else {
+ new_path = NULL;
+ }
+ } else {
+ new_path = DEFAULT_CHUNK_TMP_NEW_DIRECTORY;
+ }
+
trace_chunk = lttng_trace_chunk_create(next_chunk_id,
- chunk_creation_ts);
+ chunk_creation_ts, new_path);
if (!trace_chunk) {
goto error;
}
struct consumer_socket *socket;
enum lttng_trace_chunk_status chunk_status;
const time_t chunk_close_timestamp = time(NULL);
+ const char *new_path;
chunk_status = lttng_trace_chunk_set_close_command(
trace_chunk, close_command);
ret = -1;
goto end;
}
+
+ if (close_command == LTTNG_TRACE_CHUNK_COMMAND_TYPE_DELETE && !session->rotated) {
+ /* New chunk stays in session output directory. */
+ new_path = "";
+ } else {
+ /* Use chunk name for new chunk. */
+ new_path = NULL;
+ }
+ if (session->current_trace_chunk &&
+ !lttng_trace_chunk_get_name_overridden(session->current_trace_chunk)) {
+ /* Rename new chunk path. */
+ chunk_status = lttng_trace_chunk_rename_path(session->current_trace_chunk,
+ new_path);
+ if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
+ ret = -1;
+ goto end;
+ }
+ }
+ if (!lttng_trace_chunk_get_name_overridden(trace_chunk) &&
+ close_command == LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION) {
+ const char *old_path;
+
+ if (!session->rotated) {
+ old_path = "";
+ } else {
+ old_path = NULL;
+ }
+ /* We need to move back the .tmp_old_chunk to its rightful place. */
+ chunk_status = lttng_trace_chunk_rename_path(trace_chunk,
+ old_path);
+ if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
+ ret = -1;
+ goto end;
+ }
+ }
+ if (close_command == LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED) {
+ session->rotated = true;
+ }
chunk_status = lttng_trace_chunk_set_close_timestamp(trace_chunk,
chunk_close_timestamp);
if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
return ret;
}
+/*
+ * This function skips the metadata channel as the begin/end timestamps of a
+ * metadata packet are useless.
+ *
+ * Moreover, opening a packet after a "clear" will cause problems for live
+ * sessions as it will introduce padding that was not part of the first trace
+ * chunk. The relay daemon expects the content of the metadata stream of
+ * successive metadata trace chunks to be strict supersets of one another.
+ *
+ * For example, flushing a packet at the beginning of the metadata stream of
+ * a trace chunk resulting from a "clear" session command will cause the
+ * size of the metadata stream of the new trace chunk to not match the size of
+ * the metadata stream of the original chunk. This will confuse the relay
+ * daemon as the same "offset" in a metadata stream will no longer point
+ * to the same content.
+ */
+static
+enum lttng_error_code session_kernel_open_packets(struct ltt_session *session)
+{
+ enum lttng_error_code ret = LTTNG_OK;
+ struct consumer_socket *socket;
+ struct lttng_ht_iter iter;
+ struct cds_lfht_node *node;
+ struct ltt_kernel_channel *chan;
+
+ rcu_read_lock();
+
+ cds_lfht_first(session->kernel_session->consumer->socks->ht, &iter.iter);
+ node = cds_lfht_iter_get_node(&iter.iter);
+ socket = container_of(node, typeof(*socket), node.node);
+
+ cds_list_for_each_entry(chan,
+ &session->kernel_session->channel_list.head, list) {
+ int open_ret;
+
+ DBG("Open packet of kernel channel: channel key = %" PRIu64
+ ", session name = %s, session_id = %" PRIu64,
+ chan->key, session->name, session->id);
+
+ open_ret = consumer_open_channel_packets(socket, chan->key);
+ if (open_ret < 0) {
+ /* General error (no known error expected). */
+ ret = LTTNG_ERR_UNK;
+ goto end;
+ }
+ }
+
+end:
+ rcu_read_unlock();
+ return ret;
+}
+
+enum lttng_error_code session_open_packets(struct ltt_session *session)
+{
+ enum lttng_error_code ret = LTTNG_OK;
+
+ DBG("Opening packets of session channels: session name = %s, session id = %" PRIu64,
+ session->name, session->id);
+
+ if (session->ust_session) {
+ ret = ust_app_open_packets(session);
+ if (ret != LTTNG_OK) {
+ goto end;
+ }
+ }
+
+ if (session->kernel_session) {
+ ret = session_kernel_open_packets(session);
+ if (ret != LTTNG_OK) {
+ goto end;
+ }
+ }
+
+end:
+ return ret;
+}
+
/*
* Set a session's current trace chunk.
*
}
}
+/*
+ * Fire each clear notifier once, and remove them from the array.
+ */
+void session_notify_clear(struct ltt_session *session)
+{
+ size_t i;
+ const size_t count = lttng_dynamic_array_get_count(
+ &session->clear_notifiers);
+
+ for (i = 0; i < count; i++) {
+ const struct ltt_session_clear_notifier_element *element =
+ lttng_dynamic_array_get_element(
+ &session->clear_notifiers, i);
+
+ element->notifier(session, element->user_data);
+ }
+ lttng_dynamic_array_clear(&session->clear_notifiers);
+}
+
static
void session_release(struct urcu_ref *ref)
{
usess = session->ust_session;
ksess = session->kernel_session;
- /* Clean kernel session teardown, keeping data for destroy notifier. */
+ /* Clean kernel session teardown, keeping data for destroy notifier. */
kernel_destroy_session(ksess);
/* UST session teardown, keeping data for destroy notifier. */
session->ust_session = NULL;
}
lttng_dynamic_array_reset(&session->destroy_notifiers);
+ lttng_dynamic_array_reset(&session->clear_notifiers);
free(session->last_archived_chunk_name);
free(session->base_path);
free(session);
&element);
}
+int session_add_clear_notifier(struct ltt_session *session,
+ ltt_session_clear_notifier notifier, void *user_data)
+{
+ const struct ltt_session_clear_notifier_element element = {
+ .notifier = notifier,
+ .user_data = user_data
+ };
+
+ return lttng_dynamic_array_add_element(&session->clear_notifiers,
+ &element);
+}
+
/*
* Return a ltt_session structure ptr that matches name. If no session found,
* NULL is returned. This must be called with the session list lock held using
lttng_dynamic_array_init(&new_session->destroy_notifiers,
sizeof(struct ltt_session_destroy_notifier_element),
NULL);
+ lttng_dynamic_array_init(&new_session->clear_notifiers,
+ sizeof(struct ltt_session_clear_notifier_element),
+ NULL);
urcu_ref_init(&new_session->ref);
pthread_mutex_init(&new_session->lock, NULL);
chunk_id);
lttng_trace_chunk_put(session->chunk_being_archived);
session->chunk_being_archived = NULL;
+ /*
+ * Fire the clear reply notifiers if we are completing a clear
+ * rotation.
+ */
+ session_notify_clear(session);
}
return ret;
}
projects / lttng-tools.git / blobdiff