X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fsession.c;h=dc6dea4439a6b77417863f0c1626ce89bfaf4490;hp=c3a65aafbfa6b44e327b32b165e155200afcdfbb;hb=3a5f70173aa04d11ccb22694d5d31a702cad33ab;hpb=04ed9e10dfa0b3c88d4a7abe9fa59b8e03b7e49a

diff --git a/src/bin/lttng-sessiond/session.c b/src/bin/lttng-sessiond/session.c
index c3a65aafb..dc6dea443 100644
--- a/src/bin/lttng-sessiond/session.c
+++ b/src/bin/lttng-sessiond/session.c
@@ -45,7 +45,7 @@ struct ltt_session_clear_notifier_element {
  * 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().
  */
@@ -67,6 +67,8 @@ 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;
 
 /*
  * Validate the session name for forbidden characters.
@@ -78,7 +80,7 @@ static int validate_name(const char *name)
 	int ret;
 	char *tok, *tmp_name;
 
-	assert(name);
+	LTTNG_ASSERT(name);
 
 	tmp_name = strdup(name);
 	if (!tmp_name) {
@@ -109,7 +111,7 @@ error:
  */
 static uint64_t add_session_list(struct ltt_session *ls)
 {
-	assert(ls);
+	LTTNG_ASSERT(ls);
 
 	cds_list_add(&ls->list, &ltt_session_list.head);
 	return ltt_session_list.next_uuid++;
@@ -122,7 +124,7 @@ static uint64_t add_session_list(struct ltt_session *ls)
  */
 static void del_session_list(struct ltt_session *ls)
 {
-	assert(ls);
+	LTTNG_ASSERT(ls);
 
 	cds_list_del(&ls->list);
 }
@@ -293,7 +295,7 @@ end:
 }
 
 /*
- * 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.
  */
@@ -308,6 +310,15 @@ static int ltt_sessions_ht_alloc(void)
 		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;
 }
@@ -319,23 +330,29 @@ end:
  */
 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;
 	}
-	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;
+	}
+
+	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();
@@ -344,35 +361,45 @@ static void add_session_ht(struct ltt_session *ls)
 			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)
@@ -380,15 +407,20 @@ 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();
 	}
 }
@@ -398,7 +430,7 @@ static void del_session_ht(struct ltt_session *ls)
  */
 void session_lock(struct ltt_session *session)
 {
-	assert(session);
+	LTTNG_ASSERT(session);
 
 	pthread_mutex_lock(&session->lock);
 }
@@ -408,7 +440,7 @@ void session_lock(struct ltt_session *session)
  */
 void session_unlock(struct ltt_session *session)
 {
-	assert(session);
+	LTTNG_ASSERT(session);
 
 	pthread_mutex_unlock(&session->lock);
 }
@@ -448,7 +480,7 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session,
 		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;
@@ -471,7 +503,7 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session,
 				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(
@@ -479,7 +511,7 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session,
 			if (ret_error_code != LTTNG_OK) {
 				goto error;
 			}
-                }
+		}
 		cds_lfht_for_each_entry(
 				session->ust_session->consumer->socks->ht,
 				&iter, socket, node.node) {
@@ -489,11 +521,11 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session,
 					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;
@@ -510,7 +542,7 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session,
 			if (ret_error_code != LTTNG_OK) {
 				goto error;
 			}
-                }
+		}
 		cds_lfht_for_each_entry(
 				session->kernel_session->consumer->socks->ht,
 				&iter, socket, node.node) {
@@ -520,11 +552,11 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session,
 					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
@@ -548,7 +580,7 @@ error:
 	if (session->kernel_session) {
 		session->kernel_session->current_trace_chunk = NULL;
 	}
-        /*
+	/*
 	 * Release references taken in the case where all references could not
 	 * be acquired.
 	 */
@@ -574,8 +606,8 @@ struct lttng_trace_chunk *session_create_new_trace_chunk(
 	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;
@@ -584,7 +616,7 @@ struct lttng_trace_chunk *session_create_new_trace_chunk(
 	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;
@@ -927,12 +959,12 @@ void session_release(struct urcu_ref *ref)
 	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;
 
-        /* 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. */
@@ -954,7 +986,7 @@ void session_release(struct urcu_ref *ref)
 	 * 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");
 	}
@@ -989,6 +1021,7 @@ void session_release(struct urcu_ref *ref)
 		 * Broadcast after free-ing to ensure the memory is
 		 * reclaimed before the main thread exits.
 		 */
+		ASSERT_LOCKED(ltt_session_list.lock);
 		pthread_cond_broadcast(&ltt_session_list.removal_cond);
 	}
 }
@@ -1015,7 +1048,7 @@ void session_put(struct ltt_session *session)
 	 * 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);
 }
 
@@ -1032,7 +1065,7 @@ void session_put(struct ltt_session *session)
  */
 void session_destroy(struct ltt_session *session)
 {
-	assert(!session->destroyed);
+	LTTNG_ASSERT(!session->destroyed);
 	session->destroyed = true;
 	session_put(session);
 }
@@ -1071,7 +1104,7 @@ struct ltt_session *session_find_by_name(const char *name)
 {
 	struct ltt_session *iter;
 
-	assert(name);
+	LTTNG_ASSERT(name);
 	ASSERT_LOCKED(ltt_session_list.lock);
 
 	DBG2("Trying to find session by name %s", name);
@@ -1296,18 +1329,13 @@ error:
 }
 
 /*
- * Check if the UID or GID match the session. Root user has access to all
+ * Check if the UID matches the session. Root user has access to all
  * sessions.
  */
-int session_access_ok(struct ltt_session *session, uid_t uid, gid_t gid)
+bool session_access_ok(struct ltt_session *session, uid_t uid)
 {
-	assert(session);
-
-	if (uid != session->uid && gid != session->gid && uid != 0) {
-		return 0;
-	} else {
-		return 1;
-	}
+	LTTNG_ASSERT(session);
+	return (uid == session->uid) || uid == 0;
 }
 
 /*
@@ -1344,7 +1372,7 @@ int session_reset_rotation_state(struct ltt_session *session,
 		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);
@@ -1357,3 +1385,43 @@ int session_reset_rotation_state(struct ltt_session *session,
 	}
 	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;
+}