#include "timer.hpp"
#include "cmd.hpp"
+namespace {
struct ltt_session_destroy_notifier_element {
ltt_session_destroy_notifier notifier;
void *user_data;
* using session_lock() and session_unlock().
*/
+/* These characters are forbidden in a session name. Used by validate_name. */
+const char *forbidden_name_chars = "/";
+
+/* Global hash table to keep the sessions, indexed by id. */
+struct lttng_ht *ltt_sessions_ht_by_id = NULL;
+/* Global hash table to keep the sessions, indexed by name. */
+struct lttng_ht *ltt_sessions_ht_by_name = NULL;
+
/*
* Init tracing session list.
*
* Please see session.h for more explanation and correct usage of the list.
*/
-static struct ltt_session_list ltt_session_list = {
+struct ltt_session_list the_session_list = {
.lock = PTHREAD_MUTEX_INITIALIZER,
.removal_cond = PTHREAD_COND_INITIALIZER,
.next_uuid = 0,
- .head = CDS_LIST_HEAD_INIT(ltt_session_list.head),
+ .head = CDS_LIST_HEAD_INIT(the_session_list.head),
};
-
-/* These characters are forbidden in a session name. Used by validate_name. */
-static const char *forbidden_name_chars = "/";
-
-/* Global hash table to keep the sessions, indexed by id. */
-static struct lttng_ht *ltt_sessions_ht_by_id = NULL;
-/* Global hash table to keep the sessions, indexed by name. */
-static struct lttng_ht *ltt_sessions_ht_by_name = NULL;
+} /* namespace */
/*
* Validate the session name for forbidden characters.
{
LTTNG_ASSERT(ls);
- cds_list_add(&ls->list, <t_session_list.head);
- return ltt_session_list.next_uuid++;
+ cds_list_add(&ls->list, &the_session_list.head);
+ return the_session_list.next_uuid++;
}
/*
*/
struct ltt_session_list *session_get_list(void)
{
- return <t_session_list;
+ return &the_session_list;
}
/*
*/
void session_list_wait_empty(void)
{
- pthread_mutex_lock(<t_session_list.lock);
- while (!cds_list_empty(<t_session_list.head)) {
- pthread_cond_wait(<t_session_list.removal_cond,
- <t_session_list.lock);
+ pthread_mutex_lock(&the_session_list.lock);
+ while (!cds_list_empty(&the_session_list.head)) {
+ pthread_cond_wait(&the_session_list.removal_cond,
+ &the_session_list.lock);
}
- pthread_mutex_unlock(<t_session_list.lock);
+ pthread_mutex_unlock(&the_session_list.lock);
}
/*
*/
void session_lock_list(void)
{
- pthread_mutex_lock(<t_session_list.lock);
+ pthread_mutex_lock(&the_session_list.lock);
}
/*
*/
int session_trylock_list(void)
{
- return pthread_mutex_trylock(<t_session_list.lock);
+ return pthread_mutex_trylock(&the_session_list.lock);
}
/*
*/
void session_unlock_list(void)
{
- pthread_mutex_unlock(<t_session_list.lock);
+ pthread_mutex_unlock(&the_session_list.lock);
}
/*
/*
* Test if ltt_sessions_ht_by_id/name are empty.
- * Return 1 if empty, 0 if not empty.
+ * Return `false` if hash table objects are null.
* The session list lock must be held.
*/
-static int ltt_sessions_ht_empty(void)
+static bool ltt_sessions_ht_empty(void)
{
- unsigned long count;
+ bool empty = false;
if (!ltt_sessions_ht_by_id) {
- count = 0;
+ /* The hash tables do not exist yet. */
goto end;
}
LTTNG_ASSERT(ltt_sessions_ht_by_name);
- count = lttng_ht_get_count(ltt_sessions_ht_by_id);
- LTTNG_ASSERT(count == lttng_ht_get_count(ltt_sessions_ht_by_name));
+ if (lttng_ht_get_count(ltt_sessions_ht_by_id) != 0) {
+ /* Not empty.*/
+ goto end;
+ }
+
+ /*
+ * At this point it is expected that the `ltt_sessions_ht_by_name` ht is
+ * empty.
+ *
+ * The removal from both hash tables is done in two different
+ * places:
+ * - removal from `ltt_sessions_ht_by_name` is done during
+ * `session_destroy()`
+ * - removal from `ltt_sessions_ht_by_id` is done later
+ * in `session_release()` on the last reference put.
+ *
+ * This means that it is possible for `ltt_sessions_ht_by_name` to be
+ * empty but for `ltt_sessions_ht_by_id` to still contain objects when
+ * multiple sessions exists. The reverse is false, hence this sanity
+ * check.
+ */
+ LTTNG_ASSERT(lttng_ht_get_count(ltt_sessions_ht_by_name) == 0);
+ empty = true;
end:
- return count ? 0 : 1;
+ return empty;
}
/*
pthread_mutex_destroy(&session->lock);
if (session_published) {
- ASSERT_LOCKED(ltt_session_list.lock);
+ ASSERT_LOCKED(the_session_list.lock);
del_session_list(session);
del_session_ht(session);
}
* Broadcast after free-ing to ensure the memory is
* reclaimed before the main thread exits.
*/
- ASSERT_LOCKED(ltt_session_list.lock);
- pthread_cond_broadcast(<t_session_list.removal_cond);
+ ASSERT_LOCKED(the_session_list.lock);
+ pthread_cond_broadcast(&the_session_list.removal_cond);
}
}
* The session list lock must be held as any session_put()
* may cause the removal of the session from the session_list.
*/
- ASSERT_LOCKED(ltt_session_list.lock);
+ ASSERT_LOCKED(the_session_list.lock);
LTTNG_ASSERT(session->ref.refcount);
urcu_ref_put(&session->ref, session_release);
}
struct ltt_session *iter;
LTTNG_ASSERT(name);
- ASSERT_LOCKED(ltt_session_list.lock);
+ ASSERT_LOCKED(the_session_list.lock);
DBG2("Trying to find session by name %s", name);
- cds_list_for_each_entry(iter, <t_session_list.head, list) {
+ cds_list_for_each_entry(iter, &the_session_list.head, list) {
if (!strncmp(iter->name, name, NAME_MAX) &&
!iter->destroyed) {
goto found;
struct ltt_session *ls;
ASSERT_RCU_READ_LOCKED();
- ASSERT_LOCKED(ltt_session_list.lock);
+ ASSERT_LOCKED(the_session_list.lock);
if (!ltt_sessions_ht_by_id) {
goto end;
enum lttng_error_code ret_code;
struct ltt_session *new_session = NULL;
- ASSERT_LOCKED(ltt_session_list.lock);
+ ASSERT_LOCKED(the_session_list.lock);
if (name) {
struct ltt_session *clashing_session;
goto error;
}
}
- new_session = (ltt_session *) zmalloc(sizeof(struct ltt_session));
+ new_session = zmalloc<ltt_session>();
if (!new_session) {
PERROR("Failed to allocate an ltt_session structure");
ret_code = LTTNG_ERR_NOMEM;
{
int ret = 0;
- ASSERT_LOCKED(ltt_session_list.lock);
+ ASSERT_LOCKED(the_session_list.lock);
ASSERT_LOCKED(session->lock);
session->rotation_state = result;
projects / lttng-tools.git / blobdiff