le_log.h

Go to the documentation of this file.

#ifndef LEGATO_LOG_INCLUDE_GUARD
#define LEGATO_LOG_INCLUDE_GUARD

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef enum _le_log_Level_t
{
    LE_LOG_DEBUG,   
    LE_LOG_INFO,    
    LE_LOG_WARN,    
    LE_LOG_ERR,     
    LE_LOG_CRIT,    
    LE_LOG_EMERG,   
    LE_LOG_MAX      
}
le_log_Level_t;

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#if LE_CONFIG_LOG_STATIC_FILTER_NO_LOG
#   define LE_LOG_LEVEL_STATIC_FILTER   LE_LOG_MAX
#elif LE_CONFIG_LOG_STATIC_FILTER_EMERG
#   define LE_LOG_LEVEL_STATIC_FILTER   LE_LOG_EMERG
#elif LE_CONFIG_LOG_STATIC_FILTER_CRIT
#   define LE_LOG_LEVEL_STATIC_FILTER   LE_LOG_CRIT
#elif LE_CONFIG_LOG_STATIC_FILTER_ERR
#   define LE_LOG_LEVEL_STATIC_FILTER   LE_LOG_ERR
#elif LE_CONFIG_LOG_STATIC_FILTER_WARN
#   define LE_LOG_LEVEL_STATIC_FILTER   LE_LOG_WARN
#elif LE_CONFIG_LOG_STATIC_FILTER_INFO
#   define LE_LOG_LEVEL_STATIC_FILTER   LE_LOG_INFO
#else /* default to LE_DEBUG */
#   define LE_LOG_LEVEL_STATIC_FILTER   LE_LOG_DEBUG
#endif

//--------------------------------------------------------------------------------------------------

typedef struct le_log_Session* le_log_SessionRef_t;

typedef struct le_log_Trace* le_log_TraceRef_t;

#if !defined(LE_DEBUG) && \
    !defined(LE_DUMP) && \
    !defined(LE_LOG_DUMP) && \
    !defined(LE_INFO) && \
    !defined(LE_WARN) && \
    !defined(LE_ERROR) && \
    !defined(LE_CRIT) && \
    !defined(LE_EMERG)

