Log.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef KERNEL_LOG_H
#define KERNEL_LOG_H

#include "pedigree/kernel/compiler.h"
#ifdef THREADS
#include "pedigree/kernel/Spinlock.h"
#endif
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/StaticString.h"
#include "pedigree/kernel/utilities/StaticCord.h"
#include "pedigree/kernel/time/Time.h"

class String;
class StringView;

#define SHOW_FILE_IN_LOGS 0

typedef StaticCord<8> LogCord;

#if SHOW_FILE_IN_LOGS
#define FILE_LOG(entry, level)                                             \
    do                                                                     \
    {                                                                      \
        entry << level << __FILE__ << ":" << Dec << __LINE__ << Hex << " " \
              << __FUNCTION__ << " -- ";                                   \
    } while (0)
#else
#define FILE_LOG(entry, level)
#endif

#define LOG_AT_LEVEL(level, text, lock)                       \
    do                                                        \
    {                                                         \
        Log::LogEntry __log_macro_logentry;                   \
        FILE_LOG(__log_macro_logentry, level);                \
        __log_macro_logentry << level << text;                \
        Log::instance().addEntry(__log_macro_logentry, lock); \
    } while (0)

#ifndef NO_LOGGING

#if DEBUG_LOGGING
#define DEBUG_LOG(text) LOG_AT_LEVEL(Log::Debug, text, 1)
#define DEBUG_LOG_NOLOCK(text) LOG_AT_LEVEL(Log::Debug, text, 0)
#else
#define DEBUG_LOG(text)
#define DEBUG_LOG_NOLOCK(text)
#endif

#define NOTICE(text) LOG_AT_LEVEL(Log::Notice, text, 1)
#define NOTICE_NOLOCK(text) LOG_AT_LEVEL(Log::Notice, text, 0)

#define WARNING(text) LOG_AT_LEVEL(Log::Warning, text, 1)
#define WARNING_NOLOCK(text) LOG_AT_LEVEL(Log::Warning, text, 0)

#define ERROR(text) LOG_AT_LEVEL(Log::Error, text, 1)
#define ERROR_NOLOCK(text) LOG_AT_LEVEL(Log::Error, text, 0)

#define FATAL(text)                        \
    do                                     \
    {                                      \
        LOG_AT_LEVEL(Log::Fatal, text, 1); \
        while (1)                          \
            ;                              \
    } while (0)
#define FATAL_NOLOCK(text)                 \
    do                                     \
    {                                      \
        LOG_AT_LEVEL(Log::Fatal, text, 0); \
        while (1)                          \
            ;                              \
    } while (0)

#else  // NO_LOGGING

#define DEBUG_LOG(text)
#define DEBUG_LOG_NOLOCK(text)
#define NOTICE(text)
#define NOTICE_NOLOCK(text)
#define WARNING(text)
#define WARNING_NOLOCK(text)
#define ERROR(text)
#define ERROR_NOLOCK(text)
#define FATAL(text)
#define FATAL_NOLOCK(text)

#endif

#define LOG_LENGTH 128

#ifdef HUGE_STATIC_LOG
// 2MB static log buffer
#define LOG_ENTRIES ((1 << 21) / sizeof(LogEntry))
#else
// 64K static log buffer
#define LOG_ENTRIES ((1 << 16) / sizeof(LogEntry))
#endif

#define LOG_CALLBACK_COUNT 16

enum NumberType
{
    Hex,
    Dec,
    Oct
};

enum Modifier
{
    Flush
};

// Function pointer to update boot progress -
// Description.
typedef void (*BootProgressUpdateFn)(const char *);

extern size_t g_BootProgressCurrent;
extern size_t g_BootProgressTotal;
extern BootProgressUpdateFn g_BootProgressUpdate;

extern void installSerialLogger();

class Log
{
  public:
    struct LogEntry;

    class EXPORTED_PUBLIC LogCallback
    {
      public:
        virtual void callback(const LogCord &cord) = 0;
        virtual ~LogCallback();
    };

    enum SeverityLevel
    {
        Debug = 0,
        Notice,
        Warning,
        Error,
        Fatal
    };

#ifdef THREADS
    Spinlock m_Lock;
#endif

    EXPORTED_PUBLIC static Log &instance();

    void initialise1();

    void initialise2();

    EXPORTED_PUBLIC void
    installCallback(LogCallback *pCallback, bool bSkipBacklog = false);

    EXPORTED_PUBLIC void removeCallback(LogCallback *pCallback);

    EXPORTED_PUBLIC Log &operator<<(const LogEntry &entry);

    EXPORTED_PUBLIC Log &operator<<(Modifier type);

    EXPORTED_PUBLIC void
    addEntry(const LogEntry &entry, bool lock = true, bool flush = true);

    void flushEntry(bool lock = true);

    size_t getStaticEntryCount() const;
    size_t getDynamicEntryCount() const;

    struct EXPORTED_PUBLIC LogEntry
    {
        LogEntry();

        unsigned int timestamp;
        SeverityLevel severity;
        StaticString<LOG_LENGTH> str;
        NumberType numberType;

        LogEntry &operator<<(const char *);
        LogEntry &operator<<(const String &);
        LogEntry &operator<<(const StringView &);
        LogEntry &operator<<(char *append_str);
        LogEntry &operator<<(bool b);
        template <class T>
        LogEntry &operator<<(T *p)
        {
            // Preserve the current number type but always print pointers as
            // hex.
            NumberType currentNumberType = numberType;
            return (*this) << Hex << (reinterpret_cast<uintptr_t>(p))
                           << currentNumberType;
        }
        template <class T>
        LogEntry &operator<<(T n);

        LogEntry &operator<<(SeverityLevel level);
        LogEntry &operator<<(NumberType type);
    };

    typedef LogEntry StaticLogEntry;
    typedef LogEntry DynamicLogEntry;

    const StaticLogEntry &getStaticEntry(size_t n) const;
    const DynamicLogEntry &getDynamicEntry(size_t n) const;

    bool echoToSerial();

    const LogEntry &getLatestEntry() const;

    void enableTimestamps();
    void disableTimestamps();

  private:
    Log();
    ~Log();
    Log(const Log &);
    Log &operator=(const Log &);

    const NormalStaticString &getTimestamp();

    const TinyStaticString &severityToString(SeverityLevel level) const;

    StaticLogEntry m_StaticLog[LOG_ENTRIES];
    //  Vector<DynamicLogEntry*> m_DynamicLog;
    size_t m_StaticEntries;

    size_t m_StaticEntryStart, m_StaticEntryEnd;

    StaticLogEntry m_Buffer;

    bool m_EchoToSerial;

    LogCallback *m_OutputCallbacks[LOG_CALLBACK_COUNT];
    size_t m_nOutputCallbacks;

    EXPORTED_PUBLIC static Log m_Instance;

    uint64_t m_LastEntryHash;

    SeverityLevel m_LastEntrySeverity;

    size_t m_HashMatchedCount;

    bool m_Timestamps;

    Time::Timestamp m_LastTime;

    NormalStaticString m_CachedTimestamp;

    static TinyStaticString m_DebugSeverityString;
    static TinyStaticString m_NoticeSeverityString;
    static TinyStaticString m_WarningSeverityString;
    static TinyStaticString m_ErrorSeverityString;
    static TinyStaticString m_FatalSeverityString;

    static TinyStaticString m_LineEnding;

    static NormalStaticString m_DedupeHead;
    static TinyStaticString m_DedupeTail;
};

#endif