2 * Copyright (C) 2011 EfficiOS Inc.
4 * SPDX-License-Identifier: GPL-2.0-only
17 #include <sys/types.h>
20 #include <common/common.h>
21 #include <common/utils.h>
22 #include <common/trace-chunk.h>
23 #include <common/sessiond-comm/sessiond-comm.h>
24 #include <lttng/location-internal.h>
25 #include "lttng-sessiond.h"
30 #include "trace-ust.h"
34 struct ltt_session_destroy_notifier_element
{
35 ltt_session_destroy_notifier notifier
;
39 struct ltt_session_clear_notifier_element
{
40 ltt_session_clear_notifier notifier
;
47 * No ltt_session.lock is taken here because those data structure are widely
48 * spread across the lttng-tools code base so before calling functions below
49 * that can read/write a session, the caller MUST acquire the session lock
50 * using session_lock() and session_unlock().
54 * Init tracing session list.
56 * Please see session.h for more explanation and correct usage of the list.
58 static struct ltt_session_list ltt_session_list
= {
59 .lock
= PTHREAD_MUTEX_INITIALIZER
,
60 .removal_cond
= PTHREAD_COND_INITIALIZER
,
62 .head
= CDS_LIST_HEAD_INIT(ltt_session_list
.head
),
65 /* These characters are forbidden in a session name. Used by validate_name. */
66 static const char *forbidden_name_chars
= "/";
68 /* Global hash table to keep the sessions, indexed by id. */
69 static struct lttng_ht
*ltt_sessions_ht_by_id
= NULL
;
70 /* Global hash table to keep the sessions, indexed by name. */
71 static struct lttng_ht
*ltt_sessions_ht_by_name
= NULL
;
74 * Validate the session name for forbidden characters.
76 * Return 0 on success else -1 meaning a forbidden char. has been found.
78 static int validate_name(const char *name
)
85 tmp_name
= strdup(name
);
92 tok
= strpbrk(tmp_name
, forbidden_name_chars
);
94 DBG("Session name %s contains a forbidden character", name
);
95 /* Forbidden character has been found. */
107 * Add a ltt_session structure to the global list.
109 * The caller MUST acquire the session list lock before.
110 * Returns the unique identifier for the session.
112 static uint64_t add_session_list(struct ltt_session
*ls
)
116 cds_list_add(&ls
->list
, <t_session_list
.head
);
117 return ltt_session_list
.next_uuid
++;
121 * Delete a ltt_session structure to the global list.
123 * The caller MUST acquire the session list lock before.
125 static void del_session_list(struct ltt_session
*ls
)
129 cds_list_del(&ls
->list
);
133 * Return a pointer to the session list.
135 struct ltt_session_list
*session_get_list(void)
137 return <t_session_list
;
141 * Returns once the session list is empty.
143 void session_list_wait_empty(void)
145 pthread_mutex_lock(<t_session_list
.lock
);
146 while (!cds_list_empty(<t_session_list
.head
)) {
147 pthread_cond_wait(<t_session_list
.removal_cond
,
148 <t_session_list
.lock
);
150 pthread_mutex_unlock(<t_session_list
.lock
);
154 * Acquire session list lock
156 void session_lock_list(void)
158 pthread_mutex_lock(<t_session_list
.lock
);
162 * Try to acquire session list lock
164 int session_trylock_list(void)
166 return pthread_mutex_trylock(<t_session_list
.lock
);
170 * Release session list lock
172 void session_unlock_list(void)
174 pthread_mutex_unlock(<t_session_list
.lock
);
178 * Get the session's consumer destination type.
180 * The caller must hold the session lock.
182 enum consumer_dst_type
session_get_consumer_destination_type(
183 const struct ltt_session
*session
)
186 * The output information is duplicated in both of those session types.
187 * Hence, it doesn't matter from which it is retrieved. However, it is
188 * possible for only one of them to be set.
190 return session
->kernel_session
?
191 session
->kernel_session
->consumer
->type
:
192 session
->ust_session
->consumer
->type
;
196 * Get the session's consumer network hostname.
197 * The caller must ensure that the destination is of type "net".
199 * The caller must hold the session lock.
201 const char *session_get_net_consumer_hostname(const struct ltt_session
*session
)
203 const char *hostname
= NULL
;
204 const struct consumer_output
*output
;
206 output
= session
->kernel_session
?
207 session
->kernel_session
->consumer
:
208 session
->ust_session
->consumer
;
211 * hostname is assumed to be the same for both control and data
214 switch (output
->dst
.net
.control
.dtype
) {
216 hostname
= output
->dst
.net
.control
.dst
.ipv4
;
219 hostname
= output
->dst
.net
.control
.dst
.ipv6
;
228 * Get the session's consumer network control and data ports.
229 * The caller must ensure that the destination is of type "net".
231 * The caller must hold the session lock.
233 void session_get_net_consumer_ports(const struct ltt_session
*session
,
234 uint16_t *control_port
, uint16_t *data_port
)
236 const struct consumer_output
*output
;
238 output
= session
->kernel_session
?
239 session
->kernel_session
->consumer
:
240 session
->ust_session
->consumer
;
241 *control_port
= output
->dst
.net
.control
.port
;
242 *data_port
= output
->dst
.net
.data
.port
;
246 * Get the location of the latest trace archive produced by a rotation.
248 * The caller must hold the session lock.
250 struct lttng_trace_archive_location
*session_get_trace_archive_location(
251 const struct ltt_session
*session
)
254 struct lttng_trace_archive_location
*location
= NULL
;
255 char *chunk_path
= NULL
;
257 if (session
->rotation_state
!= LTTNG_ROTATION_STATE_COMPLETED
||
258 !session
->last_archived_chunk_name
) {
262 switch (session_get_consumer_destination_type(session
)) {
263 case CONSUMER_DST_LOCAL
:
264 ret
= asprintf(&chunk_path
,
265 "%s/" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY
"/%s",
266 session_get_base_path(session
),
267 session
->last_archived_chunk_name
);
271 location
= lttng_trace_archive_location_local_create(
274 case CONSUMER_DST_NET
:
276 const char *hostname
;
277 uint16_t control_port
, data_port
;
279 hostname
= session_get_net_consumer_hostname(session
);
280 session_get_net_consumer_ports(session
,
283 location
= lttng_trace_archive_location_relay_create(
285 LTTNG_TRACE_ARCHIVE_LOCATION_RELAY_PROTOCOL_TYPE_TCP
,
286 control_port
, data_port
, session
->last_chunk_path
);
298 * Allocate the ltt_sessions_ht_by_id and ltt_sessions_ht_by_name HT.
300 * The session list lock must be held.
302 static int ltt_sessions_ht_alloc(void)
306 DBG("Allocating ltt_sessions_ht_by_id");
307 ltt_sessions_ht_by_id
= lttng_ht_new(0, LTTNG_HT_TYPE_U64
);
308 if (!ltt_sessions_ht_by_id
) {
310 ERR("Failed to allocate ltt_sessions_ht_by_id");
314 DBG("Allocating ltt_sessions_ht_by_name");
315 ltt_sessions_ht_by_name
= lttng_ht_new(0, LTTNG_HT_TYPE_STRING
);
316 if (!ltt_sessions_ht_by_name
) {
318 ERR("Failed to allocate ltt_sessions_ht_by_name");
327 * Destroy the ltt_sessions_ht_by_id HT.
329 * The session list lock must be held.
331 static void ltt_sessions_ht_destroy(void)
333 if (ltt_sessions_ht_by_id
) {
334 lttng_ht_destroy(ltt_sessions_ht_by_id
);
335 ltt_sessions_ht_by_id
= NULL
;
338 if (ltt_sessions_ht_by_name
) {
339 lttng_ht_destroy(ltt_sessions_ht_by_name
);
340 ltt_sessions_ht_by_name
= NULL
;
347 * Add a ltt_session to the ltt_sessions_ht_by_id and ltt_sessions_ht_by_name.
348 * If unallocated, the ltt_sessions_ht_by_id and ltt_sessions_ht_by_name. HTs
349 * are allocated. The session list lock must be held.
351 static void add_session_ht(struct ltt_session
*ls
)
357 if (!ltt_sessions_ht_by_id
) {
358 ret
= ltt_sessions_ht_alloc();
360 ERR("Error allocating the sessions HT");
365 /* Should always be present with ltt_sessions_ht_by_id. */
366 LTTNG_ASSERT(ltt_sessions_ht_by_name
);
368 lttng_ht_node_init_u64(&ls
->node
, ls
->id
);
369 lttng_ht_add_unique_u64(ltt_sessions_ht_by_id
, &ls
->node
);
371 lttng_ht_node_init_str(&ls
->node_by_name
, ls
->name
);
372 lttng_ht_add_unique_str(ltt_sessions_ht_by_name
, &ls
->node_by_name
);
379 * Test if ltt_sessions_ht_by_id/name are empty.
380 * Return 1 if empty, 0 if not empty.
381 * The session list lock must be held.
383 static int ltt_sessions_ht_empty(void)
387 if (!ltt_sessions_ht_by_id
) {
392 LTTNG_ASSERT(ltt_sessions_ht_by_name
);
394 count
= lttng_ht_get_count(ltt_sessions_ht_by_id
);
395 LTTNG_ASSERT(count
== lttng_ht_get_count(ltt_sessions_ht_by_name
));
397 return count
? 0 : 1;
401 * Remove a ltt_session from the ltt_sessions_ht_by_id.
402 * If empty, the ltt_sessions_ht_by_id/name HTs are freed.
403 * The session list lock must be held.
405 static void del_session_ht(struct ltt_session
*ls
)
407 struct lttng_ht_iter iter
;
411 LTTNG_ASSERT(ltt_sessions_ht_by_id
);
412 LTTNG_ASSERT(ltt_sessions_ht_by_name
);
414 iter
.iter
.node
= &ls
->node
.node
;
415 ret
= lttng_ht_del(ltt_sessions_ht_by_id
, &iter
);
418 if (ltt_sessions_ht_empty()) {
419 DBG("Empty ltt_sessions_ht_by_id/name, destroying hast tables");
420 ltt_sessions_ht_destroy();
425 * Acquire session lock
427 void session_lock(struct ltt_session
*session
)
429 LTTNG_ASSERT(session
);
431 pthread_mutex_lock(&session
->lock
);
435 * Release session lock
437 void session_unlock(struct ltt_session
*session
)
439 LTTNG_ASSERT(session
);
441 pthread_mutex_unlock(&session
->lock
);
445 int _session_set_trace_chunk_no_lock_check(struct ltt_session
*session
,
446 struct lttng_trace_chunk
*new_trace_chunk
,
447 struct lttng_trace_chunk
**_current_trace_chunk
)
450 unsigned int i
, refs_to_acquire
= 0, refs_acquired
= 0, refs_to_release
= 0;
451 struct cds_lfht_iter iter
;
452 struct consumer_socket
*socket
;
453 struct lttng_trace_chunk
*current_trace_chunk
;
455 enum lttng_trace_chunk_status chunk_status
;
459 * Ownership of current trace chunk is transferred to
460 * `current_trace_chunk`.
462 current_trace_chunk
= session
->current_trace_chunk
;
463 session
->current_trace_chunk
= NULL
;
464 if (session
->ust_session
) {
465 lttng_trace_chunk_put(
466 session
->ust_session
->current_trace_chunk
);
467 session
->ust_session
->current_trace_chunk
= NULL
;
469 if (session
->kernel_session
) {
470 lttng_trace_chunk_put(
471 session
->kernel_session
->current_trace_chunk
);
472 session
->kernel_session
->current_trace_chunk
= NULL
;
474 if (!new_trace_chunk
) {
478 chunk_status
= lttng_trace_chunk_get_id(new_trace_chunk
, &chunk_id
);
479 LTTNG_ASSERT(chunk_status
== LTTNG_TRACE_CHUNK_STATUS_OK
);
482 refs_to_acquire
+= !!session
->ust_session
;
483 refs_to_acquire
+= !!session
->kernel_session
;
485 for (refs_acquired
= 0; refs_acquired
< refs_to_acquire
;
487 if (!lttng_trace_chunk_get(new_trace_chunk
)) {
488 ERR("Failed to acquire reference to new trace chunk of session \"%s\"",
494 if (session
->ust_session
) {
495 const uint64_t relayd_id
=
496 session
->ust_session
->consumer
->net_seq_index
;
497 const bool is_local_trace
=
498 session
->ust_session
->consumer
->type
==
501 session
->ust_session
->current_trace_chunk
= new_trace_chunk
;
502 if (is_local_trace
) {
503 enum lttng_error_code ret_error_code
;
505 ret_error_code
= ust_app_create_channel_subdirectories(
506 session
->ust_session
);
507 if (ret_error_code
!= LTTNG_OK
) {
511 cds_lfht_for_each_entry(
512 session
->ust_session
->consumer
->socks
->ht
,
513 &iter
, socket
, node
.node
) {
514 pthread_mutex_lock(socket
->lock
);
515 ret
= consumer_create_trace_chunk(socket
,
517 session
->id
, new_trace_chunk
,
518 DEFAULT_UST_TRACE_DIR
);
519 pthread_mutex_unlock(socket
->lock
);
525 if (session
->kernel_session
) {
526 const uint64_t relayd_id
=
527 session
->kernel_session
->consumer
->net_seq_index
;
528 const bool is_local_trace
=
529 session
->kernel_session
->consumer
->type
==
532 session
->kernel_session
->current_trace_chunk
= new_trace_chunk
;
533 if (is_local_trace
) {
534 enum lttng_error_code ret_error_code
;
536 ret_error_code
= kernel_create_channel_subdirectories(
537 session
->kernel_session
);
538 if (ret_error_code
!= LTTNG_OK
) {
542 cds_lfht_for_each_entry(
543 session
->kernel_session
->consumer
->socks
->ht
,
544 &iter
, socket
, node
.node
) {
545 pthread_mutex_lock(socket
->lock
);
546 ret
= consumer_create_trace_chunk(socket
,
548 session
->id
, new_trace_chunk
,
549 DEFAULT_KERNEL_TRACE_DIR
);
550 pthread_mutex_unlock(socket
->lock
);
558 * Update local current trace chunk state last, only if all remote
559 * creations succeeded.
561 session
->current_trace_chunk
= new_trace_chunk
;
562 LTTNG_OPTIONAL_SET(&session
->most_recent_chunk_id
, chunk_id
);
564 if (_current_trace_chunk
) {
565 *_current_trace_chunk
= current_trace_chunk
;
566 current_trace_chunk
= NULL
;
570 lttng_trace_chunk_put(current_trace_chunk
);
573 if (session
->ust_session
) {
574 session
->ust_session
->current_trace_chunk
= NULL
;
576 if (session
->kernel_session
) {
577 session
->kernel_session
->current_trace_chunk
= NULL
;
580 * Release references taken in the case where all references could not
583 refs_to_release
= refs_to_acquire
- refs_acquired
;
584 for (i
= 0; i
< refs_to_release
; i
++) {
585 lttng_trace_chunk_put(new_trace_chunk
);
591 struct lttng_trace_chunk
*session_create_new_trace_chunk(
592 const struct ltt_session
*session
,
593 const struct consumer_output
*consumer_output_override
,
594 const char *session_base_path_override
,
595 const char *chunk_name_override
)
598 struct lttng_trace_chunk
*trace_chunk
= NULL
;
599 enum lttng_trace_chunk_status chunk_status
;
600 const time_t chunk_creation_ts
= time(NULL
);
602 const char *base_path
;
603 struct lttng_directory_handle
*session_output_directory
= NULL
;
604 const struct lttng_credentials session_credentials
= {
605 .uid
= LTTNG_OPTIONAL_INIT_VALUE(session
->uid
),
606 .gid
= LTTNG_OPTIONAL_INIT_VALUE(session
->gid
),
608 uint64_t next_chunk_id
;
609 const struct consumer_output
*output
;
610 const char *new_path
;
612 if (consumer_output_override
) {
613 output
= consumer_output_override
;
615 LTTNG_ASSERT(session
->ust_session
|| session
->kernel_session
);
616 output
= session
->ust_session
?
617 session
->ust_session
->consumer
:
618 session
->kernel_session
->consumer
;
621 is_local_trace
= output
->type
== CONSUMER_DST_LOCAL
;
622 base_path
= session_base_path_override
? :
623 consumer_output_get_base_path(output
);
625 if (chunk_creation_ts
== (time_t) -1) {
626 PERROR("Failed to sample time while creation session \"%s\" trace chunk",
631 next_chunk_id
= session
->most_recent_chunk_id
.is_set
?
632 session
->most_recent_chunk_id
.value
+ 1 : 0;
634 if (session
->current_trace_chunk
&&
635 !lttng_trace_chunk_get_name_overridden(session
->current_trace_chunk
)) {
636 chunk_status
= lttng_trace_chunk_rename_path(session
->current_trace_chunk
,
637 DEFAULT_CHUNK_TMP_OLD_DIRECTORY
);
638 if (chunk_status
!= LTTNG_TRACE_CHUNK_STATUS_OK
) {
642 if (!session
->current_trace_chunk
) {
643 if (!session
->rotated
) {
649 new_path
= DEFAULT_CHUNK_TMP_NEW_DIRECTORY
;
652 trace_chunk
= lttng_trace_chunk_create(next_chunk_id
,
653 chunk_creation_ts
, new_path
);
658 if (chunk_name_override
) {
659 chunk_status
= lttng_trace_chunk_override_name(trace_chunk
,
660 chunk_name_override
);
661 if (chunk_status
!= LTTNG_TRACE_CHUNK_STATUS_OK
) {
666 if (!is_local_trace
) {
668 * No need to set crendentials and output directory
669 * for remote trace chunks.
674 chunk_status
= lttng_trace_chunk_set_credentials(trace_chunk
,
675 &session_credentials
);
676 if (chunk_status
!= LTTNG_TRACE_CHUNK_STATUS_OK
) {
680 DBG("Creating base output directory of session \"%s\" at %s",
681 session
->name
, base_path
);
682 ret
= utils_mkdir_recursive(base_path
, S_IRWXU
| S_IRWXG
,
683 session
->uid
, session
->gid
);
687 session_output_directory
= lttng_directory_handle_create(base_path
);
688 if (!session_output_directory
) {
691 chunk_status
= lttng_trace_chunk_set_as_owner(trace_chunk
,
692 session_output_directory
);
693 lttng_directory_handle_put(session_output_directory
);
694 session_output_directory
= NULL
;
695 if (chunk_status
!= LTTNG_TRACE_CHUNK_STATUS_OK
) {
701 lttng_directory_handle_put(session_output_directory
);
702 lttng_trace_chunk_put(trace_chunk
);
707 int session_close_trace_chunk(struct ltt_session
*session
,
708 struct lttng_trace_chunk
*trace_chunk
,
709 enum lttng_trace_chunk_command_type close_command
,
710 char *closed_trace_chunk_path
)
713 bool error_occurred
= false;
714 struct cds_lfht_iter iter
;
715 struct consumer_socket
*socket
;
716 enum lttng_trace_chunk_status chunk_status
;
717 const time_t chunk_close_timestamp
= time(NULL
);
718 const char *new_path
;
720 chunk_status
= lttng_trace_chunk_set_close_command(
721 trace_chunk
, close_command
);
722 if (chunk_status
!= LTTNG_TRACE_CHUNK_STATUS_OK
) {
727 if (chunk_close_timestamp
== (time_t) -1) {
728 ERR("Failed to sample the close timestamp of the current trace chunk of session \"%s\"",
734 if (close_command
== LTTNG_TRACE_CHUNK_COMMAND_TYPE_DELETE
&& !session
->rotated
) {
735 /* New chunk stays in session output directory. */
738 /* Use chunk name for new chunk. */
741 if (session
->current_trace_chunk
&&
742 !lttng_trace_chunk_get_name_overridden(session
->current_trace_chunk
)) {
743 /* Rename new chunk path. */
744 chunk_status
= lttng_trace_chunk_rename_path(session
->current_trace_chunk
,
746 if (chunk_status
!= LTTNG_TRACE_CHUNK_STATUS_OK
) {
751 if (!lttng_trace_chunk_get_name_overridden(trace_chunk
) &&
752 close_command
== LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION
) {
753 const char *old_path
;
755 if (!session
->rotated
) {
760 /* We need to move back the .tmp_old_chunk to its rightful place. */
761 chunk_status
= lttng_trace_chunk_rename_path(trace_chunk
,
763 if (chunk_status
!= LTTNG_TRACE_CHUNK_STATUS_OK
) {
768 if (close_command
== LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED
) {
769 session
->rotated
= true;
771 chunk_status
= lttng_trace_chunk_set_close_timestamp(trace_chunk
,
772 chunk_close_timestamp
);
773 if (chunk_status
!= LTTNG_TRACE_CHUNK_STATUS_OK
) {
774 ERR("Failed to set the close timestamp of the current trace chunk of session \"%s\"",
780 if (session
->ust_session
) {
781 const uint64_t relayd_id
=
782 session
->ust_session
->consumer
->net_seq_index
;
784 cds_lfht_for_each_entry(
785 session
->ust_session
->consumer
->socks
->ht
,
786 &iter
, socket
, node
.node
) {
787 pthread_mutex_lock(socket
->lock
);
788 ret
= consumer_close_trace_chunk(socket
,
791 trace_chunk
, closed_trace_chunk_path
);
792 pthread_mutex_unlock(socket
->lock
);
794 ERR("Failed to close trace chunk on user space consumer");
795 error_occurred
= true;
799 if (session
->kernel_session
) {
800 const uint64_t relayd_id
=
801 session
->kernel_session
->consumer
->net_seq_index
;
803 cds_lfht_for_each_entry(
804 session
->kernel_session
->consumer
->socks
->ht
,
805 &iter
, socket
, node
.node
) {
806 pthread_mutex_lock(socket
->lock
);
807 ret
= consumer_close_trace_chunk(socket
,
810 trace_chunk
, closed_trace_chunk_path
);
811 pthread_mutex_unlock(socket
->lock
);
813 ERR("Failed to close trace chunk on kernel consumer");
814 error_occurred
= true;
818 ret
= error_occurred
? -1 : 0;
824 * This function skips the metadata channel as the begin/end timestamps of a
825 * metadata packet are useless.
827 * Moreover, opening a packet after a "clear" will cause problems for live
828 * sessions as it will introduce padding that was not part of the first trace
829 * chunk. The relay daemon expects the content of the metadata stream of
830 * successive metadata trace chunks to be strict supersets of one another.
832 * For example, flushing a packet at the beginning of the metadata stream of
833 * a trace chunk resulting from a "clear" session command will cause the
834 * size of the metadata stream of the new trace chunk to not match the size of
835 * the metadata stream of the original chunk. This will confuse the relay
836 * daemon as the same "offset" in a metadata stream will no longer point
837 * to the same content.
840 enum lttng_error_code
session_kernel_open_packets(struct ltt_session
*session
)
842 enum lttng_error_code ret
= LTTNG_OK
;
843 struct consumer_socket
*socket
;
844 struct lttng_ht_iter iter
;
845 struct cds_lfht_node
*node
;
846 struct ltt_kernel_channel
*chan
;
850 cds_lfht_first(session
->kernel_session
->consumer
->socks
->ht
, &iter
.iter
);
851 node
= cds_lfht_iter_get_node(&iter
.iter
);
852 socket
= container_of(node
, typeof(*socket
), node
.node
);
854 cds_list_for_each_entry(chan
,
855 &session
->kernel_session
->channel_list
.head
, list
) {
858 DBG("Open packet of kernel channel: channel key = %" PRIu64
859 ", session name = %s, session_id = %" PRIu64
,
860 chan
->key
, session
->name
, session
->id
);
862 open_ret
= consumer_open_channel_packets(socket
, chan
->key
);
864 /* General error (no known error expected). */
875 enum lttng_error_code
session_open_packets(struct ltt_session
*session
)
877 enum lttng_error_code ret
= LTTNG_OK
;
879 DBG("Opening packets of session channels: session name = %s, session id = %" PRIu64
,
880 session
->name
, session
->id
);
882 if (session
->ust_session
) {
883 ret
= ust_app_open_packets(session
);
884 if (ret
!= LTTNG_OK
) {
889 if (session
->kernel_session
) {
890 ret
= session_kernel_open_packets(session
);
891 if (ret
!= LTTNG_OK
) {
901 * Set a session's current trace chunk.
903 * Must be called with the session lock held.
905 int session_set_trace_chunk(struct ltt_session
*session
,
906 struct lttng_trace_chunk
*new_trace_chunk
,
907 struct lttng_trace_chunk
**current_trace_chunk
)
909 ASSERT_LOCKED(session
->lock
);
910 return _session_set_trace_chunk_no_lock_check(session
, new_trace_chunk
,
911 current_trace_chunk
);
915 void session_notify_destruction(const struct ltt_session
*session
)
918 const size_t count
= lttng_dynamic_array_get_count(
919 &session
->destroy_notifiers
);
921 for (i
= 0; i
< count
; i
++) {
922 const struct ltt_session_destroy_notifier_element
*element
=
923 (ltt_session_destroy_notifier_element
*) lttng_dynamic_array_get_element(
924 &session
->destroy_notifiers
, i
);
926 element
->notifier(session
, element
->user_data
);
931 * Fire each clear notifier once, and remove them from the array.
933 void session_notify_clear(struct ltt_session
*session
)
936 const size_t count
= lttng_dynamic_array_get_count(
937 &session
->clear_notifiers
);
939 for (i
= 0; i
< count
; i
++) {
940 const struct ltt_session_clear_notifier_element
*element
=
941 (ltt_session_clear_notifier_element
*) lttng_dynamic_array_get_element(
942 &session
->clear_notifiers
, i
);
944 element
->notifier(session
, element
->user_data
);
946 lttng_dynamic_array_clear(&session
->clear_notifiers
);
950 void session_release(struct urcu_ref
*ref
)
953 struct ltt_ust_session
*usess
;
954 struct ltt_kernel_session
*ksess
;
955 struct ltt_session
*session
= container_of(ref
, typeof(*session
), ref
);
956 const bool session_published
= session
->published
;
958 LTTNG_ASSERT(!session
->chunk_being_archived
);
960 usess
= session
->ust_session
;
961 ksess
= session
->kernel_session
;
963 /* Clean kernel session teardown, keeping data for destroy notifier. */
964 kernel_destroy_session(ksess
);
966 /* UST session teardown, keeping data for destroy notifier. */
968 /* Close any relayd session */
969 consumer_output_send_destroy_relayd(usess
->consumer
);
971 /* Destroy every UST application related to this session. */
972 ret
= ust_app_destroy_trace_all(usess
);
974 ERR("Error in ust_app_destroy_trace_all");
977 /* Clean up the rest, keeping destroy notifier data. */
978 trace_ust_destroy_session(usess
);
982 * Must notify the kernel thread here to update it's poll set in order to
983 * remove the channel(s)' fd just destroyed.
985 ret
= notify_thread_pipe(the_kernel_poll_pipe
[1]);
987 PERROR("write kernel poll pipe");
990 DBG("Destroying session %s (id %" PRIu64
")", session
->name
, session
->id
);
992 snapshot_destroy(&session
->snapshot
);
994 pthread_mutex_destroy(&session
->lock
);
996 if (session_published
) {
997 ASSERT_LOCKED(ltt_session_list
.lock
);
998 del_session_list(session
);
999 del_session_ht(session
);
1001 session_notify_destruction(session
);
1003 consumer_output_put(session
->consumer
);
1004 kernel_free_session(ksess
);
1005 session
->kernel_session
= NULL
;
1007 trace_ust_free_session(usess
);
1008 session
->ust_session
= NULL
;
1010 lttng_dynamic_array_reset(&session
->destroy_notifiers
);
1011 lttng_dynamic_array_reset(&session
->clear_notifiers
);
1012 free(session
->last_archived_chunk_name
);
1013 free(session
->base_path
);
1015 if (session_published
) {
1017 * Broadcast after free-ing to ensure the memory is
1018 * reclaimed before the main thread exits.
1020 ASSERT_LOCKED(ltt_session_list
.lock
);
1021 pthread_cond_broadcast(<t_session_list
.removal_cond
);
1026 * Acquire a reference to a session.
1027 * This function may fail (return false); its return value must be checked.
1029 bool session_get(struct ltt_session
*session
)
1031 return urcu_ref_get_unless_zero(&session
->ref
);
1035 * Release a reference to a session.
1037 void session_put(struct ltt_session
*session
)
1043 * The session list lock must be held as any session_put()
1044 * may cause the removal of the session from the session_list.
1046 ASSERT_LOCKED(ltt_session_list
.lock
);
1047 LTTNG_ASSERT(session
->ref
.refcount
);
1048 urcu_ref_put(&session
->ref
, session_release
);
1052 * Destroy a session.
1054 * This method does not immediately release/free the session as other
1055 * components may still hold a reference to the session. However,
1056 * the session should no longer be presented to the user.
1058 * Releases the session list's reference to the session
1059 * and marks it as destroyed. Iterations on the session list should be
1060 * mindful of the "destroyed" flag.
1062 void session_destroy(struct ltt_session
*session
)
1065 struct lttng_ht_iter iter
;
1067 LTTNG_ASSERT(!session
->destroyed
);
1068 session
->destroyed
= true;
1071 * Remove immediately from the "session by name" hash table. Only one
1072 * session is expected to exist with a given name for at any given time.
1074 * Even if a session still technically exists for a little while longer,
1075 * there is no point in performing action on a "destroyed" session.
1077 iter
.iter
.node
= &session
->node_by_name
.node
;
1078 ret
= lttng_ht_del(ltt_sessions_ht_by_name
, &iter
);
1081 session_put(session
);
1084 int session_add_destroy_notifier(struct ltt_session
*session
,
1085 ltt_session_destroy_notifier notifier
, void *user_data
)
1087 const struct ltt_session_destroy_notifier_element element
= {
1088 .notifier
= notifier
,
1089 .user_data
= user_data
1092 return lttng_dynamic_array_add_element(&session
->destroy_notifiers
,
1096 int session_add_clear_notifier(struct ltt_session
*session
,
1097 ltt_session_clear_notifier notifier
, void *user_data
)
1099 const struct ltt_session_clear_notifier_element element
= {
1100 .notifier
= notifier
,
1101 .user_data
= user_data
1104 return lttng_dynamic_array_add_element(&session
->clear_notifiers
,
1109 * Return a ltt_session structure ptr that matches name. If no session found,
1110 * NULL is returned. This must be called with the session list lock held using
1111 * session_lock_list and session_unlock_list.
1112 * A reference to the session is implicitly acquired by this function.
1114 struct ltt_session
*session_find_by_name(const char *name
)
1116 struct ltt_session
*iter
;
1119 ASSERT_LOCKED(ltt_session_list
.lock
);
1121 DBG2("Trying to find session by name %s", name
);
1123 cds_list_for_each_entry(iter
, <t_session_list
.head
, list
) {
1124 if (!strncmp(iter
->name
, name
, NAME_MAX
) &&
1132 return session_get(iter
) ? iter
: NULL
;
1136 * Return an ltt_session that matches the id. If no session is found,
1137 * NULL is returned. This must be called with rcu_read_lock and
1138 * session list lock held (to guarantee the lifetime of the session).
1140 struct ltt_session
*session_find_by_id(uint64_t id
)
1142 struct lttng_ht_node_u64
*node
;
1143 struct lttng_ht_iter iter
;
1144 struct ltt_session
*ls
;
1146 ASSERT_RCU_READ_LOCKED();
1147 ASSERT_LOCKED(ltt_session_list
.lock
);
1149 if (!ltt_sessions_ht_by_id
) {
1153 lttng_ht_lookup(ltt_sessions_ht_by_id
, &id
, &iter
);
1154 node
= lttng_ht_iter_get_node_u64(&iter
);
1158 ls
= caa_container_of(node
, struct ltt_session
, node
);
1160 DBG3("Session %" PRIu64
" found by id.", id
);
1161 return session_get(ls
) ? ls
: NULL
;
1164 DBG3("Session %" PRIu64
" NOT found by id", id
);
1169 * Create a new session and add it to the session list.
1170 * Session list lock must be held by the caller.
1172 enum lttng_error_code
session_create(const char *name
, uid_t uid
, gid_t gid
,
1173 struct ltt_session
**out_session
)
1176 enum lttng_error_code ret_code
;
1177 struct ltt_session
*new_session
= NULL
;
1179 ASSERT_LOCKED(ltt_session_list
.lock
);
1181 struct ltt_session
*clashing_session
;
1183 clashing_session
= session_find_by_name(name
);
1184 if (clashing_session
) {
1185 session_put(clashing_session
);
1186 ret_code
= LTTNG_ERR_EXIST_SESS
;
1190 new_session
= (ltt_session
*) zmalloc(sizeof(struct ltt_session
));
1192 PERROR("Failed to allocate an ltt_session structure");
1193 ret_code
= LTTNG_ERR_NOMEM
;
1197 lttng_dynamic_array_init(&new_session
->destroy_notifiers
,
1198 sizeof(struct ltt_session_destroy_notifier_element
),
1200 lttng_dynamic_array_init(&new_session
->clear_notifiers
,
1201 sizeof(struct ltt_session_clear_notifier_element
),
1203 urcu_ref_init(&new_session
->ref
);
1204 pthread_mutex_init(&new_session
->lock
, NULL
);
1206 new_session
->creation_time
= time(NULL
);
1207 if (new_session
->creation_time
== (time_t) -1) {
1208 PERROR("Failed to sample session creation time");
1209 ret_code
= LTTNG_ERR_SESSION_FAIL
;
1213 /* Create default consumer output. */
1214 new_session
->consumer
= consumer_create_output(CONSUMER_DST_LOCAL
);
1215 if (new_session
->consumer
== NULL
) {
1216 ret_code
= LTTNG_ERR_NOMEM
;
1221 ret
= lttng_strncpy(new_session
->name
, name
, sizeof(new_session
->name
));
1223 ret_code
= LTTNG_ERR_SESSION_INVALID_CHAR
;
1226 ret
= validate_name(name
);
1228 ret_code
= LTTNG_ERR_SESSION_INVALID_CHAR
;
1233 bool found_name
= false;
1235 struct tm
*timeinfo
;
1237 timeinfo
= localtime(&new_session
->creation_time
);
1239 ret_code
= LTTNG_ERR_SESSION_FAIL
;
1242 strftime(datetime
, sizeof(datetime
), "%Y%m%d-%H%M%S", timeinfo
);
1243 for (i
= 0; i
< INT_MAX
; i
++) {
1244 struct ltt_session
*clashing_session
;
1247 ret
= snprintf(new_session
->name
,
1248 sizeof(new_session
->name
),
1250 DEFAULT_SESSION_NAME
,
1253 ret
= snprintf(new_session
->name
,
1254 sizeof(new_session
->name
),
1256 DEFAULT_SESSION_NAME
, i
,
1259 new_session
->name_contains_creation_time
= true;
1260 if (ret
== -1 || ret
>= sizeof(new_session
->name
)) {
1262 * Null-terminate in case the name is used
1263 * in logging statements.
1265 new_session
->name
[sizeof(new_session
->name
) - 1] = '\0';
1266 ret_code
= LTTNG_ERR_SESSION_FAIL
;
1271 session_find_by_name(new_session
->name
);
1272 session_put(clashing_session
);
1273 if (!clashing_session
) {
1279 DBG("Generated session name \"%s\"", new_session
->name
);
1280 new_session
->has_auto_generated_name
= true;
1282 ERR("Failed to auto-generate a session name");
1283 ret_code
= LTTNG_ERR_SESSION_FAIL
;
1288 ret
= gethostname(new_session
->hostname
, sizeof(new_session
->hostname
));
1290 if (errno
== ENAMETOOLONG
) {
1291 new_session
->hostname
[sizeof(new_session
->hostname
) - 1] = '\0';
1292 ERR("Hostname exceeds the maximal permitted length and has been truncated to %s",
1293 new_session
->hostname
);
1295 ret_code
= LTTNG_ERR_SESSION_FAIL
;
1300 new_session
->uid
= uid
;
1301 new_session
->gid
= gid
;
1303 ret
= snapshot_init(&new_session
->snapshot
);
1305 ret_code
= LTTNG_ERR_NOMEM
;
1309 new_session
->rotation_state
= LTTNG_ROTATION_STATE_NO_ROTATION
;
1311 /* Add new session to the session list. */
1312 new_session
->id
= add_session_list(new_session
);
1315 * Add the new session to the ltt_sessions_ht_by_id.
1316 * No ownership is taken by the hash table; it is merely
1317 * a wrapper around the session list used for faster access
1320 add_session_ht(new_session
);
1321 new_session
->published
= true;
1324 * Consumer is left to NULL since the create_session_uri command will
1325 * set it up and, if valid, assign it to the session.
1327 DBG("Tracing session %s created with ID %" PRIu64
" by uid = %d, gid = %d",
1328 new_session
->name
, new_session
->id
, new_session
->uid
,
1330 ret_code
= LTTNG_OK
;
1333 (void) session_get(new_session
);
1334 *out_session
= new_session
;
1338 session_put(new_session
);
1344 * Check if the UID matches the session. Root user has access to all
1347 bool session_access_ok(struct ltt_session
*session
, uid_t uid
)
1349 LTTNG_ASSERT(session
);
1350 return (uid
== session
->uid
) || uid
== 0;
1354 * Set a session's rotation state and reset all associated state.
1356 * This function resets the rotation state (check timers, pending
1357 * flags, etc.) and sets the result of the last rotation. The result
1358 * can be queries by a liblttng-ctl client.
1360 * Be careful of the result passed to this function. For instance,
1361 * on failure to launch a rotation, a client will expect the rotation
1362 * state to be set to "NO_ROTATION". If an error occurred while the
1363 * rotation was "ONGOING", result should be set to "ERROR", which will
1364 * allow a client to report it.
1366 * Must be called with the session and session_list locks held.
1368 int session_reset_rotation_state(struct ltt_session
*session
,
1369 enum lttng_rotation_state result
)
1373 ASSERT_LOCKED(ltt_session_list
.lock
);
1374 ASSERT_LOCKED(session
->lock
);
1376 session
->rotation_state
= result
;
1377 if (session
->rotation_pending_check_timer_enabled
) {
1378 ret
= timer_session_rotation_pending_check_stop(session
);
1380 if (session
->chunk_being_archived
) {
1382 enum lttng_trace_chunk_status chunk_status
;
1384 chunk_status
= lttng_trace_chunk_get_id(
1385 session
->chunk_being_archived
,
1387 LTTNG_ASSERT(chunk_status
== LTTNG_TRACE_CHUNK_STATUS_OK
);
1388 LTTNG_OPTIONAL_SET(&session
->last_archived_chunk_id
,
1390 lttng_trace_chunk_put(session
->chunk_being_archived
);
1391 session
->chunk_being_archived
= NULL
;
1393 * Fire the clear reply notifiers if we are completing a clear
1396 session_notify_clear(session
);
1402 * Sample the id of a session looked up via its name.
1403 * Here the term "sampling" hint the caller that this return the id at a given
1404 * point in time with no guarantee that the session for which the id was
1405 * sampled still exist at that point.
1407 * Return 0 when the session is not found,
1408 * Return 1 when the session is found and set `id`.
1410 bool sample_session_id_by_name(const char *name
, uint64_t *id
)
1413 struct lttng_ht_node_str
*node
;
1414 struct lttng_ht_iter iter
;
1415 struct ltt_session
*ls
;
1419 if (!ltt_sessions_ht_by_name
) {
1424 lttng_ht_lookup(ltt_sessions_ht_by_name
, name
, &iter
);
1425 node
= lttng_ht_iter_get_node_str(&iter
);
1431 ls
= caa_container_of(node
, struct ltt_session
, node_by_name
);
1435 DBG3("Session id `%" PRIu64
"` sampled for session `%s", *id
, name
);