Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0c055863 authored by Dan Albert's avatar Dan Albert
Browse files

Support logging to other log buffers. 

LOGTO(dest, severity) and PLOGTO(dest, severity) log to other log
buffers. For example, `LOGTO(SYSTEM, FATAL) << "Foobar";`.

Change-Id: Id1ca1c8fdae72d69b73945ae9b006525d0be1582
parent 8ea5dd8c

base/include/base/logging.h

+38 −22
Original line number Diff line number Diff line
@@ -34,6 +34,11 @@ enum LogSeverity { 
  FATAL,

};



enum LogId {

  MAIN,

  SYSTEM,

};



// Configure logging based on ANDROID_LOG_TAGS environment variable.

// We need to parse a string that looks like

//
@@ -61,14 +66,25 @@ extern const char* ProgramInvocationShortName(); 
//

//     LOG(FATAL) << "We didn't expect to reach here";

#define LOG(severity)                                                    \

  ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::severity, \

                              -1).stream()

  ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::MAIN, \

                              ::android::base::severity, -1).stream()



// Logs a message to logcat with the specified log ID on Android otherwise to

// stderr. If the severity is FATAL it also causes an abort.

#define LOG_TO(dest, severity)                                           \

  ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::dest, \

                              ::android::base::severity, -1).stream()



// A variant of LOG that also logs the current errno value. To be used when

// library calls fail.

#define PLOG(severity)                                                   \

  ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::severity, \

                              errno).stream()

  ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::MAIN, \

                              ::android::base::severity, errno).stream()



// Behaves like PLOG, but logs to the specified log ID.

#define PLOG_TO(dest, severity)                                          \

  ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::dest, \

                              ::android::base::severity, errno).stream()



// Marker that code is yet to be implemented.

#define UNIMPLEMENTED(level) \
@@ -82,8 +98,8 @@ extern const char* ProgramInvocationShortName(); 
//       "Check failed: false == true".

#define CHECK(x)                                                         \

  if (UNLIKELY(!(x)))                                                    \

    ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::FATAL, \

                                -1).stream()                                \

  ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::MAIN, \

                              ::android::base::FATAL, -1).stream()       \

      << "Check failed: " #x << " "



// Helper for CHECK_xx(x,y) macros.
@@ -91,8 +107,8 @@ extern const char* ProgramInvocationShortName(); 
  for (auto _values = ::android::base::MakeEagerEvaluator(LHS, RHS);     \

       UNLIKELY(!(_values.lhs OP _values.rhs));                          \

       /* empty */)                                                      \

  ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::FATAL, -1) \

          .stream()                                                           \

  ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::MAIN, \

                              ::android::base::FATAL, -1).stream()       \

      << "Check failed: " << #LHS << " " << #OP << " " << #RHS           \

      << " (" #LHS "=" << _values.lhs << ", " #RHS "=" << _values.rhs << ") "
@@ -228,8 +244,8 @@ class LogMessageData; 
// of a CHECK. The destructor will abort if the severity is FATAL.

class LogMessage {

 public:

  LogMessage(const char* file, unsigned int line, LogSeverity severity,

             int error);

  LogMessage(const char* file, unsigned int line, LogId id,

             LogSeverity severity, int error);



  ~LogMessage();
@@ -238,8 +254,8 @@ class LogMessage { 
  std::ostream& stream();



  // The routine that performs the actual logging.

  static void LogLine(const char* file, unsigned int line, LogSeverity severity,

                      const char* msg);

  static void LogLine(const char* file, unsigned int line, LogId id,

                      LogSeverity severity, const char* msg);



 private:

  const std::unique_ptr<LogMessageData> data_;

base/logging.cpp

+28 −12
Original line number Diff line number Diff line
@@ -128,9 +128,13 @@ void InitLogging(char* argv[]) { 
// checks/logging in a function.

class LogMessageData {

 public:

  LogMessageData(const char* file, unsigned int line, LogSeverity severity,

                 int error)

      : file_(file), line_number_(line), severity_(severity), error_(error) {

  LogMessageData(const char* file, unsigned int line, LogId id,

                 LogSeverity severity, int error)

      : file_(file),

        line_number_(line),

        id_(id),

        severity_(severity),

        error_(error) {

    const char* last_slash = strrchr(file, '/');

    file = (last_slash == nullptr) ? file : last_slash + 1;

  }
@@ -147,6 +151,10 @@ class LogMessageData { 
    return severity_;

  }



  LogId GetId() const {

    return id_;

  }



  int GetError() const {

    return error_;

  }
@@ -163,15 +171,16 @@ class LogMessageData { 
  std::ostringstream buffer_;

  const char* const file_;

  const unsigned int line_number_;

  const LogId id_;

  const LogSeverity severity_;

  const int error_;



  DISALLOW_COPY_AND_ASSIGN(LogMessageData);

};



LogMessage::LogMessage(const char* file, unsigned int line,

LogMessage::LogMessage(const char* file, unsigned int line, LogId id,

                       LogSeverity severity, int error)

    : data_(new LogMessageData(file, line, severity, error)) {

    : data_(new LogMessageData(file, line, id, severity, error)) {

}



LogMessage::~LogMessage() {
@@ -189,16 +198,16 @@ LogMessage::~LogMessage() { 
  {

    std::lock_guard<std::mutex> lock(logging_lock);

    if (msg.find('\n') == std::string::npos) {

      LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetSeverity(),

              msg.c_str());

      LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetId(),

              data_->GetSeverity(), msg.c_str());

    } else {

      msg += '\n';

      size_t i = 0;

      while (i < msg.size()) {

        size_t nl = msg.find('\n', i);

        msg[nl] = '\0';

        LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetSeverity(),

                &msg[i]);

        LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetId(),

                data_->GetSeverity(), &msg[i]);

        i = nl + 1;

      }

    }
@@ -224,19 +233,26 @@ static const android_LogPriority kLogSeverityToAndroidLogPriority[] = { 
static_assert(arraysize(kLogSeverityToAndroidLogPriority) == FATAL + 1,

              "Mismatch in size of kLogSeverityToAndroidLogPriority and values "

              "in LogSeverity");



static const log_id kLogIdToAndroidLogId[] = {LOG_ID_MAIN, LOG_ID_SYSTEM};

static_assert(arraysize(kLogIdToAndroidLogId) == SYSTEM + 1,

              "Mismatch in size of kLogIdToAndroidLogId and values "

              "in LogSeverity");

#endif



void LogMessage::LogLine(const char* file, unsigned int line,

void LogMessage::LogLine(const char* file, unsigned int line, LogId id,

                         LogSeverity log_severity, const char* message) {

#ifdef __ANDROID__

  const char* tag = ProgramInvocationShortName();

  int priority = kLogSeverityToAndroidLogPriority[log_severity];

  log_id lg_id = kLogIdToAndroidLogId[id];

  if (priority == ANDROID_LOG_FATAL) {

    LOG_PRI(priority, tag, "%s:%u] %s", file, line, message);

    __android_log_buf_print(lg_id, priority, tag, "%s:%u] %s", file, line, message);

  } else {

    LOG_PRI(priority, tag, "%s", message);

    __android_log_buf_print(lg_id, priority, tag, "%s", message);

  }

#else

  UNUSED(id);

  static const char* log_characters = "VDIWEF";

  CHECK_EQ(strlen(log_characters), FATAL + 1U);

  char severity = log_characters[log_severity];