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/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/WaitQueue.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/time/Time.h"
#include "pedigree/kernel/utilities/StaticCord.h"
#include "pedigree/kernel/utilities/StaticString.h"
 
#include <config.h>
 
class String;
class StringView;
class Cord;
class Thread;
 
typedef StaticCord<8> LogCord;
 
#define LOG_AT_LEVEL(level, text, lock)                   \
  do {                                                    \
    Log::LogEntry __log_macro_logentry;                   \
    __log_macro_logentry << level << text;                \
    if (!lock)                                            \
      __log_macro_logentry << Unlocked;                   \
    Log::instance().addEntry(__log_macro_logentry, lock); \
  } while (0)
 
#if 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)
 
#if PEDANTIC_PEDIGREE
#define PEDANTRY FATAL
#else
#define PEDANTRY WARNING
#endif
 
#else  // 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)
#define PEDANTRY(text)
 
#endif
 
#define LOG_LENGTH 128
// 64K static log buffer
#define LOG_ENTRIES ((1 << 16) / sizeof(LogEntry))
#define LOG_CALLBACK_COUNT 16
 
enum NumberType {
  Hex,
  Dec,
  Oct
};
 
enum LogEntryModifier {
  Unlocked,
  NoTimestamp,
};
 
// 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, bool locked = true) = 0;
    virtual ~LogCallback();
  };
 
  enum SeverityLevel { Debug = 0, Notice, Warning, Error, Fatal };
 
  Spinlock m_Lock;
 
  EXPORTED_PUBLIC static Log& instance();
 
  void initialise1();
 
  void initialise2();
 
  EXPORTED_PUBLIC bool installCallback(LogCallback* pCallback, bool bSkipBacklog = false);
 
  EXPORTED_PUBLIC bool removeCallback(LogCallback* pCallback);
 
  EXPORTED_PUBLIC void addEntry(const LogEntry& entry, 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;
    bool lockfree = false;
    bool showTimestamp = true;
 
    LogEntry& operator<<(const char*);
    template <size_t N>
    LogEntry& operator<<(const char (&str)[N]) {
      str.appendBytes(str, N);
      return *this;
    }
    LogEntry& operator<<(const String&);
    LogEntry& operator<<(const StringView&);
    LogEntry& operator<<(const Cord&);
    template <size_t N>
    LogEntry& operator<<(const StaticString<N>& s) {
      str.appendBytes(s, s.length());
      return *this;
    }
    LogEntry& operator<<(const TinyStaticString&);
    LogEntry& operator<<(const NormalStaticString&);
    LogEntry& operator<<(const LargeStaticString&);
    LogEntry& operator<<(const HugeStaticString&);
    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);
    LogEntry& operator<<(LogEntryModifier modifier);
  };
 
  typedef LogEntry StaticLogEntry;
  typedef LogEntry DynamicLogEntry;
 
  const StaticLogEntry& getStaticEntry(size_t n) const;
  const DynamicLogEntry& getDynamicEntry(size_t n) const;
 
  EXPORTED_PUBLIC size_t copyText(char* buffer, size_t capacity);
 
  static constexpr size_t textCapacity() {
    return LOG_ENTRIES * (LOG_LENGTH + 4);
  }
 
  bool echoToSerial();
 
  const LogEntry& getLatestEntry() const;
 
  void enableTimestamps();
  void disableTimestamps();
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  using CallbackPinHook = void (*)(LogCallback* callback);
  using EntrySnapshotHook = void (*)(const LogEntry& entry);
 
  EXPORTED_PUBLIC static void setCallbackPinHook(CallbackPinHook hook);
  EXPORTED_PUBLIC static void setEntrySnapshotHook(EntrySnapshotHook hook);
#endif
 
 private:
  struct CallbackSlot {
    LogCallback* callback;
    size_t inFlight;
    size_t removers;
    bool enabled;
  };
 
  struct CallbackPin {
    CallbackSlot* slot;
    LogCallback* callback;
    void* owner;
    CallbackPin* next;
  };
 
  Log();
  ~Log();
  Log(const Log&);
  Log& operator=(const Log&);
 
  const NormalStaticString& getTimestamp();
 
  const TinyStaticString& severityToString(SeverityLevel level) const;
 
  size_t snapshotCallbacks(CallbackPin pins[LOG_CALLBACK_COUNT]);
  bool pinCallback(CallbackSlot* slot, CallbackPin& pin);
  bool callbackEnabled(const CallbackPin& pin);
  void releaseCallback(CallbackPin& pin);
  void dispatchCallbacks(CallbackPin pins[LOG_CALLBACK_COUNT], size_t count, const LogCord& message,
                         bool locked);
  void dispatchCallback(CallbackSlot* slot, const LogCord& message, bool locked);
  void* currentCallbackOwner();
  bool isCallbackContext(void* owner);
  void clearCallback(CallbackSlot* slot);
 
  StaticLogEntry m_StaticLog[LOG_ENTRIES];
  //  Vector<DynamicLogEntry*> m_DynamicLog;
  size_t m_StaticEntries;
 
  size_t m_StaticEntryStart, m_StaticEntryEnd;
 
  bool m_EchoToSerial;
 
  WaitQueue m_CallbackWaiters;
  CallbackSlot m_OutputCallbacks[LOG_CALLBACK_COUNT];
  CallbackPin* m_ActiveCallbackPins;
  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;
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  static CallbackPinHook m_CallbackPinHook;
  static EntrySnapshotHook m_EntrySnapshotHook;
#endif
};
 
#endif