kcenon::logger::security::signal_manager Class Reference

Manager for safe signal handler installation. More...

#include <signal_manager.h>

Inheritance diagram for kcenon::logger::security::signal_manager:

Collaboration diagram for kcenon::logger::security::signal_manager:

Public Member Functions
	signal_manager ()=default
	Default constructor.
	~signal_manager () override=default
	Destructor.
void	register_logger (critical_logger_interface *log) override
	Register a logger to receive signal notifications.
void	unregister_logger (critical_logger_interface *log) override
	Unregister a logger.
bool	are_handlers_installed () const override
	Check if signal handlers are installed.
size_t	logger_count () const override
	Get number of registered loggers.
	signal_manager (const signal_manager &)=delete
signal_manager &	operator= (const signal_manager &)=delete
	signal_manager (signal_manager &&)=delete
signal_manager &	operator= (signal_manager &&)=delete
Public Member Functions inherited from kcenon::logger::security::signal_manager_interface
virtual	~signal_manager_interface ()=default

Private Member Functions
void	install_handlers ()
	Install signal handlers.
void	uninstall_handlers ()
	Uninstall signal handlers.

Static Private Member Functions
static void	signal_handler (int sig)
	Signal handler (must use only signal-safe functions)
static void	emergency_flush (critical_logger_interface *log)
	Emergency flush for a logger (signal-safe)

Private Attributes
std::mutex	mutex_
std::set< critical_logger_interface * >	loggers_
std::atomic< bool >	handlers_installed_ {false}
void(*	original_sigsegv_ )(int) = SIG_DFL
void(*	original_sigabrt_ )(int) = SIG_DFL
void(*	original_sigterm_ )(int) = SIG_DFL
void(*	original_sigint_ )(int) = SIG_DFL

Static Private Attributes
static std::atomic< signal_manager * >	current_instance_ {nullptr}

Detailed Description

Manager for safe signal handler installation.

Features:

• Centralized signal handler management
• Thread-safe logger registration
• Uses only signal-safe functions in handlers
• Prevents global state conflicts when multiple loggers exist
• Implements signal_manager_interface for dependency injection

Since

2.0.0 - Converted from singleton to DI pattern

Definition at line 84 of file signal_manager.h.

Constructor & Destructor Documentation

signal_manager() [1/3]

kcenon::logger::security::signal_manager::signal_manager ( )

default

Default constructor.

~signal_manager()

kcenon::logger::security::signal_manager::~signal_manager ( )

overridedefault

Destructor.

signal_manager() [2/3]

kcenon::logger::security::signal_manager::signal_manager ( const signal_manager & )

delete

signal_manager() [3/3]

kcenon::logger::security::signal_manager::signal_manager ( signal_manager && )

delete

Member Function Documentation

are_handlers_installed()

bool kcenon::logger::security::signal_manager::are_handlers_installed ( ) const

inlineoverridevirtual

Check if signal handlers are installed.

Implements kcenon::logger::security::signal_manager_interface.

Definition at line 133 of file signal_manager.h.

                                                 {
        return handlers_installed_.load();
    }

emergency_flush()

void kcenon::logger::security::signal_manager::emergency_flush ( critical_logger_interface * log )

inlinestaticprivate

Emergency flush for a logger (signal-safe)

Parameters

log	Logger interface

Definition at line 344 of file signal_manager.h.

                                                                          {
    if (!log) {
        return;
    }
 
    // Get file descriptor
    int fd = log->get_emergency_fd();
    if (fd < 0) {
        return;
    }
 
    // Get buffer
    const char* buffer = log->get_emergency_buffer();
    size_t size = log->get_emergency_buffer_size();
 
    if (buffer && size > 0) {
        // Write using signal-safe write() syscall
        ssize_t written = 0;
        while (written < static_cast<ssize_t>(size)) {
            ssize_t n = detail::safe_write(fd, buffer + written, size - written);
            if (n <= 0) {
                break;  // Error or would block
            }
            written += n;
        }
 
        // Sync to disk (signal-safe)
        detail::safe_fsync(fd);
    }
}

