Android-cuttlefish cvd tool
Classes | Namespaces | Macros | Typedefs | Enumerations | Functions | Variables
logging.h File Reference
#include <functional>
#include <memory>
#include <ostream>
#include "android-base/errno_restorer.h"
#include "android-base/macros.h"
Include dependency graph for logging.h:

Go to the source code of this file.

Classes

class  android::base::LogdLogger
 
struct  android::base::log_detail::Storage< T >
 
struct  android::base::log_detail::Storage< std::unique_ptr< T > >
 
struct  android::base::log_detail::Storage< std::shared_ptr< T > >
 
struct  android::base::log_detail::IsCharPointer< T >
 
struct  android::base::log_detail::StorageTypes< LHS, RHS >
 
struct  android::base::log_detail::EagerEvaluator< LHS, RHS >
 
struct  android::base::LogNullGuard< T >
 
struct  android::base::LogNullGuard< std::nullptr_t >
 
struct  android::base::LogNullGuard< char * >
 
struct  android::base::LogNullGuard< const char * >
 
class  android::base::LogMessage
 
class  android::base::ScopedLogSeverity
 

Namespaces

namespace  android
 
namespace  android::base
 
namespace  android::base::log_detail
 
namespace  std
 

Macros

#define __builtin_available(v1, v2)   false
 
#define _LOG_TAG_INTERNAL   nullptr
 
#define INIT_LOGGING_DEFAULT_LOGGER   StderrLogger
 
#define SEVERITY_LAMBDA(severity)
 
#define ABORT_AFTER_LOG_FATAL
 
#define ABORT_AFTER_LOG_EXPR_IF(c, x)   (x)
 
#define MUST_LOG_MESSAGE(severity)   false
 
#define ABORT_AFTER_LOG_FATAL_EXPR(x)   ABORT_AFTER_LOG_EXPR_IF(true, x)
 
#define WOULD_LOG(severity)
 
#define LOG_STREAM(severity)
 
#define LOG(severity)   LOGGING_PREAMBLE(severity) && LOG_STREAM(severity)
 
#define LOGGING_PREAMBLE(severity)
 
#define PLOG(severity)
 
#define UNIMPLEMENTED(level)    LOG(level) << __PRETTY_FUNCTION__ << " unimplemented "
 
#define CHECK(x)
 
#define CHECK_OP(LHS, RHS, OP)
 
#define CHECK_EQ(x, y)   CHECK_OP(x, y, == )
 
#define CHECK_NE(x, y)   CHECK_OP(x, y, != )
 
#define CHECK_LE(x, y)   CHECK_OP(x, y, <= )
 
#define CHECK_LT(x, y)   CHECK_OP(x, y, < )
 
#define CHECK_GE(x, y)   CHECK_OP(x, y, >= )
 
#define CHECK_GT(x, y)   CHECK_OP(x, y, > )
 
#define CHECK_STROP(s1, s2, sense)
 
#define CHECK_STREQ(s1, s2)   CHECK_STROP(s1, s2, true)
 
#define CHECK_STRNE(s1, s2)   CHECK_STROP(s1, s2, false)
 
#define CHECK_PTHREAD_CALL(call, args, what)
 
#define DCHECK(x)    if (::android::base::kEnableDChecks) CHECK(x)
 
#define DCHECK_EQ(x, y)    if (::android::base::kEnableDChecks) CHECK_EQ(x, y)
 
#define DCHECK_NE(x, y)    if (::android::base::kEnableDChecks) CHECK_NE(x, y)
 
#define DCHECK_LE(x, y)    if (::android::base::kEnableDChecks) CHECK_LE(x, y)
 
#define DCHECK_LT(x, y)    if (::android::base::kEnableDChecks) CHECK_LT(x, y)
 
#define DCHECK_GE(x, y)    if (::android::base::kEnableDChecks) CHECK_GE(x, y)
 
#define DCHECK_GT(x, y)    if (::android::base::kEnableDChecks) CHECK_GT(x, y)
 
