2 * Copyright (C) 2017 - Julien Desfossez <jdesfossez@efficios.com>
3 * Copyright (C) 2018 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License, version 2 only, as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc., 51
16 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 #include <lttng/trigger/trigger.h>
21 #include <common/error.h>
22 #include <common/config/session-config.h>
23 #include <common/defaults.h>
24 #include <common/utils.h>
25 #include <common/futex.h>
26 #include <common/align.h>
27 #include <common/time.h>
28 #include <common/hashtable/utils.h>
29 #include <sys/eventfd.h>
35 #include <common/kernel-ctl/kernel-ctl.h>
36 #include <lttng/notification/channel-internal.h>
37 #include <lttng/rotate-internal.h>
39 #include "rotation-thread.h"
40 #include "lttng-sessiond.h"
41 #include "health-sessiond.h"
46 #include "notification-thread-commands.h"
49 #include <urcu/list.h>
51 struct lttng_notification_channel
*rotate_notification_channel
= NULL
;
53 struct rotation_thread
{
54 struct lttng_poll_event events
;
57 struct rotation_thread_job
{
58 enum rotation_thread_job_type type
;
59 struct ltt_session
*session
;
60 /* List member in struct rotation_thread_timer_queue. */
61 struct cds_list_head head
;
65 * The timer thread enqueues jobs and wakes up the rotation thread.
66 * When the rotation thread wakes up, it empties the queue.
68 struct rotation_thread_timer_queue
{
69 struct lttng_pipe
*event_pipe
;
70 struct cds_list_head list
;
74 struct rotation_thread_handle
{
75 struct rotation_thread_timer_queue
*rotation_timer_queue
;
76 /* Access to the notification thread cmd_queue */
77 struct notification_thread_handle
*notification_thread_handle
;
78 sem_t
*notification_thread_ready
;
82 const char *get_job_type_str(enum rotation_thread_job_type job_type
)
85 case ROTATION_THREAD_JOB_TYPE_CHECK_PENDING_ROTATION
:
86 return "CHECK_PENDING_ROTATION";
87 case ROTATION_THREAD_JOB_TYPE_SCHEDULED_ROTATION
:
88 return "SCHEDULED_ROTATION";
94 struct rotation_thread_timer_queue
*rotation_thread_timer_queue_create(void)
96 struct rotation_thread_timer_queue
*queue
= NULL
;
98 queue
= zmalloc(sizeof(*queue
));
100 PERROR("Failed to allocate timer rotate queue");
104 queue
->event_pipe
= lttng_pipe_open(FD_CLOEXEC
| O_NONBLOCK
);
105 CDS_INIT_LIST_HEAD(&queue
->list
);
106 pthread_mutex_init(&queue
->lock
, NULL
);
111 void log_job_destruction(const struct rotation_thread_job
*job
)
113 enum lttng_error_level log_level
;
114 const char *job_type_str
= get_job_type_str(job
->type
);
117 case ROTATION_THREAD_JOB_TYPE_SCHEDULED_ROTATION
:
119 * Not a problem, the scheduled rotation is racing with the teardown
120 * of the daemon. In this case, the rotation will not happen, which
121 * is not a problem (or at least, not important enough to delay
122 * the shutdown of the session daemon).
124 log_level
= PRINT_DBG
;
126 case ROTATION_THREAD_JOB_TYPE_CHECK_PENDING_ROTATION
:
127 /* This is not expected to happen; warn the user. */
128 log_level
= PRINT_WARN
;
134 LOG(log_level
, "Rotation thread timer queue still contains job of type %s targeting session \"%s\" on destruction",
135 job_type_str
, job
->session
->name
);
138 void rotation_thread_timer_queue_destroy(
139 struct rotation_thread_timer_queue
*queue
)
141 struct rotation_thread_job
*job
, *tmp_job
;
147 lttng_pipe_destroy(queue
->event_pipe
);
149 pthread_mutex_lock(&queue
->lock
);
150 /* Empty wait queue. */
151 cds_list_for_each_entry_safe(job
, tmp_job
, &queue
->list
, head
) {
152 log_job_destruction(job
);
153 cds_list_del(&job
->head
);
156 pthread_mutex_unlock(&queue
->lock
);
157 pthread_mutex_destroy(&queue
->lock
);
162 * Destroy the thread data previously created by the init function.
164 void rotation_thread_handle_destroy(
165 struct rotation_thread_handle
*handle
)
170 struct rotation_thread_handle
*rotation_thread_handle_create(
171 struct rotation_thread_timer_queue
*rotation_timer_queue
,
172 struct notification_thread_handle
*notification_thread_handle
,
173 sem_t
*notification_thread_ready
)
175 struct rotation_thread_handle
*handle
;
177 handle
= zmalloc(sizeof(*handle
));
182 handle
->rotation_timer_queue
= rotation_timer_queue
;
183 handle
->notification_thread_handle
= notification_thread_handle
;
184 handle
->notification_thread_ready
= notification_thread_ready
;
191 * Called with the rotation_thread_timer_queue lock held.
192 * Return true if the same timer job already exists in the queue, false if not.
195 bool timer_job_exists(const struct rotation_thread_timer_queue
*queue
,
196 enum rotation_thread_job_type job_type
,
197 struct ltt_session
*session
)
200 struct rotation_thread_job
*job
;
202 cds_list_for_each_entry(job
, &queue
->list
, head
) {
203 if (job
->session
== session
&& job
->type
== job_type
) {
212 void rotation_thread_enqueue_job(struct rotation_thread_timer_queue
*queue
,
213 enum rotation_thread_job_type job_type
,
214 struct ltt_session
*session
)
217 const char * const dummy
= "!";
218 struct rotation_thread_job
*job
= NULL
;
219 const char *job_type_str
= get_job_type_str(job_type
);
221 pthread_mutex_lock(&queue
->lock
);
222 if (timer_job_exists(queue
, job_type
, session
)) {
224 * This timer job is already pending, we don't need to add
230 job
= zmalloc(sizeof(struct rotation_thread_job
));
232 PERROR("Failed to allocate rotation thread job of type \"%s\" for session \"%s\"",
233 job_type_str
, session
->name
);
236 /* No reason for this to fail as the caller must hold a reference. */
237 (void) session_get(session
);
239 job
->session
= session
;
240 job
->type
= job_type
;
241 cds_list_add_tail(&job
->head
, &queue
->list
);
243 ret
= lttng_write(lttng_pipe_get_writefd(queue
->event_pipe
), dummy
,
247 * We do not want to block in the timer handler, the job has
248 * been enqueued in the list, the wakeup pipe is probably full,
249 * the job will be processed when the rotation_thread catches
252 if (errno
== EAGAIN
|| errno
== EWOULDBLOCK
) {
254 * Not an error, but would be surprising and indicate
255 * that the rotation thread can't keep up with the
258 DBG("Wake-up pipe of rotation thread job queue is full");
261 PERROR("Failed to wake-up the rotation thread after pushing a job of type \"%s\" for session \"%s\"",
262 job_type_str
, session
->name
);
267 pthread_mutex_unlock(&queue
->lock
);
271 int init_poll_set(struct lttng_poll_event
*poll_set
,
272 struct rotation_thread_handle
*handle
)
277 * Create pollset with size 2:
279 * - rotation thread timer queue pipe,
281 ret
= sessiond_set_thread_pollset(poll_set
, 2);
285 ret
= lttng_poll_add(poll_set
,
286 lttng_pipe_get_readfd(handle
->rotation_timer_queue
->event_pipe
),
289 ERR("[rotation-thread] Failed to add rotate_pending fd to pollset");
295 lttng_poll_clean(poll_set
);
300 void fini_thread_state(struct rotation_thread
*state
)
302 lttng_poll_clean(&state
->events
);
303 if (rotate_notification_channel
) {
304 lttng_notification_channel_destroy(rotate_notification_channel
);
309 int init_thread_state(struct rotation_thread_handle
*handle
,
310 struct rotation_thread
*state
)
314 memset(state
, 0, sizeof(*state
));
315 lttng_poll_init(&state
->events
);
317 ret
= init_poll_set(&state
->events
, handle
);
319 ERR("[rotation-thread] Failed to initialize rotation thread poll set");
324 * We wait until the notification thread is ready to create the
325 * notification channel and add it to the poll_set.
327 sem_wait(handle
->notification_thread_ready
);
328 rotate_notification_channel
= lttng_notification_channel_create(
329 lttng_session_daemon_notification_endpoint
);
330 if (!rotate_notification_channel
) {
331 ERR("[rotation-thread] Could not create notification channel");
335 ret
= lttng_poll_add(&state
->events
, rotate_notification_channel
->socket
,
338 ERR("[rotation-thread] Failed to add notification fd to pollset");
347 int check_session_rotation_pending_local_on_consumer(
348 const struct ltt_session
*session
,
349 struct consumer_socket
*socket
, bool *rotation_completed
)
353 pthread_mutex_lock(socket
->lock
);
354 DBG("[rotation-thread] Checking for locally pending rotation on the %s consumer for session %s",
355 lttng_consumer_type_str(socket
->type
),
357 ret
= consumer_check_rotation_pending_local(socket
,
359 session
->current_archive_id
- 1);
360 pthread_mutex_unlock(socket
->lock
);
363 /* Rotation was completed on this consumer. */
364 DBG("[rotation-thread] Local rotation of trace archive %" PRIu64
" of session \"%s\" was completed on the %s consumer",
365 session
->current_archive_id
- 1,
367 lttng_consumer_type_str(socket
->type
));
368 *rotation_completed
= true;
369 } else if (ret
== 1) {
370 /* Rotation pending on this consumer. */
371 DBG("[rotation-thread] Local rotation of trace archive %" PRIu64
" of session \"%s\" is pending on the %s consumer",
372 session
->current_archive_id
- 1,
374 lttng_consumer_type_str(socket
->type
));
375 *rotation_completed
= false;
378 /* Not a fatal error. */
379 ERR("[rotation-thread] Encountered an error when checking if local rotation of trace archive %" PRIu64
" of session \"%s\" is pending on the %s consumer",
380 session
->current_archive_id
- 1,
382 lttng_consumer_type_str(socket
->type
));
383 *rotation_completed
= false;
389 int check_session_rotation_pending_local(struct ltt_session
*session
)
392 struct consumer_socket
*socket
;
393 struct cds_lfht_iter iter
;
394 bool rotation_completed
= true;
397 * Check for a local pending rotation on all consumers (32-bit
398 * user space, 64-bit user space, and kernel).
400 DBG("[rotation-thread] Checking for pending local rotation on session \"%s\", trace archive %" PRIu64
,
401 session
->name
, session
->current_archive_id
- 1);
404 if (!session
->ust_session
) {
407 cds_lfht_for_each_entry(session
->ust_session
->consumer
->socks
->ht
,
408 &iter
, socket
, node
.node
) {
409 ret
= check_session_rotation_pending_local_on_consumer(session
,
410 socket
, &rotation_completed
);
411 if (ret
|| !rotation_completed
) {
417 if (!session
->kernel_session
) {
420 cds_lfht_for_each_entry(session
->kernel_session
->consumer
->socks
->ht
,
421 &iter
, socket
, node
.node
) {
422 ret
= check_session_rotation_pending_local_on_consumer(session
,
423 socket
, &rotation_completed
);
424 if (ret
|| !rotation_completed
) {
432 if (rotation_completed
) {
433 DBG("[rotation-thread] Local rotation of trace archive %" PRIu64
" of session \"%s\" is complete on all consumers",
434 session
->current_archive_id
- 1,
436 session
->rotation_pending_local
= false;
439 ret
= session_reset_rotation_state(session
,
440 LTTNG_ROTATION_STATE_ERROR
);
442 ERR("Failed to reset rotation state of session \"%s\"",
450 int check_session_rotation_pending_relay(struct ltt_session
*session
)
453 struct consumer_socket
*socket
;
454 struct cds_lfht_iter iter
;
455 bool rotation_completed
= true;
456 const struct consumer_output
*output
;
459 * Check for a pending rotation on any consumer as we only use
460 * it as a "tunnel" to the relayd.
464 if (session
->ust_session
) {
465 cds_lfht_first(session
->ust_session
->consumer
->socks
->ht
,
467 output
= session
->ust_session
->consumer
;
469 cds_lfht_first(session
->kernel_session
->consumer
->socks
->ht
,
471 output
= session
->kernel_session
->consumer
;
473 assert(cds_lfht_iter_get_node(&iter
));
475 socket
= caa_container_of(cds_lfht_iter_get_node(&iter
),
476 typeof(*socket
), node
.node
);
478 pthread_mutex_lock(socket
->lock
);
479 DBG("[rotation-thread] Checking for pending relay rotation on session \"%s\", trace archive %" PRIu64
" through the %s consumer",
480 session
->name
, session
->current_archive_id
- 1,
481 lttng_consumer_type_str(socket
->type
));
482 ret
= consumer_check_rotation_pending_relay(socket
,
485 session
->current_archive_id
- 1);
486 pthread_mutex_unlock(socket
->lock
);
489 /* Rotation was completed on the relay. */
490 DBG("[rotation-thread] Relay rotation of trace archive %" PRIu64
" of session \"%s\" was completed",
491 session
->current_archive_id
- 1,
493 } else if (ret
== 1) {
494 /* Rotation pending on relay. */
495 DBG("[rotation-thread] Relay rotation of trace archive %" PRIu64
" of session \"%s\" is pending",
496 session
->current_archive_id
- 1,
498 rotation_completed
= false;
500 /* Not a fatal error. */
501 ERR("[rotation-thread] Encountered an error when checking if rotation of trace archive %" PRIu64
" of session \"%s\" is pending on the relay",
502 session
->current_archive_id
- 1,
504 ret
= session_reset_rotation_state(session
,
505 LTTNG_ROTATION_STATE_ERROR
);
507 ERR("Failed to reset rotation state of session \"%s\"",
510 rotation_completed
= false;
515 if (rotation_completed
) {
516 DBG("[rotation-thread] Rotation of trace archive %" PRIu64
" of session \"%s\" is complete on the relay",
517 session
->current_archive_id
- 1,
519 session
->rotation_pending_relay
= false;
525 * Check if the last rotation was completed, called with session lock held.
528 int check_session_rotation_pending(struct ltt_session
*session
,
529 struct notification_thread_handle
*notification_thread_handle
)
532 struct lttng_trace_archive_location
*location
;
535 DBG("[rotation-thread] Checking for pending rotation on session \"%s\", trace archive %" PRIu64
,
536 session
->name
, session
->current_archive_id
- 1);
538 if (session
->rotation_pending_local
) {
539 /* Updates session->rotation_pending_local as needed. */
540 ret
= check_session_rotation_pending_local(session
);
546 * No need to check for a pending rotation on the relay
547 * since the rotation is not even completed locally yet.
549 if (session
->rotation_pending_local
) {
554 if (session
->rotation_pending_relay
) {
555 /* Updates session->rotation_pending_relay as needed. */
556 ret
= check_session_rotation_pending_relay(session
);
561 if (session
->rotation_pending_relay
) {
566 DBG("[rotation-thread] Rotation of trace archive %" PRIu64
" completed for "
567 "session %s", session
->current_archive_id
- 1,
570 /* Rename the completed trace archive's location. */
572 if (now
== (time_t) -1) {
573 ret
= session_reset_rotation_state(session
,
574 LTTNG_ROTATION_STATE_ERROR
);
576 ERR("Failed to reset rotation state of session \"%s\"",
583 ret
= rename_completed_chunk(session
, now
);
585 ERR("Failed to rename completed rotation chunk");
588 session
->last_chunk_start_ts
= session
->current_chunk_start_ts
;
591 * Now we can clear the "ONGOING" state in the session. New
592 * rotations can start now.
594 session
->rotation_state
= LTTNG_ROTATION_STATE_COMPLETED
;
596 /* Ownership of location is transferred. */
597 location
= session_get_trace_archive_location(session
);
598 ret
= notification_thread_command_session_rotation_completed(
599 notification_thread_handle
,
603 session
->current_archive_id
,
605 if (ret
!= LTTNG_OK
) {
606 ERR("[rotation-thread] Failed to notify notification thread of completed rotation for session %s",
610 if (!session
->active
) {
612 * A stop command was issued during the rotation, it is
613 * up to the rotation completion check to perform the
614 * renaming of the last chunk that was produced.
616 ret
= notification_thread_command_session_rotation_ongoing(
617 notification_thread_handle
,
621 session
->current_archive_id
);
622 if (ret
!= LTTNG_OK
) {
623 ERR("[rotation-thread] Failed to notify notification thread of completed rotation for session %s",
627 ret
= rename_active_chunk(session
);
629 ERR("[rotation-thread] Failed to rename active rotation chunk");
633 /* Ownership of location is transferred. */
634 location
= session_get_trace_archive_location(session
);
635 ret
= notification_thread_command_session_rotation_completed(
636 notification_thread_handle
,
640 session
->current_archive_id
,
642 if (ret
!= LTTNG_OK
) {
643 ERR("[rotation-thread] Failed to notify notification thread of completed rotation for session %s",
650 if (session
->rotation_state
== LTTNG_ROTATION_STATE_ONGOING
) {
651 DBG("[rotation-thread] Rotation of trace archive %" PRIu64
" is still pending for session %s",
652 session
->current_archive_id
- 1, session
->name
);
653 ret
= timer_session_rotation_pending_check_start(session
,
654 DEFAULT_ROTATE_PENDING_TIMER
);
656 ERR("Re-enabling rotate pending timer");
665 /* Call with the session and session_list locks held. */
667 int launch_session_rotation(struct ltt_session
*session
)
670 struct lttng_rotate_session_return rotation_return
;
672 DBG("[rotation-thread] Launching scheduled time-based rotation on session \"%s\"",
675 ret
= cmd_rotate_session(session
, &rotation_return
);
676 if (ret
== LTTNG_OK
) {
677 DBG("[rotation-thread] Scheduled time-based rotation successfully launched on session \"%s\"",
680 /* Don't consider errors as fatal. */
681 DBG("[rotation-thread] Scheduled time-based rotation aborted for session %s: %s",
682 session
->name
, lttng_strerror(ret
));
688 int run_job(struct rotation_thread_job
*job
, struct ltt_session
*session
,
689 struct notification_thread_handle
*notification_thread_handle
)
694 case ROTATION_THREAD_JOB_TYPE_SCHEDULED_ROTATION
:
695 ret
= launch_session_rotation(session
);
697 case ROTATION_THREAD_JOB_TYPE_CHECK_PENDING_ROTATION
:
698 ret
= check_session_rotation_pending(session
,
699 notification_thread_handle
);
708 int handle_job_queue(struct rotation_thread_handle
*handle
,
709 struct rotation_thread
*state
,
710 struct rotation_thread_timer_queue
*queue
)
713 int fd
= lttng_pipe_get_readfd(queue
->event_pipe
);
716 ret
= lttng_read(fd
, &buf
, 1);
718 ERR("[rotation-thread] Failed to read from wakeup pipe (fd = %i)", fd
);
724 struct ltt_session
*session
;
725 struct rotation_thread_job
*job
;
727 /* Take the queue lock only to pop an element from the list. */
728 pthread_mutex_lock(&queue
->lock
);
729 if (cds_list_empty(&queue
->list
)) {
730 pthread_mutex_unlock(&queue
->lock
);
733 job
= cds_list_first_entry(&queue
->list
,
735 cds_list_del(&job
->head
);
736 pthread_mutex_unlock(&queue
->lock
);
739 session
= job
->session
;
741 DBG("[rotation-thread] Session \"%s\" not found",
744 * This is a non-fatal error, and we cannot report it to
745 * the user (timer), so just print the error and
746 * continue the processing.
748 * While the timer thread will purge pending signals for
749 * a session on the session's destruction, it is
750 * possible for a job targeting that session to have
751 * already been queued before it was destroyed.
753 session_unlock_list();
755 session_put(session
);
759 session_lock(session
);
760 ret
= run_job(job
, session
, handle
->notification_thread_handle
);
761 session_unlock(session
);
762 session_put(session
);
763 session_unlock_list();
777 int handle_condition(const struct lttng_condition
*condition
,
778 const struct lttng_evaluation
*evaluation
,
779 struct notification_thread_handle
*notification_thread_handle
)
782 const char *condition_session_name
= NULL
;
783 enum lttng_condition_type condition_type
;
784 enum lttng_condition_status condition_status
;
785 enum lttng_evaluation_status evaluation_status
;
787 struct ltt_session
*session
;
789 condition_type
= lttng_condition_get_type(condition
);
791 if (condition_type
!= LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE
) {
793 ERR("[rotation-thread] Condition type and session usage type are not the same");
797 /* Fetch info to test */
798 condition_status
= lttng_condition_session_consumed_size_get_session_name(
799 condition
, &condition_session_name
);
800 if (condition_status
!= LTTNG_CONDITION_STATUS_OK
) {
801 ERR("[rotation-thread] Session name could not be fetched");
805 evaluation_status
= lttng_evaluation_session_consumed_size_get_consumed_size(evaluation
,
807 if (evaluation_status
!= LTTNG_EVALUATION_STATUS_OK
) {
808 ERR("[rotation-thread] Failed to get evaluation");
814 session
= session_find_by_name(condition_session_name
);
817 session_unlock_list();
818 ERR("[rotation-thread] Session \"%s\" not found",
819 condition_session_name
);
822 session_lock(session
);
823 session_unlock_list();
825 ret
= unsubscribe_session_consumed_size_rotation(session
,
826 notification_thread_handle
);
831 ret
= cmd_rotate_session(session
, NULL
);
832 if (ret
== -LTTNG_ERR_ROTATION_PENDING
) {
833 DBG("Rotate already pending, subscribe to the next threshold value");
834 } else if (ret
!= LTTNG_OK
) {
835 ERR("[rotation-thread] Failed to rotate on size notification with error: %s",
836 lttng_strerror(ret
));
840 ret
= subscribe_session_consumed_size_rotation(session
,
841 consumed
+ session
->rotate_size
,
842 notification_thread_handle
);
844 ERR("[rotation-thread] Failed to subscribe to session consumed size condition");
850 session_unlock(session
);
851 session_put(session
);
857 int handle_notification_channel(int fd
,
858 struct rotation_thread_handle
*handle
,
859 struct rotation_thread
*state
)
862 bool notification_pending
;
863 struct lttng_notification
*notification
= NULL
;
864 enum lttng_notification_channel_status status
;
865 const struct lttng_evaluation
*notification_evaluation
;
866 const struct lttng_condition
*notification_condition
;
868 status
= lttng_notification_channel_has_pending_notification(
869 rotate_notification_channel
, ¬ification_pending
);
870 if (status
!= LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
) {
871 ERR("[rotation-thread ]Error occurred while checking for pending notification");
876 if (!notification_pending
) {
881 /* Receive the next notification. */
882 status
= lttng_notification_channel_get_next_notification(
883 rotate_notification_channel
,
887 case LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
:
889 case LTTNG_NOTIFICATION_CHANNEL_STATUS_NOTIFICATIONS_DROPPED
:
890 /* Not an error, we will wait for the next one */
893 case LTTNG_NOTIFICATION_CHANNEL_STATUS_CLOSED
:
894 ERR("Notification channel was closed");
898 /* Unhandled conditions / errors. */
899 ERR("Unknown notification channel status");
904 notification_condition
= lttng_notification_get_condition(notification
);
905 notification_evaluation
= lttng_notification_get_evaluation(notification
);
907 ret
= handle_condition(notification_condition
, notification_evaluation
,
908 handle
->notification_thread_handle
);
911 lttng_notification_destroy(notification
);
915 void *thread_rotation(void *data
)
918 struct rotation_thread_handle
*handle
= data
;
919 struct rotation_thread thread
;
921 DBG("[rotation-thread] Started rotation thread");
924 ERR("[rotation-thread] Invalid thread context provided");
928 rcu_register_thread();
931 health_register(health_sessiond
, HEALTH_SESSIOND_TYPE_ROTATION
);
932 health_code_update();
934 ret
= init_thread_state(handle
, &thread
);
939 /* Ready to handle client connections. */
940 sessiond_notify_ready();
946 DBG("[rotation-thread] Entering poll wait");
947 ret
= lttng_poll_wait(&thread
.events
, -1);
948 DBG("[rotation-thread] Poll wait returned (%i)", ret
);
952 * Restart interrupted system call.
954 if (errno
== EINTR
) {
957 ERR("[rotation-thread] Error encountered during lttng_poll_wait (%i)", ret
);
962 for (i
= 0; i
< fd_count
; i
++) {
963 int fd
= LTTNG_POLL_GETFD(&thread
.events
, i
);
964 uint32_t revents
= LTTNG_POLL_GETEV(&thread
.events
, i
);
966 DBG("[rotation-thread] Handling fd (%i) activity (%u)",
969 if (revents
& LPOLLERR
) {
970 ERR("[rotation-thread] Polling returned an error on fd %i", fd
);
974 if (sessiond_check_thread_quit_pipe(fd
, revents
)) {
975 DBG("[rotation-thread] Quit pipe activity");
976 /* TODO flush the queue. */
978 } else if (fd
== lttng_pipe_get_readfd(handle
->rotation_timer_queue
->event_pipe
)) {
979 ret
= handle_job_queue(handle
, &thread
,
980 handle
->rotation_timer_queue
);
982 ERR("[rotation-thread] Failed to handle rotation timer pipe event");
985 } else if (fd
== rotate_notification_channel
->socket
) {
986 ret
= handle_notification_channel(fd
, handle
,
989 ERR("[rotation-thread] Error occurred while handling activity on notification channel socket");
997 DBG("[rotation-thread] Exit");
998 fini_thread_state(&thread
);
999 health_unregister(health_sessiond
);
1000 rcu_thread_offline();
1001 rcu_unregister_thread();