#include <lttng/rotate-internal.hpp>
#include <lttng/trigger/trigger.h>
+#include <fcntl.h>
#include <inttypes.h>
#include <memory>
#include <signal.h>
struct rotation_thread_job {
using uptr = std::unique_ptr<
rotation_thread_job,
- lttng::details::create_unique_class<rotation_thread_job, lttng::free>>;
+ lttng::memory::create_deleter_class<rotation_thread_job, lttng::free>::deleter>;
enum ls::rotation_thread_job_type type;
struct ltt_session *session;
free(queue);
}
-ls::rotation_thread::rotation_thread(
- rotation_thread_timer_queue& rotation_timer_queue,
- notification_thread_handle& notification_thread_handle) :
- _rotation_timer_queue{ rotation_timer_queue },
- _notification_thread_handle{ notification_thread_handle }
+ls::rotation_thread::rotation_thread(rotation_thread_timer_queue& rotation_timer_queue,
+ notification_thread_handle& notification_thread_handle) :
+ _rotation_timer_queue(rotation_timer_queue),
+ _notification_thread_handle(notification_thread_handle)
{
_quit_pipe.reset([]() {
auto raw_pipe = lttng_pipe_open(FD_CLOEXEC);
}
void ls::rotation_thread_enqueue_job(ls::rotation_thread_timer_queue *queue,
- ls::rotation_thread_job_type job_type,
- ltt_session *session)
+ ls::rotation_thread_job_type job_type,
+ ltt_session *session)
{
const char dummy = '!';
struct rotation_thread_job *job = nullptr;
}
session_lock_list();
- const auto unlock_list = lttng::make_scope_exit([]() noexcept { session_unlock_list(); });
+ const auto unlock_list =
+ lttng::make_scope_exit([]() noexcept { session_unlock_list(); });
/* locked_ptr will unlock the session and release the ref held by the job. */
session_lock(job->session);
}
}
-void ls::rotation_thread::_handle_notification(const lttng_notification ¬ification)
+void ls::rotation_thread::_handle_notification(const lttng_notification& notification)
{
int ret = 0;
const char *condition_session_name = nullptr;
DBG_FMT("Handling descriptor activity: fd={}, events={:b}", fd, revents);
if (revents & LPOLLERR) {
- LTTNG_THROW_ERROR(
- fmt::format("Polling returned an error on fd: fd={}", fd));
+ LTTNG_THROW_ERROR(lttng::format(
+ "Polling returned an error on fd: fd={}", fd));
}
if (fd == _notification_channel->socket ||
}
if (fd == _notification_channel_subscribtion_change_eventfd.fd()) {
- _notification_channel_subscribtion_change_eventfd.decrement();
+ _notification_channel_subscribtion_change_eventfd
+ .decrement();
}
} else {
/* Job queue or quit pipe activity. */
if (lttng_read(fd, &buf, 1) != 1) {
LTTNG_THROW_POSIX(
- fmt::format(
+ lttng::format(
"Failed to read from wakeup pipe: fd={}",
fd),
errno);
}
void ls::rotation_thread::subscribe_session_consumed_size_rotation(ltt_session& session,
- std::uint64_t size)
+ std::uint64_t size)
{
const struct lttng_credentials session_creds = {
.uid = LTTNG_OPTIONAL_INIT_VALUE(session.uid),
auto condition_status =
lttng_condition_session_consumed_size_set_threshold(rotate_condition.get(), size);
if (condition_status != LTTNG_CONDITION_STATUS_OK) {
- LTTNG_THROW_ERROR(fmt::format(
+ LTTNG_THROW_ERROR(lttng::format(
"Could not set session consumed size condition threshold: size={}", size));
}
- condition_status = lttng_condition_session_consumed_size_set_session_name(rotate_condition.get(),
- session.name);
+ condition_status = lttng_condition_session_consumed_size_set_session_name(
+ rotate_condition.get(), session.name);
if (condition_status != LTTNG_CONDITION_STATUS_OK) {
- LTTNG_THROW_ERROR(fmt::format(
+ LTTNG_THROW_ERROR(lttng::format(
"Could not set session consumed size condition session name: name=`{}`",
session.name));
}
/* trigger acquires its own reference to condition and action on success. */
auto trigger = lttng::make_unique_wrapper<lttng_trigger, lttng_trigger_put>(
lttng_trigger_create(rotate_condition.get(), notify_action.get()));
- if (!trigger)
- {
+ if (!trigger) {
LTTNG_THROW_POSIX("Could not create size-based rotation trigger", errno);
}
lttng_trigger_set_hidden(trigger.get());
lttng_trigger_set_credentials(trigger.get(), &session_creds);
- auto nc_status =
- lttng_notification_channel_subscribe(_notification_channel.get(), rotate_condition.get());
+ auto nc_status = lttng_notification_channel_subscribe(_notification_channel.get(),
+ rotate_condition.get());
if (nc_status != LTTNG_NOTIFICATION_CHANNEL_STATUS_OK) {
LTTNG_THROW_ERROR("Could not subscribe to session consumed size notification");
}
&_notification_thread_handle, trigger.get(), true);
if (register_ret != LTTNG_OK) {
LTTNG_THROW_CTL(
- fmt::format(
+ lttng::format(
"Failed to register trigger for automatic size-based rotation: session_name{}, size={}",
session.name,
size),
_notification_channel.get(),
lttng_trigger_get_const_condition(session.rotate_trigger));
if (unsubscribe_status != LTTNG_NOTIFICATION_CHANNEL_STATUS_OK) {
- LTTNG_THROW_ERROR(fmt::format(
+ LTTNG_THROW_ERROR(lttng::format(
"Failed to unsubscribe from consumed size condition used to control automatic size-based rotations: session_name=`{}` return_code={}",
session.name,
static_cast<int>(unsubscribe_status)));
&_notification_thread_handle, session.rotate_trigger);
if (unregister_status != LTTNG_OK) {
LTTNG_THROW_CTL(
- fmt::format(
+ lttng::format(
"Failed to unregister trigger for automatic size-based rotation: session_name{}",
session.name),
unregister_status);