#define DCHECK_STREQ(s1, s2)    if (::android::base::kEnableDChecks) CHECK_STREQ(s1, s2)
 
#define DCHECK_STRNE(s1, s2)    if (::android::base::kEnableDChecks) CHECK_STRNE(s1, s2)
 
#define OSTREAM_STRING_POINTER_USAGE_WARNING    __attribute__((diagnose_if(true, "Unexpected logging of string pointer", "warning")))
 

Typedefs

using android::base::LogFunction = std::function< void(LogId, LogSeverity, const char *, const char *, unsigned int, const char *)>
 
using android::base::AbortFunction = std::function< void(const char *)>
 

Enumerations

enum  android::base::LogSeverity {
  android::base::VERBOSE , android::base::DEBUG , android::base::INFO , android::base::WARNING ,
  android::base::ERROR , android::base::FATAL_WITHOUT_ABORT , android::base::FATAL
}
 
enum  android::base::LogId {
  android::base::DEFAULT , android::base::MAIN , android::base::SYSTEM , android::base::RADIO ,
  android::base::CRASH
}
 

Functions

void android::base::KernelLogger (LogId log_buffer_id, LogSeverity severity, const char *tag, const char *file, unsigned int line, const char *message)
 
void android::base::StderrLogger (LogId log_buffer_id, LogSeverity severity, const char *tag, const char *file, unsigned int line, const char *message)
 
void android::base::StdioLogger (LogId log_buffer_id, LogSeverity severity, const char *tag, const char *file, unsigned int line, const char *message)
 
void android::base::DefaultAborter (const char *abort_message)
 
void android::base::SetDefaultTag (const std::string &tag)
 
void android::base::InitLogging (char *argv[], LogFunction &&logger=INIT_LOGGING_DEFAULT_LOGGER, AbortFunction &&aborter=DefaultAborter)
 
LogFunction android::base::SetLogger (LogFunction &&logger)
 
AbortFunction android::base::SetAborter (AbortFunction &&aborter)
 
template<typename LHS , typename RHS >
constexpr auto android::base::MakeEagerEvaluator (LHS &&lhs, RHS &&rhs)
 
LogSeverity android::base::GetMinimumLogSeverity ()
 
LogSeverity android::base::SetMinimumLogSeverity (LogSeverity new_severity)
 
bool android::base::ShouldLog (LogSeverity severity, const char *tag)
 
OSTREAM_STRING_POINTER_USAGE_WARNING std::ostream & std::operator<< (std::ostream &stream, const std::string *string_pointer)
 

Variables

static constexpr bool android::base::kEnableDChecks = true
 

Macro Definition Documentation

◆ __builtin_available

#define __builtin_available (   v1,
  v2 
)    false

◆ _LOG_TAG_INTERNAL

#define _LOG_TAG_INTERNAL   nullptr

◆ ABORT_AFTER_LOG_EXPR_IF

#define ABORT_AFTER_LOG_EXPR_IF (   c,
  x 
)    (x)

◆ ABORT_AFTER_LOG_FATAL

#define ABORT_AFTER_LOG_FATAL

◆ ABORT_AFTER_LOG_FATAL_EXPR

#define ABORT_AFTER_LOG_FATAL_EXPR (   x)    ABORT_AFTER_LOG_EXPR_IF(true, x)

◆ CHECK

#define CHECK (   x)
Value:
LIKELY((x)) || ABORT_AFTER_LOG_FATAL_EXPR(false) || \
::android::base::LogMessage(__FILE__, __LINE__, ::android::base::FATAL, _LOG_TAG_INTERNAL, \
-1) \
.stream() \
<< "Check failed: " #x << " "
FATAL
#define FATAL(x...)
Definition: image.h:31
ABORT_AFTER_LOG_FATAL_EXPR
#define ABORT_AFTER_LOG_FATAL_EXPR(x)
Definition: logging.h:200
_LOG_TAG_INTERNAL
#define _LOG_TAG_INTERNAL
Definition: logging.h:81
LIKELY
#define LIKELY(exp)
Definition: macros.h:83

◆ CHECK_EQ