#   define LE_LOG_DEFAULT_IMPL 1

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
void _le_log_Send
(
    const le_log_Level_t     level,             
    const le_log_TraceRef_t  traceRef,          
    le_log_SessionRef_t      logSession,        
    const char              *filenamePtr,       
    const char              *functionNamePtr,   
    const unsigned int       lineNumber,        
    const char              *formatPtr,         
    ...                                         
) __attribute__((format (printf, 7, 8)));

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
void _le_LogData
(
    le_log_Level_t       level,             
    const uint8_t       *dataPtr,           
    int                  dataLength,        
    const char          *filenamePtr,       
    const char          *functionNamePtr,   
    const unsigned int   lineNumber         
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
le_log_TraceRef_t _le_log_GetTraceRef
(
    le_log_SessionRef_t  logSession,    
    const char          *keyword        
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
void _le_log_SetFilterLevel
(
    le_log_SessionRef_t logSession, 
    le_log_Level_t      level       
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
extern LE_SHARED le_log_SessionRef_t LE_LOG_SESSION;

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
extern LE_SHARED le_log_Level_t* LE_LOG_LEVEL_FILTER_PTR;

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#if LE_CONFIG_LOG_FUNCTION_NAMES
#   define _LE_LOG_FUNCTION_NAME __func__
#else
#   define _LE_LOG_FUNCTION_NAME NULL
#endif

//--------------------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define _LE_LOG_MSG(level, formatString, ...) \
    do { \
        if ((level >= LE_LOG_LEVEL_STATIC_FILTER) &&                        \
            ((LE_LOG_LEVEL_FILTER_PTR == NULL) || (level >= *LE_LOG_LEVEL_FILTER_PTR))) \
            _le_log_Send(level, NULL, LE_LOG_SESSION, __FILE__, _LE_LOG_FUNCTION_NAME, __LINE__, \
                    formatString, ##__VA_ARGS__); \
    } while(0)


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

#define LE_DEBUG(formatString, ...)     _LE_LOG_MSG(LE_LOG_DEBUG, formatString, ##__VA_ARGS__)

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_DUMP(dataPtr, dataLength)                                                              \
    _le_LogData(LE_LOG_DEBUG, dataPtr, dataLength, STRINGIZE(LE_FILENAME), _LE_LOG_FUNCTION_NAME, \
        __LINE__)

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_LOG_DUMP(level, dataPtr, dataLength) \
    _le_LogData(level, dataPtr, dataLength, STRINGIZE(LE_FILENAME), _LE_LOG_FUNCTION_NAME, __LINE__)

#define LE_INFO(formatString, ...)      _LE_LOG_MSG(LE_LOG_INFO, formatString, ##__VA_ARGS__)

#define LE_WARN(formatString, ...)      _LE_LOG_MSG(LE_LOG_WARN, formatString, ##__VA_ARGS__)

#define LE_ERROR(formatString, ...)     _LE_LOG_MSG(LE_LOG_ERR, formatString, ##__VA_ARGS__)

#define LE_CRIT(formatString, ...)      _LE_LOG_MSG(LE_LOG_CRIT, formatString, ##__VA_ARGS__)

#define LE_EMERG(formatString, ...)     _LE_LOG_MSG(LE_LOG_EMERG, formatString, ##__VA_ARGS__)


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_LOG_CAN_TRACE        1


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_IS_TRACE_ENABLED(traceRef)  (le_log_IsTraceEnabled(traceRef))


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_TRACE(traceRef, string, ...)         \
        if (le_log_IsTraceEnabled(traceRef))    \
        {                                       \
            _le_log_Send((le_log_Level_t)-1,    \
                    traceRef,                   \
                    LE_LOG_SESSION,             \
                    STRINGIZE(LE_FILENAME),     \
                    _LE_LOG_FUNCTION_NAME,      \
                    __LINE__,                   \
                    string,                     \
                    ##__VA_ARGS__);             \
        }


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define le_log_GetTraceRef(keywordPtr)                  \
    _le_log_GetTraceRef(LE_LOG_SESSION, (keywordPtr))


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define le_log_IsTraceEnabled(traceRef) ((traceRef) == NULL ? false : *((bool *) (traceRef)))


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define le_log_SetFilterLevel(level)                    \
    _le_log_SetFilterLevel(LE_LOG_SESSION, (level))


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define le_log_GetFilterLevel()                 \
    ((LE_LOG_LEVEL_FILTER_PTR != NULL)?(*LE_LOG_LEVEL_FILTER_PTR):(LE_LOG_INFO))


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define le_log_EnableTrace(traceRef)            \
    ((void)(*((bool*)(traceRef)) = true))


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define le_log_DisableTrace(traceRef)           \
    ((void)(*((bool*)(traceRef)) = false))

#else

// If any logging macro is overridden, all logging macros must be overridden.
#if !defined(LE_DEBUG)
#  error "Logging are overridden, but LE_DEBUG not defined.  Define LE_DEBUG."
#endif

#if !defined(LE_DUMP)
#  error "Logging are overridden, but LE_DUMP not defined.  Define LE_DUMP."
#endif

#if !defined(LE_LOG_DUMP)
#  error "Logging are overridden, but LE_LOG_DUMP not defined.  Define LE_LOG_DUMP."
#endif

#if !defined(LE_INFO)
#  error "Logging are overridden, but LE_INFO not defined.  Define LE_INFO."
#endif

#if !defined(LE_WARN)
#  error "Logging are overridden, but LE_WARN not defined.  Define LE_WARN."
#endif

#if !defined(LE_ERROR)
#  error "Logging are overridden, but LE_ERROR not defined.  Define LE_ERROR."
#endif

#if !defined(LE_CRIT)
#  error "Logging are overridden, but LE_CRIT not defined.  Define LE_CRIT."
#endif

#if !defined(LE_EMERG)
#  error "Logging are overridden, but LE_EMERG not defined.  Define LE_EMERG."
#endif

// If SetFilterLevel is not defined when logging is overridden,
// assume it cannot be set programatically
#ifndef le_log_SetFilterLevel
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define le_log_SetFilterLevel(level) ((void)(level))
#endif


// If le_log_GetFilterLevel is not defined when logging is overridden, assume it
// cannot be obtained programatically.  In this case code should assume filter level
// is equal to static filter level
#ifndef le_log_GetFilterLevel
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define le_log_GetFilterLevel()  (LE_LOG_LEVEL_STATIC_FILTER)
#endif

//--------------------------------------------------------------------------------------------------
/*
 * If logging is overridden, disable Legato tracing mechanism.  Tracing is noisy and should
 * not be put into general logs.
 */
//--------------------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_IS_TRACE_ENABLED(traceRef)  (false)


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_TRACE(traceRef, string, ...) ((void)(traceRef))


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define le_log_GetTraceRef(keywordPtr) ((le_log_TraceRef_t)NULL)


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define le_log_IsTraceEnabled(traceRef) (false)


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define le_log_EnableTrace(traceRef) ((void)(0))


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define le_log_DisableTrace(traceRef) ((void)(0))

#endif /* Logging macro override */

const char* _le_log_GetResultCodeString
(
    le_result_t resultCode  
);

const char* _le_log_GetErrnoCodeString
(
    int errnoCode  
);

__attribute__((noreturn))
void _le_log_ExitFatal
(
    void
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

#define LE_DEBUG_IF(condition, formatString, ...) \
        if (condition) { LE_DEBUG(formatString, ##__VA_ARGS__); }

#define LE_INFO_IF(condition, formatString, ...) \
        if (condition) { LE_INFO(formatString, ##__VA_ARGS__); }

#define LE_WARN_IF(condition, formatString, ...) \
        if (condition) { LE_WARN(formatString, ##__VA_ARGS__); }

#define LE_ERROR_IF(condition, formatString, ...) \
        if (condition) { LE_ERROR(formatString, ##__VA_ARGS__); }

#define LE_CRIT_IF(condition, formatString, ...) \
        if (condition) { LE_CRIT(formatString, ##__VA_ARGS__); }

#define LE_EMERG_IF(condition, formatString, ...) \
        if (condition) { LE_EMERG(formatString, ##__VA_ARGS__); }


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#ifndef LE_FATAL
#   if !LE_CONFIG_DEBUG
#       define LE_FATAL(formatString, ...) \
        { LE_EMERG(formatString, ##__VA_ARGS__); _le_log_ExitFatal(); }
#   else
#       define LE_FATAL(formatString, ...) \
        { LE_EMERG(formatString, ##__VA_ARGS__); abort(); }
#   endif
#endif


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_FATAL_IF(condition, formatString, ...) \
        if (condition) { LE_FATAL(formatString, ##__VA_ARGS__) }


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_ASSERT(condition)                            \
    LE_FATAL_IF(!(condition), "Assert Failed: '%s'", #condition)


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_ASSERT_OK(condition)                                         \
    LE_FATAL_IF((condition) != LE_OK, "Assert Failed: '%s' is not LE_OK (0)", #condition)


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#define LE_RESULT_TXT(v) _le_log_GetResultCodeString(v)

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
#ifndef LE_ERRNO_TXT
#  define LE_ERRNO_TXT(v) _le_log_GetErrnoCodeString(v)
#  define LE_LOG_NEED_GET_ERRNO_STRING 1

const char *_le_log_GetErrnoCodeString(int error);
#endif


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
LE_FULL_API void le_log_ConnectToControlDaemon
(
    void
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
LE_FULL_API le_log_SessionRef_t le_log_RegComponent
(
    const char       *componentNamePtr, 
    le_log_Level_t  **levelFilterPtrPtr 
);

#endif // LEGATO_LOG_INCLUDE_GUARD