/*
* Copyright (c) 2020 Red Hat, Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* $Id: //eng/uds-releases/jasper/src/uds/logger.h#5 $
*/
#ifndef LOGGER_H
#define LOGGER_H 1
#ifdef __KERNEL__
#include <linux/ratelimit.h>
#include <linux/version.h>
#else
#include <stdarg.h>
#include "minisyslog.h"
#endif
#ifdef __KERNEL__
#define LOG_EMERG 0 /* system is unusable */
#define LOG_ALERT 1 /* action must be taken immediately */
#define LOG_CRIT 2 /* critical conditions */
#define LOG_ERR 3 /* error conditions */
#define LOG_WARNING 4 /* warning conditions */
#define LOG_NOTICE 5 /* normal but significant condition */
#define LOG_INFO 6 /* informational */
#define LOG_DEBUG 7 /* debug-level messages */
#endif
#ifdef __KERNEL__
// Make it easy to log real pointer values using %px when in development.
#ifdef LOG_INTERNAL
#define PRIptr "px"
#else
#define PRIptr "pK"
#endif
#else // not __KERNEL__
// For compatibility with hooks we need when compiling in kernel mode.
#define PRIptr "p"
#endif
/*
* Apply a rate limiter to a log method call.
*
* @param logFunc A method that does logging, which is not invoked if we are
* running in the kernel and the ratelimiter detects that we
* are calling it frequently.
*/
#ifdef __KERNEL__
#define logRatelimit(logFunc, ...) \
do { \
static DEFINE_RATELIMIT_STATE(_rs, DEFAULT_RATELIMIT_INTERVAL, \
DEFAULT_RATELIMIT_BURST); \
if (__ratelimit(&_rs)) { \
logFunc(__VA_ARGS__); \
} \
} while (0)
#else
#define logRatelimit(logFunc, ...) logFunc(__VA_ARGS__)
#endif
/**
* @file
*
* All of the log<Level>() functions will preserve the callers value of errno.
**/
#ifndef __KERNEL__
/*
* In user mode, the functions in this file are not thread safe in the sense
* that nothing prevents multiple threads from closing loggers out from under
* other threads. In reality this isn't a problem since there are no calls to
* closeLogger() in production code.
*/
/**
* Start the logger.
**/
void openLogger(void);
/**
* Stop the logger.
**/
void closeLogger(void);
#endif
/**
* Get the current logging level.
*
* @return the current logging priority level.
**/
int getLogLevel(void);
/**
* Set the current logging level.
*
* @param newLogLevel the new value for the logging priority level.
**/
void setLogLevel(int newLogLevel);
/**
* Return the integer logging priority represented by a name.
*
* @param string the name of the logging priority (case insensitive).
*
* @return the integer priority named by string, or LOG_INFO if not recognized.
**/
int stringToPriority(const char *string);
/**
* Return the printable name of a logging priority.
*
* @return the priority name
**/
const char *priorityToString(int priority);
/**
* Log a debug message.
*
* @param format The format of the message (a printf style format)
**/
void logDebug(const char *format, ...) __attribute__((format(printf, 1, 2)));
/**
* Log an informational message.
*
* @param format The format of the message (a printf style format)
**/
void logInfo(const char *format, ...) __attribute__((format(printf, 1, 2)));
/**
* Log a normal (but notable) condition.
*
* @param format The format of the message (a printf style format)
**/
void logNotice(const char *format, ...) __attribute__((format(printf, 1, 2)));
/**
* Log a warning.
*
* @param format The format of the message (a printf style format)
**/
void logWarning(const char *format, ...) __attribute__((format(printf, 1, 2)));
/**
* Log an error.
*
* @param format The format of the message (a printf style format)
**/
void logError(const char *format, ...) __attribute__((format(printf, 1, 2)));
/**
* Log a message embedded within another message.
*
* @param priority the priority at which to log the message
* @param prefix optional string prefix to message, may be NULL
* @param fmt1 format of message first part, may be NULL
* @param args1 arguments for message first part
* @param fmt2 format of message second part
**/
void logEmbeddedMessage(int priority,
const char *prefix,
const char *fmt1,
va_list args1,
const char *fmt2,
...)
__attribute__((format(printf, 3, 0), format(printf, 5, 6)));
/**
* Log a message pack consisting of multiple variable sections.
*
* @param priority the priority at which to log the message
* @param prefix optional string prefix to message, may be NULL
* @param fmt1 format of message first part, may be NULL
* @param args1 arguments for message first part
* @param fmt2 format of message second part, may be NULL
* @param args2 arguments for message second part
**/
void logMessagePack(int priority,
const char *prefix,
const char *fmt1,
va_list args1,
const char *fmt2,
va_list args2)
__attribute__((format(printf, 3, 0)));
/**
* Log a stack backtrace.
*
* @param priority The priority at which to log the backtrace
**/
void logBacktrace(int priority);
/**
* Log a message with an error from an error code.
*
* @param priority The priority of the logging entry
* @param errnum Int value of errno or a UDS_* value.
* @param format The format of the message (a printf style format)
*
* @return errnum
**/
int logWithStringError(int priority, int errnum, const char *format, ...)
__attribute__((format(printf, 3, 4)));
/**
* Log a message with an error from an error code.
*
* @param priority The priority of the logging entry
* @param errnum Int value of errno or a UDS_* value.
* @param format The format of the message (a printf style format)
* @param args The list of arguments with format.
*
* @return errnum
**/
int vLogWithStringError(int priority,
int errnum,
const char *format,
va_list args)
__attribute__((format(printf, 3, 0)));
/**
* Log an error prefixed with the string associated with the errnum.
*
* @param errnum Int value of errno or a UDS_* value.
* @param format The format of the message (a printf style format)
*
* @return errnum
**/
int logErrorWithStringError(int errnum, const char *format, ...)
__attribute__((format(printf, 2, 3)));
/**********************************************************************/
int logDebugWithStringError(int errnum, const char *format, ...)
__attribute__((format(printf, 2, 3)));
/**********************************************************************/
int logInfoWithStringError(int errnum, const char *format, ...)
__attribute__((format(printf, 2, 3)));
/**********************************************************************/
int logNoticeWithStringError(int errnum, const char *format, ...)
__attribute__((format(printf, 2, 3)));
/**********************************************************************/
int logWarningWithStringError(int errnum, const char *format, ...)
__attribute__((format(printf, 2, 3)));
/**********************************************************************/
int logFatalWithStringError(int errnum, const char *format, ...)
__attribute__((format(printf, 2, 3)));
/**
* IF the result is an error, log a FATAL level message and return the result
* after marking it unrecoverable. The UDS_SUCCESS and UDS_QUEUED results are
* not considered errors and are returned unmodified.
*
* @param errnum int value of errno or a UDS_* value.
* @param format The format of the message (a printf style format)
*
* @return makeUnrecoverable(errnum) or UDS_SUCCESS or UDS_QUEUED
**/
int logUnrecoverable(int errnum, const char *format, ...)
__attribute__((format(printf, 2, 3)));
/**
* Log a fatal error.
*
* @param format The format of the message (a printf style format)
**/
void logFatal(const char *format, ...) __attribute__((format(printf, 1, 2)));
/**
* Log a message -- for internal use only.
*
* @param priority The syslog priority value for the message.
* @param format The format of the message (a printf style format)
* @param args The variadic argument list of format parameters.
**/
void vLogMessage(int priority, const char *format, va_list args)
__attribute__((format(printf, 2, 0)));
/**
* Log a message
*
* @param priority The syslog priority value for the message.
* @param format The format of the message (a printf style format)
**/
void logMessage(int priority, const char *format, ...)
__attribute__((format(printf, 2, 3)));
/**
* Sleep or delay a short time (likely a few milliseconds) in an attempt allow
* the log buffers to be written out in case they might be overrun. This is
* unnecessary in user-space (and is a no-op there), but is needed when
* quickly issuing a lot of log output in the Linux kernel, as when dumping a
* large number of data structures.
**/
void pauseForLogger(void);
#endif /* LOGGER_H */