#define CHECK_EQ (   x,
  y 
)    CHECK_OP(x, y, == )

◆ CHECK_GE

#define CHECK_GE (   x,
  y 
)    CHECK_OP(x, y, >= )

◆ CHECK_GT

#define CHECK_GT (   x,
  y 
)    CHECK_OP(x, y, > )

◆ CHECK_LE

#define CHECK_LE (   x,
  y 
)    CHECK_OP(x, y, <= )

◆ CHECK_LT

#define CHECK_LT (   x,
  y 
)    CHECK_OP(x, y, < )

◆ CHECK_NE

#define CHECK_NE (   x,
  y 
)    CHECK_OP(x, y, != )

◆ CHECK_OP

#define CHECK_OP (   LHS,
  RHS,
  OP 
)
Value:
for (auto _values = ::android::base::MakeEagerEvaluator(LHS, RHS); \
UNLIKELY(!(_values.lhs.v OP _values.rhs.v)); \
/* empty */) \
ABORT_AFTER_LOG_FATAL \
::android::base::LogMessage(__FILE__, __LINE__, ::android::base::FATAL, _LOG_TAG_INTERNAL, -1) \
.stream() \
<< "Check failed: " << #LHS << " " << #OP << " " << #RHS << " (" #LHS "=" \
<< ::android::base::LogNullGuard<decltype(_values.lhs.v)>::Guard(_values.lhs.v) \
<< ", " #RHS "=" \
<< ::android::base::LogNullGuard<decltype(_values.rhs.v)>::Guard(_values.rhs.v) \
<< ") "
android::base::LogMessage
Definition: logging.h:419
android::base::LogMessage::stream
std::ostream & stream()
Definition: logging.cpp:509
ABORT_AFTER_LOG_FATAL
#define ABORT_AFTER_LOG_FATAL
Definition: logging.h:196
android::base::MakeEagerEvaluator
constexpr auto MakeEagerEvaluator(LHS &&lhs, RHS &&rhs)
Definition: logging.h:408
android::base::LogNullGuard
Definition: logging.h:393

◆ CHECK_PTHREAD_CALL

#define CHECK_PTHREAD_CALL (   call,
  args,
  what 
)
Value:
do { \
int rc = call args; \
if (rc != 0) { \
errno = rc; \
ABORT_AFTER_LOG_FATAL \
PLOG(FATAL) << #call << " failed for " << (what); \
} \
} while (false)
PLOG
#define PLOG(severity)
Definition: logging.h:235

◆ CHECK_STREQ

#define CHECK_STREQ (   s1,
  s2 
)    CHECK_STROP(s1, s2, true)

◆ CHECK_STRNE

#define CHECK_STRNE (   s1,
  s2 
)    CHECK_STROP(s1, s2, false)

◆ CHECK_STROP

#define CHECK_STROP (   s1,
  s2,
  sense 
)
Value:
while (UNLIKELY((strcmp(s1, s2) == 0) != (sense))) \
ABORT_AFTER_LOG_FATAL \
::android::base::LogMessage(__FILE__, __LINE__, ::android::base::FATAL, \
_LOG_TAG_INTERNAL, -1) \
.stream() \
<< "Check failed: " << "\"" << (s1) << "\"" \
<< ((sense) ? " == " : " != ") << "\"" << (s2) << "\""
UNLIKELY
#define UNLIKELY(exp)
Definition: macros.h:84

◆ DCHECK

#define DCHECK (   x)     if (::android::base::kEnableDChecks) CHECK(x)

◆ DCHECK_EQ

#define DCHECK_EQ (   x,
  y 
)     if (::android::base::kEnableDChecks) CHECK_EQ(x, y)

◆ DCHECK_GE

#define DCHECK_GE (   x,
  y 
)     if (::android::base::kEnableDChecks) CHECK_GE(x, y)

◆ DCHECK_GT

#define DCHECK_GT (   x,
  y 
)     if (::android::base::kEnableDChecks) CHECK_GT(x, y)

◆ DCHECK_LE

