*/
#define _LGPL_SOURCE
-#include <inttypes.h>
-#include <signal.h>
-
-#include "timer.hpp"
#include "health-sessiond.hpp"
#include "rotation-thread.hpp"
#include "thread.hpp"
+#include "timer.hpp"
-#define LTTNG_SESSIOND_SIG_QS SIGRTMIN + 10
-#define LTTNG_SESSIOND_SIG_EXIT SIGRTMIN + 11
-#define LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK SIGRTMIN + 12
-#define LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION SIGRTMIN + 13
+#include <inttypes.h>
+#include <signal.h>
+
+#define LTTNG_SESSIOND_SIG_QS (SIGRTMIN + 10)
+#define LTTNG_SESSIOND_SIG_EXIT (SIGRTMIN + 11)
+#define LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK (SIGRTMIN + 12)
+#define LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION (SIGRTMIN + 13)
-#define UINT_TO_PTR(value) \
- ({ \
- LTTNG_ASSERT(value <= UINTPTR_MAX); \
- (void *) (uintptr_t) value; \
+#define UINT_TO_PTR(value) \
+ ({ \
+ LTTNG_ASSERT((value) <= UINTPTR_MAX); \
+ (void *) (uintptr_t) (value); \
})
-#define PTR_TO_UINT(ptr) ((uintptr_t) ptr)
+#define PTR_TO_UINT(ptr) ((uintptr_t) (ptr))
+namespace {
/*
* Handle timer teardown race wrt memory free of private data by sessiond
* signals are handled by a single thread, which permits a synchronization
* point between handling of each signal. Internal lock ensures mutual
* exclusion.
*/
-static
struct timer_signal_data {
/* Thread managing signals. */
pthread_t tid;
.qs_done = 0,
.lock = PTHREAD_MUTEX_INITIALIZER,
};
+} /* namespace */
/*
* Set custom signal mask to current thread.
*/
-static
-void setmask(sigset_t *mask)
+static void setmask(sigset_t *mask)
{
int ret;
* returns, it means that no timer signr is currently pending or being handled
* by the timer thread. This cannot be called from the timer thread.
*/
-static
-void timer_signal_thread_qs(unsigned int signr)
+static void timer_signal_thread_qs(unsigned int signr)
{
sigset_t pending_set;
int ret;
* Returns a negative value on error, 0 if a timer was created, and
* a positive value if no timer was created (not an error).
*/
-static
-int timer_start(timer_t *timer_id, struct ltt_session *session,
- unsigned int timer_interval_us, int signal, bool one_shot)
+static int timer_start(timer_t *timer_id,
+ struct ltt_session *session,
+ unsigned int timer_interval_us,
+ int signal,
+ bool one_shot)
{
int ret = 0, delete_ret;
struct sigevent sev = {};
its.it_interval.tv_nsec = its.it_value.tv_nsec;
}
- ret = timer_settime(*timer_id, 0, &its, NULL);
+ ret = timer_settime(*timer_id, 0, &its, nullptr);
if (ret == -1) {
PERROR("timer_settime");
goto error_destroy_timer;
return ret;
}
-static
-int timer_stop(timer_t *timer_id, int signal)
+static int timer_stop(timer_t *timer_id, int signal)
{
int ret = 0;
}
timer_signal_thread_qs(signal);
- *timer_id = 0;
+ *timer_id = nullptr;
end:
return ret;
}
int timer_session_rotation_pending_check_start(struct ltt_session *session,
- unsigned int interval_us)
+ unsigned int interval_us)
{
int ret;
ret = -1;
goto end;
}
- DBG("Enabling session rotation pending check timer on session %" PRIu64,
- session->id);
+ DBG("Enabling session rotation pending check timer on session %" PRIu64, session->id);
/*
* We arm this timer in a one-shot mode so we don't have to disable it
* explicitly (which could deadlock if the timer thread is blocked
* no need to go through the whole signal teardown scheme everytime.
*/
ret = timer_start(&session->rotation_pending_check_timer,
- session, interval_us,
- LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK,
- /* one-shot */ true);
+ session,
+ interval_us,
+ LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK,
+ /* one-shot */ true);
if (ret == 0) {
session->rotation_pending_check_timer_enabled = true;
}
/*
* Call with session and session_list locks held.
*/
-int timer_session_rotation_pending_check_stop(struct ltt_session *session)
+int timer_session_rotation_pending_check_stop(ltt_session& session)
{
int ret;
- LTTNG_ASSERT(session);
- LTTNG_ASSERT(session->rotation_pending_check_timer_enabled);
+ LTTNG_ASSERT(session.rotation_pending_check_timer_enabled);
- DBG("Disabling session rotation pending check timer on session %" PRIu64,
- session->id);
- ret = timer_stop(&session->rotation_pending_check_timer,
- LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK);
+ DBG("Disabling session rotation pending check timer on session %" PRIu64, session.id);
+ ret = timer_stop(&session.rotation_pending_check_timer,
+ LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK);
if (ret == -1) {
ERR("Failed to stop rotate_pending_check timer");
} else {
- session->rotation_pending_check_timer_enabled = false;
+ session.rotation_pending_check_timer_enabled = false;
/*
* The timer's reference to the session can be released safely.
*/
- session_put(session);
+ session_put(&session);
}
+
return ret;
}
* Call with session and session_list locks held.
*/
int timer_session_rotation_schedule_timer_start(struct ltt_session *session,
- unsigned int interval_us)
+ unsigned int interval_us)
{
int ret;
ret = -1;
goto end;
}
- DBG("Enabling scheduled rotation timer on session \"%s\" (%ui %s)", session->name,
- interval_us, USEC_UNIT);
- ret = timer_start(&session->rotation_schedule_timer, session,
- interval_us, LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION,
- /* one-shot */ false);
+ DBG("Enabling scheduled rotation timer on session \"%s\" (%ui %s)",
+ session->name,
+ interval_us,
+ USEC_UNIT);
+ ret = timer_start(&session->rotation_schedule_timer,
+ session,
+ interval_us,
+ LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION,
+ /* one-shot */ false);
if (ret < 0) {
goto end;
}
}
DBG("Disabling scheduled rotation timer on session %s", session->name);
- ret = timer_stop(&session->rotation_schedule_timer,
- LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION);
+ ret = timer_stop(&session->rotation_schedule_timer, LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION);
if (ret < 0) {
- ERR("Failed to stop scheduled rotation timer of session \"%s\"",
- session->name);
+ ERR("Failed to stop scheduled rotation timer of session \"%s\"", session->name);
goto end;
}
* Block the RT signals for the entire process. It must be called from the
* sessiond main before creating the threads
*/
-int timer_signal_init(void)
+int timer_signal_init()
{
int ret;
sigset_t mask;
/* Block signal for entire process, so only our thread processes it. */
setmask(&mask);
- ret = pthread_sigmask(SIG_BLOCK, &mask, NULL);
+ ret = pthread_sigmask(SIG_BLOCK, &mask, nullptr);
if (ret) {
errno = ret;
PERROR("pthread_sigmask");
/*
* This thread is the sighandler for the timer signals.
*/
-static
-void *thread_timer(void *data)
+static void *thread_timer(void *data)
{
int signr;
sigset_t mask;
setmask(&mask);
CMM_STORE_SHARED(timer_signal.tid, pthread_self());
- while (1) {
+ while (true) {
health_code_update();
health_poll_entry();
goto end;
} else if (signr == LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK) {
struct ltt_session *session =
- (struct ltt_session *) info.si_value.sival_ptr;
+ (struct ltt_session *) info.si_value.sival_ptr;
- rotation_thread_enqueue_job(ctx->rotation_thread_job_queue,
- ROTATION_THREAD_JOB_TYPE_CHECK_PENDING_ROTATION,
- session);
+ rotation_thread_enqueue_job(
+ ctx->rotation_thread_job_queue,
+ lttng::sessiond::rotation_thread_job_type::CHECK_PENDING_ROTATION,
+ session);
} else if (signr == LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION) {
- rotation_thread_enqueue_job(ctx->rotation_thread_job_queue,
- ROTATION_THREAD_JOB_TYPE_SCHEDULED_ROTATION,
- (struct ltt_session *) info.si_value.sival_ptr);
+ rotation_thread_enqueue_job(
+ ctx->rotation_thread_job_queue,
+ lttng::sessiond::rotation_thread_job_type::SCHEDULED_ROTATION,
+ (struct ltt_session *) info.si_value.sival_ptr);
/*
* The scheduled periodic rotation timer is not in
* "one-shot" mode. The reference to the session is not
health_unregister(the_health_sessiond);
rcu_thread_offline();
rcu_unregister_thread();
- return NULL;
+ return nullptr;
}
-static
-bool shutdown_timer_thread(void *data __attribute__((unused)))
+static bool shutdown_timer_thread(void *data __attribute__((unused)))
{
return kill(getpid(), LTTNG_SESSIOND_SIG_EXIT) == 0;
}
-bool launch_timer_thread(
- struct timer_thread_parameters *timer_thread_parameters)
+bool launch_timer_thread(struct timer_thread_parameters *timer_thread_parameters)
{
struct lttng_thread *thread;
- thread = lttng_thread_create("Timer",
- thread_timer,
- shutdown_timer_thread,
- NULL,
- timer_thread_parameters);
+ thread = lttng_thread_create(
+ "Timer", thread_timer, shutdown_timer_thread, nullptr, timer_thread_parameters);
if (!thread) {
goto error;
}