logger.cpp

Go to the documentation of this file.

 
#include <common/logger.h>
#include <stdarg.h>
#include <console/framebuffer.h>
#include <common/version.h>
#include <system/cpu.h>
#include <processes/scheduler.h>
 
using namespace MaxOS;
using namespace MaxOS::common;
using namespace MaxOS::console;
using namespace MaxOS::processes;
using namespace MaxOS::system;
 
Logger::Logger()
: m_log_writers()
{
 
    s_active_logger = this;
 
    // The following line is generated automatically by the MaxOS build system.
    s_progress_total =                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               15;
 
}
 
 
Logger::~Logger() = default;
 
void Logger::add_log_writer(OutputStream* log_writer) {
 
    // If the list is not empty
    if (m_log_writer_count >= MAX_LOG_WRITERS)
        return;
 
    // Add the output stream to the list
    m_log_writers[m_log_writer_count] = log_writer;
    m_log_writers_enabled[m_log_writer_count] = true;
    m_log_writer_count++;
 
    // Print the setup info
    *this << LogLevel::INFO << "Logger setup: " << m_log_writer_count << "\n";
    *this << LogLevel::HEADER << "MaxOS v" << VERSION_STRING << " [ build " << BUILD_NUMBER << " ]\n";
 
}
 
void Logger::disable_log_writer(OutputStream* log_writer) {
 
    // If the list is empty
    if (m_log_writer_count == 0)
        return;
 
    // Find the output stream in the list
    for (int i = 0; i < m_log_writer_count; i++)
        if (m_log_writers[i] == log_writer)
            m_log_writers_enabled[i] = false;
}
 
void Logger::enable_log_writer(OutputStream* log_writer) {
 
    // If the list is empty
    if (m_log_writer_count == 0)
        return;
 
    // Find the output stream in the list
    for (int i = 0; i < m_log_writer_count; i++)
        if (m_log_writers[i] == log_writer)
            m_log_writers_enabled[i] = true;
 
}
 
void Logger::enable_all_log_writers() {
    for (int i = 0; i < m_log_writer_count; i++)
        if (!m_log_writers_enabled[i])
            m_log_writers_enabled[i] = true;
}
 
void Logger::set_log_level(LogLevel log_level) {
 
    // Set the log level
    m_log_level = log_level;
 
    // Update the progress bar
    if (log_level == LogLevel::INFO) {
        FramebufferConsole::update_progress_bar((m_progress_current * 100) / s_progress_total);
        m_progress_current++;
    }
 
    // Print the header
    switch (log_level) {
 
        case LogLevel::HEADER:
            *this << ANSI_COLOURS[FG_Blue]   << "[  BOOT    ] ";
            break;
 
        case LogLevel::INFO:
            *this << ANSI_COLOURS[FG_Cyan]   << "[  INFO    ]" << ANSI_COLOURS[FG_White] << " ";
            break;
 
        case LogLevel::TEST:
            *this << ANSI_COLOURS[FG_Green]  << "[  TEST    ]" << ANSI_COLOURS[FG_White] << " ";
            break;
 
        case LogLevel::DEBUG:
            *this << ANSI_COLOURS[FG_Yellow] << "[  DEBUG   ]" << ANSI_COLOURS[Reset] << " ";
            break;
 
        case LogLevel::WARNING:
            *this << ANSI_COLOURS[BG_Yellow] << ANSI_COLOURS[FG_White] << "[ WARNING  ]" << ANSI_COLOURS[Reset] << " ";
            break;
 
        case LogLevel::ERROR:
            *this << ANSI_COLOURS[BG_Red]   << "[  ERROR   ]" << ANSI_COLOURS[Reset] << " ";
            break;
    }
 
    GlobalScheduler::print_running_header();
}
 
 
void Logger::write_char(char c) {
 
    // Ensure logging at this level is enabled
    if (m_log_level > MAX_LOG_LEVEL)
        return;
 
    // Write the character to all output streams
    for (int i = 0; i < m_log_writer_count; i++)
        if (m_log_writers_enabled[i])
            m_log_writers[i]->write_char(c);
 
}
 
LogRecord Logger::Out() {
 
    return LogRecord(*s_active_logger, LogLevel::OUT);
}
 
LogRecord Logger::TEST() {
    return LogRecord(*s_active_logger, LogLevel::TEST);
}
 
LogRecord Logger::INFO() {
    return LogRecord(*s_active_logger, LogLevel::INFO);
}
 
LogRecord Logger::DEBUG() {
    return LogRecord(*s_active_logger, LogLevel::DEBUG);
}
 
LogRecord Logger::WARNING() {
    return LogRecord(*s_active_logger, LogLevel::WARNING);
}
 
LogRecord Logger::ERROR() {
    return LogRecord(*s_active_logger, LogLevel::ERROR);
}
 
LogRecord Logger::HEADER() {
    return LogRecord(*s_active_logger, LogLevel::HEADER);
}
 
Logger *Logger::active_logger() {
    return s_active_logger;
}
 
void Logger::printf(char const *format, ...) {
 
 
    // Create a pointer to the data
    va_list parameters;
    va_start(parameters, format);
 
    write(String::formatted(format, parameters));
}
 
void Logger::assert(bool condition, char const* message, ...) {
 
    // If the condition is met then everything is ok
    if (condition)
        return;
 
    va_list parameters;
    va_start(parameters, message);
 
    // Hang the system
    CPU::PANIC(String::formatted(message, parameters).c_str());
}
 
Logger &Logger::operator<<(LogLevel log_level) {
 
    set_log_level(log_level);
    return *this;
 
}
 
LogRecord::LogRecord(Logger& logger, LogLevel level)
: m_logger(logger)
{
 
    // Wait for the logger to be free
    Logger::s_loggers_lock.lock();
    if (level != LogLevel::OUT)
        m_logger.set_log_level(level);
}
 
LogRecord::~LogRecord() {
 
    Logger::s_loggers_lock.unlock();
 
}