References kcenon::logger::security::critical_logger_interface::get_emergency_buffer(), kcenon::logger::security::critical_logger_interface::get_emergency_buffer_size(), kcenon::logger::security::critical_logger_interface::get_emergency_fd(), kcenon::logger::security::detail::safe_fsync(), kcenon::logger::security::detail::safe_write(), and kcenon::logger::size.

Here is the call graph for this function:

install_handlers()

void kcenon::logger::security::signal_manager::install_handlers ( )

inlineprivate

Install signal handlers.

Definition at line 156 of file signal_manager.h.

                            {
        // Set current instance for signal handler
        current_instance_.store(this, std::memory_order_release);
 
        // Save original handlers
        original_sigsegv_ = std::signal(SIGSEGV, signal_handler);
        original_sigabrt_ = std::signal(SIGABRT, signal_handler);
        original_sigterm_ = std::signal(SIGTERM, signal_handler);
        original_sigint_ = std::signal(SIGINT, signal_handler);
 
        handlers_installed_.store(true);
    }

logger_count()

size_t kcenon::logger::security::signal_manager::logger_count ( ) const

inlineoverridevirtual

Get number of registered loggers.

Implements kcenon::logger::security::signal_manager_interface.

Definition at line 140 of file signal_manager.h.

                                         {
        std::lock_guard lock(mutex_);
        return loggers_.size();
    }

operator=() [1/2]

signal_manager & kcenon::logger::security::signal_manager::operator= ( const signal_manager & )

delete

operator=() [2/2]

signal_manager & kcenon::logger::security::signal_manager::operator= ( signal_manager && )

delete

register_logger()

void kcenon::logger::security::signal_manager::register_logger ( critical_logger_interface * log )

inlineoverridevirtual

Register a logger to receive signal notifications.

Parameters

log	Logger interface for emergency flushing

Signal handlers are installed when the first logger is registered.

Implements kcenon::logger::security::signal_manager_interface.

Definition at line 102 of file signal_manager.h.

                                                                  {
        std::lock_guard lock(mutex_);
 
        loggers_.insert(log);
 
        // Install handlers only on first registration
        if (loggers_.size() == 1 && !handlers_installed_.load()) {
            install_handlers();
        }
    }

signal_handler()

static void kcenon::logger::security::signal_manager::signal_handler ( int sig )

inlinestaticprivate

Signal handler (must use only signal-safe functions)

Parameters

sig	Signal number

Signal-safe functions (POSIX):

• write(), fsync(), _exit()
• Most syscalls

NOT signal-safe:

• malloc(), free()
• printf(), iostream
• std::mutex (use atomic flags instead)

Definition at line 198 of file signal_manager.h.

                                        {
        // Write signal message using only signal-safe functions
        const char* msg = nullptr;
        size_t msg_len = 0;
 
        switch (sig) {
            case SIGSEGV:
                msg = "\n[CRITICAL] SIGSEGV received - emergency flush\n";
                msg_len = 45;
                break;
            case SIGABRT:
                msg = "\n[CRITICAL] SIGABRT received - emergency flush\n";
                msg_len = 45;
                break;
            case SIGTERM:
                msg = "\n[CRITICAL] SIGTERM received - emergency flush\n";
                msg_len = 45;
                break;
            case SIGINT:
                msg = "\n[CRITICAL] SIGINT received - emergency flush\n";
                msg_len = 44;
                break;
            default:
                msg = "\n[CRITICAL] Unknown signal - emergency flush\n";
                msg_len = 43;
                break;
        }
 
        // Write to stderr (signal-safe)
        detail::safe_write(STDERR_FILENO, msg, msg_len);
 
        // Emergency flush for all registered loggers
        // Note: We cannot safely lock mutex_ here (not signal-safe)
        // Instead, we access the loggers directly (risk of race condition,
        // but in a crash scenario, this is acceptable)
        signal_manager* mgr = current_instance_.load(std::memory_order_acquire);
        if (!mgr) {
            // No instance available, nothing to flush
            _exit(128 + sig);
        }
 
        // Call emergency_flush on each logger
        // Note: This assumes the logger pointers are still valid
        // In production, consider using a signal-safe data structure
        for (auto* log : mgr->loggers_) {
            if (log) {
                emergency_flush(log);
            }
        }
 
        // Call original handler (or terminate)
        switch (sig) {
            case SIGSEGV:
                if (mgr->original_sigsegv_ != SIG_DFL &&
                    mgr->original_sigsegv_ != SIG_IGN) {
                    mgr->original_sigsegv_(sig);
                } else {
                    std::signal(SIGSEGV, SIG_DFL);
                    std::raise(SIGSEGV);
                }
                break;
            case SIGABRT:
                if (mgr->original_sigabrt_ != SIG_DFL &&
                    mgr->original_sigabrt_ != SIG_IGN) {
                    mgr->original_sigabrt_(sig);
                } else {
                    std::signal(SIGABRT, SIG_DFL);
                    std::raise(SIGABRT);
                }
                break;
            case SIGTERM:
                if (mgr->original_sigterm_ != SIG_DFL &&
                    mgr->original_sigterm_ != SIG_IGN) {
                    mgr->original_sigterm_(sig);
                } else {
                    _exit(128 + sig);
                }
                break;
            case SIGINT:
                if (mgr->original_sigint_ != SIG_DFL &&
                    mgr->original_sigint_ != SIG_IGN) {
                    mgr->original_sigint_(sig);
                } else {
                    _exit(128 + sig);
                }
                break;
            default:
                _exit(128 + sig);
        }
    }