#define DCHECK_LE (   x,
  y 
)     if (::android::base::kEnableDChecks) CHECK_LE(x, y)

◆ DCHECK_LT

#define DCHECK_LT (   x,
  y 
)     if (::android::base::kEnableDChecks) CHECK_LT(x, y)

◆ DCHECK_NE

#define DCHECK_NE (   x,
  y 
)     if (::android::base::kEnableDChecks) CHECK_NE(x, y)

◆ DCHECK_STREQ

#define DCHECK_STREQ (   s1,
  s2 
)     if (::android::base::kEnableDChecks) CHECK_STREQ(s1, s2)

◆ DCHECK_STRNE

#define DCHECK_STRNE (   s1,
  s2 
)     if (::android::base::kEnableDChecks) CHECK_STRNE(s1, s2)

◆ INIT_LOGGING_DEFAULT_LOGGER

#define INIT_LOGGING_DEFAULT_LOGGER   StderrLogger

◆ LOG

#define LOG (   severity)    LOGGING_PREAMBLE(severity) && LOG_STREAM(severity)

◆ LOG_STREAM

#define LOG_STREAM (   severity)
Value:
::android::base::LogMessage(__FILE__, __LINE__, SEVERITY_LAMBDA(severity), _LOG_TAG_INTERNAL, \
-1) \
.stream()
SEVERITY_LAMBDA
#define SEVERITY_LAMBDA(severity)
Definition: logging.h:171

◆ LOGGING_PREAMBLE

#define LOGGING_PREAMBLE (   severity)
Value:
(WOULD_LOG(severity) && \
ABORT_AFTER_LOG_EXPR_IF((SEVERITY_LAMBDA(severity)) == ::android::base::FATAL, true) && \
::android::base::ErrnoRestorer())
WOULD_LOG
#define WOULD_LOG(severity)
Definition: logging.h:203

◆ MUST_LOG_MESSAGE

#define MUST_LOG_MESSAGE (   severity)    false

◆ OSTREAM_STRING_POINTER_USAGE_WARNING

#define OSTREAM_STRING_POINTER_USAGE_WARNING    __attribute__((diagnose_if(true, "Unexpected logging of string pointer", "warning")))

◆ PLOG

#define PLOG (   severity)
Value:
LOGGING_PREAMBLE(severity) && \
::android::base::LogMessage(__FILE__, __LINE__, SEVERITY_LAMBDA(severity), \
_LOG_TAG_INTERNAL, errno) \
.stream()
LOGGING_PREAMBLE
#define LOGGING_PREAMBLE(severity)
Definition: logging.h:228

◆ SEVERITY_LAMBDA

#define SEVERITY_LAMBDA (   severity)
Value:
([&]() { \
using ::android::base::VERBOSE; \
using ::android::base::DEBUG; \
using ::android::base::INFO; \
using ::android::base::WARNING; \
using ::android::base::ERROR; \
using ::android::base::FATAL_WITHOUT_ABORT; \
using ::android::base::FATAL; \
return (severity); }())
INFO
#define INFO(x...)
Definition: image.h:29
android::base::DEBUG
@ DEBUG
Definition: logging.h:89
android::base::WARNING
@ WARNING
Definition: logging.h:91
android::base::FATAL_WITHOUT_ABORT
@ FATAL_WITHOUT_ABORT
Definition: logging.h:93
android::base::VERBOSE
@ VERBOSE
Definition: logging.h:88
android::base::ERROR
@ ERROR
Definition: logging.h:92

◆ UNIMPLEMENTED

#define UNIMPLEMENTED (   level)     LOG(level) << __PRETTY_FUNCTION__ << " unimplemented "

◆ WOULD_LOG

#define WOULD_LOG (   severity)
Value:
(UNLIKELY(::android::base::ShouldLog(SEVERITY_LAMBDA(severity), _LOG_TAG_INTERNAL)) || \
MUST_LOG_MESSAGE(severity))
android::base::ShouldLog
bool ShouldLog(LogSeverity severity, const char *tag)
Definition: logging.cpp:542
Generated by doxygen 1.9.4