* NOTES:
*
* No ltt_session.lock is taken here because those data structure are widely
- * spread across the lttng-tools code base so before caling functions below
+ * spread across the lttng-tools code base so before calling functions below
* that can read/write a session, the caller MUST acquire the session lock
* using session_lock() and session_unlock().
*/
/* 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;
/*
* Validate the session name for forbidden characters.
int ret;
char *tok, *tmp_name;
- assert(name);
+ LTTNG_ASSERT(name);
tmp_name = strdup(name);
if (!tmp_name) {
*/
static uint64_t add_session_list(struct ltt_session *ls)
{
- assert(ls);
+ LTTNG_ASSERT(ls);
cds_list_add(&ls->list, <t_session_list.head);
return ltt_session_list.next_uuid++;
*/
static void del_session_list(struct ltt_session *ls)
{
- assert(ls);
+ LTTNG_ASSERT(ls);
cds_list_del(&ls->list);
}
}
/*
- * Allocate the ltt_sessions_ht_by_id HT.
+ * Allocate the ltt_sessions_ht_by_id and ltt_sessions_ht_by_name HT.
*
* The session list lock must be held.
*/
ERR("Failed to allocate ltt_sessions_ht_by_id");
goto end;
}
+
+ DBG("Allocating ltt_sessions_ht_by_name");
+ ltt_sessions_ht_by_name = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
+ if (!ltt_sessions_ht_by_name) {
+ ret = -1;
+ ERR("Failed to allocate ltt_sessions_ht_by_name");
+ goto end;
+ }
+
end:
return ret;
}
*/
static void ltt_sessions_ht_destroy(void)
{
- if (!ltt_sessions_ht_by_id) {
- return;
+ if (ltt_sessions_ht_by_id) {
+ ht_cleanup_push(ltt_sessions_ht_by_id);
+ ltt_sessions_ht_by_id = NULL;
+ }
+
+ if (ltt_sessions_ht_by_name) {
+ ht_cleanup_push(ltt_sessions_ht_by_name);
+ ltt_sessions_ht_by_name = NULL;
}
- ht_cleanup_push(ltt_sessions_ht_by_id);
- ltt_sessions_ht_by_id = NULL;
+
+ return;
}
/*
- * Add a ltt_session to the ltt_sessions_ht_by_id.
- * If unallocated, the ltt_sessions_ht_by_id HT is allocated.
- * The session list lock must be held.
+ * Add a ltt_session to the ltt_sessions_ht_by_id and ltt_sessions_ht_by_name.
+ * If unallocated, the ltt_sessions_ht_by_id and ltt_sessions_ht_by_name. HTs
+ * are allocated. The session list lock must be held.
*/
static void add_session_ht(struct ltt_session *ls)
{
int ret;
- assert(ls);
+ LTTNG_ASSERT(ls);
if (!ltt_sessions_ht_by_id) {
ret = ltt_sessions_ht_alloc();
goto end;
}
}
+
+ /* Should always be present with ltt_sessions_ht_by_id. */
+ LTTNG_ASSERT(ltt_sessions_ht_by_name);
+
lttng_ht_node_init_u64(&ls->node, ls->id);
lttng_ht_add_unique_u64(ltt_sessions_ht_by_id, &ls->node);
+ lttng_ht_node_init_str(&ls->node_by_name, ls->name);
+ lttng_ht_add_unique_str(ltt_sessions_ht_by_name, &ls->node_by_name);
+
end:
return;
}
/*
- * Test if ltt_sessions_ht_by_id is empty.
+ * Test if ltt_sessions_ht_by_id/name are empty.
* Return 1 if empty, 0 if not empty.
* The session list lock must be held.
*/
static int ltt_sessions_ht_empty(void)
{
- int ret;
+ unsigned long count;
if (!ltt_sessions_ht_by_id) {
- ret = 1;
+ count = 0;
goto end;
}
- ret = lttng_ht_get_count(ltt_sessions_ht_by_id) ? 0 : 1;
+ 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));
end:
- return ret;
+ return count ? 0 : 1;
}
/*
- * Remove a ltt_session from the ltt_sessions_ht_by_id.
- * If empty, the ltt_sessions_ht_by_id HT is freed.
+ * Remove a ltt_session from the ltt_sessions_ht_by_id/name.
+ * If empty, the ltt_sessions_ht_by_id/name HTs are freed.
* The session list lock must be held.
*/
static void del_session_ht(struct ltt_session *ls)
struct lttng_ht_iter iter;
int ret;
- assert(ls);
- assert(ltt_sessions_ht_by_id);
+ LTTNG_ASSERT(ls);
+ LTTNG_ASSERT(ltt_sessions_ht_by_id);
+ LTTNG_ASSERT(ltt_sessions_ht_by_name);
iter.iter.node = &ls->node.node;
ret = lttng_ht_del(ltt_sessions_ht_by_id, &iter);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
+
+ iter.iter.node = &ls->node_by_name.node;
+ ret = lttng_ht_del(ltt_sessions_ht_by_name, &iter);
+ LTTNG_ASSERT(!ret);
if (ltt_sessions_ht_empty()) {
- DBG("Empty ltt_sessions_ht_by_id, destroying it");
+ DBG("Empty ltt_sessions_ht_by_id/name, destroying hast tables");
ltt_sessions_ht_destroy();
}
}
*/
void session_lock(struct ltt_session *session)
{
- assert(session);
+ LTTNG_ASSERT(session);
pthread_mutex_lock(&session->lock);
}
*/
void session_unlock(struct ltt_session *session)
{
- assert(session);
+ LTTNG_ASSERT(session);
pthread_mutex_unlock(&session->lock);
}
goto end;
}
chunk_status = lttng_trace_chunk_get_id(new_trace_chunk, &chunk_id);
- assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
+ LTTNG_ASSERT(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
refs_to_acquire = 1;
refs_to_acquire += !!session->ust_session;
const char *base_path;
struct lttng_directory_handle *session_output_directory = NULL;
const struct lttng_credentials session_credentials = {
- .uid = session->uid,
- .gid = session->gid,
+ .uid = LTTNG_OPTIONAL_INIT_VALUE(session->uid),
+ .gid = LTTNG_OPTIONAL_INIT_VALUE(session->gid),
};
uint64_t next_chunk_id;
const struct consumer_output *output;
if (consumer_output_override) {
output = consumer_output_override;
} else {
- assert(session->ust_session || session->kernel_session);
+ LTTNG_ASSERT(session->ust_session || session->kernel_session);
output = session->ust_session ?
session->ust_session->consumer :
session->kernel_session->consumer;
struct ltt_session *session = container_of(ref, typeof(*session), ref);
const bool session_published = session->published;
- assert(!session->chunk_being_archived);
+ LTTNG_ASSERT(!session->chunk_being_archived);
usess = session->ust_session;
ksess = session->kernel_session;
* Must notify the kernel thread here to update it's poll set in order to
* remove the channel(s)' fd just destroyed.
*/
- ret = notify_thread_pipe(kernel_poll_pipe[1]);
+ ret = notify_thread_pipe(the_kernel_poll_pipe[1]);
if (ret < 0) {
PERROR("write kernel poll pipe");
}
* 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);
}
}
* may cause the removal of the session from the session_list.
*/
ASSERT_LOCKED(ltt_session_list.lock);
- assert(session->ref.refcount);
+ LTTNG_ASSERT(session->ref.refcount);
urcu_ref_put(&session->ref, session_release);
}
*/
void session_destroy(struct ltt_session *session)
{
- assert(!session->destroyed);
+ LTTNG_ASSERT(!session->destroyed);
session->destroyed = true;
session_put(session);
}
{
struct ltt_session *iter;
- assert(name);
+ LTTNG_ASSERT(name);
ASSERT_LOCKED(ltt_session_list.lock);
DBG2("Trying to find session by name %s", name);
*/
bool session_access_ok(struct ltt_session *session, uid_t uid)
{
- assert(session);
+ LTTNG_ASSERT(session);
return (uid == session->uid) || uid == 0;
}
chunk_status = lttng_trace_chunk_get_id(
session->chunk_being_archived,
&chunk_id);
- assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
+ LTTNG_ASSERT(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
LTTNG_OPTIONAL_SET(&session->last_archived_chunk_id,
chunk_id);
lttng_trace_chunk_put(session->chunk_being_archived);
}
return ret;
}
+
+/*
+ * Sample the id of a session looked up via its name.
+ * Here the term "sampling" hint the caller that this return the id at a given
+ * point in time with no guarantee that the session for which the id was
+ * sampled still exist at that point.
+ *
+ * Return 0 when the session is not found,
+ * Return 1 when the session is found and set `id`.
+ */
+bool sample_session_id_by_name(const char *name, uint64_t *id)
+{
+ bool found = false;
+ struct lttng_ht_node_str *node;
+ struct lttng_ht_iter iter;
+ struct ltt_session *ls;
+
+ rcu_read_lock();
+
+ if (!ltt_sessions_ht_by_name) {
+ found = false;
+ goto end;
+ }
+
+ lttng_ht_lookup(ltt_sessions_ht_by_name, name, &iter);
+ node = lttng_ht_iter_get_node_str(&iter);
+ if (node == NULL) {
+ found = false;
+ goto end;
+ }
+
+ ls = caa_container_of(node, struct ltt_session, node_by_name);
+ *id = ls->id;
+ found = true;
+
+ DBG3("Session id `%" PRIu64 "` sampled for session `%s", *id, name);
+end:
+ rcu_read_unlock();
+ return found;
+}