References loggers_, original_sigabrt_, original_sigint_, original_sigsegv_, and original_sigterm_.

uninstall_handlers()

void kcenon::logger::security::signal_manager::uninstall_handlers ( )

inlineprivate

Uninstall signal handlers.

Definition at line 172 of file signal_manager.h.

                              {
        // Restore original handlers
        std::signal(SIGSEGV, original_sigsegv_);
        std::signal(SIGABRT, original_sigabrt_);
        std::signal(SIGTERM, original_sigterm_);
        std::signal(SIGINT, original_sigint_);
 
        handlers_installed_.store(false);
 
        // Clear current instance
        current_instance_.store(nullptr, std::memory_order_release);
    }

unregister_logger()

void kcenon::logger::security::signal_manager::unregister_logger ( critical_logger_interface * log )

inlineoverridevirtual

Unregister a logger.

Parameters

log	Logger to unregister

Signal handlers are removed when the last logger is unregistered.

Implements kcenon::logger::security::signal_manager_interface.

Definition at line 119 of file signal_manager.h.

                                                                    {
        std::lock_guard lock(mutex_);
 
        loggers_.erase(log);
 
        // Remove handlers when last logger is unregistered
        if (loggers_.empty() && handlers_installed_.load()) {
            uninstall_handlers();
        }
    }

Member Data Documentation

current_instance_

std::atomic< signal_manager * > kcenon::logger::security::signal_manager::current_instance_ {nullptr}

staticprivate

Current instance for signal handler (static due to C signal API limitation) Note: Only one instance can handle signals at a time

Definition at line 297 of file signal_manager.h.

handlers_installed_

std::atomic<bool> kcenon::logger::security::signal_manager::handlers_installed_ {false}

private

Definition at line 301 of file signal_manager.h.

{false};

loggers_

std::set<critical_logger_interface*> kcenon::logger::security::signal_manager::loggers_

private

Definition at line 300 of file signal_manager.h.

Referenced by signal_handler().

mutex_

std::mutex kcenon::logger::security::signal_manager::mutex_

mutableprivate

Definition at line 299 of file signal_manager.h.

original_sigabrt_

void(* kcenon::logger::security::signal_manager::original_sigabrt_) (int) = SIG_DFL

private

Definition at line 305 of file signal_manager.h.

Referenced by signal_handler().

original_sigint_

void(* kcenon::logger::security::signal_manager::original_sigint_) (int) = SIG_DFL

private

Definition at line 307 of file signal_manager.h.

Referenced by signal_handler().

original_sigsegv_

void(* kcenon::logger::security::signal_manager::original_sigsegv_) (int) = SIG_DFL

private

Definition at line 304 of file signal_manager.h.

Referenced by signal_handler().

original_sigterm_

void(* kcenon::logger::security::signal_manager::original_sigterm_) (int) = SIG_DFL

private

Definition at line 306 of file signal_manager.h.

Referenced by signal_handler().

---

The documentation for this class was generated from the following files:

• include/kcenon/logger/security/signal_manager.h
• src/security/signal_manager.cpp