src/basic/log.h

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 #pragma once
   3
   4 #include <stdarg.h>
   5 #include <stdbool.h>
   6 #include <stdlib.h>
   7 #include <syslog.h>
   8
   9 #include "macro.h"
  10
  11 /* Some structures we reference but don't want to pull in headers for */
  12 struct iovec;
  13 struct signalfd_siginfo;
  14
  15 typedef enum LogRealm {
  16         LOG_REALM_SYSTEMD,
  17         LOG_REALM_UDEV,
  18         _LOG_REALM_MAX,
  19 } LogRealm;
  20
  21 #ifndef LOG_REALM
  22 #  define LOG_REALM LOG_REALM_SYSTEMD
  23 #endif
  24
  25 typedef enum LogTarget{
  26         LOG_TARGET_CONSOLE,
  27         LOG_TARGET_CONSOLE_PREFIXED,
  28         LOG_TARGET_KMSG,
  29         LOG_TARGET_JOURNAL,
  30         LOG_TARGET_JOURNAL_OR_KMSG,
  31         LOG_TARGET_SYSLOG,
  32         LOG_TARGET_SYSLOG_OR_KMSG,
  33         LOG_TARGET_AUTO, /* console if stderr is tty, JOURNAL_OR_KMSG otherwise */
  34         LOG_TARGET_NULL,
  35         _LOG_TARGET_MAX,
  36         _LOG_TARGET_INVALID = -1
  37 } LogTarget;
  38
  39 #define LOG_REALM_PLUS_LEVEL(realm, level)      \
  40         ((realm) << 10 | (level))
  41 #define LOG_REALM_REMOVE_LEVEL(realm_level)     \
  42         ((realm_level >> 10))
  43
  44 void log_set_target(LogTarget target);
  45 void log_set_max_level_realm(LogRealm realm, int level);
  46 #define log_set_max_level(level)                \
  47         log_set_max_level_realm(LOG_REALM, (level))
  48
  49 void log_set_facility(int facility);
  50
  51 int log_set_target_from_string(const char *e);
  52 int log_set_max_level_from_string_realm(LogRealm realm, const char *e);
  53 #define log_set_max_level_from_string(e)        \
  54         log_set_max_level_from_string_realm(LOG_REALM, (e))
  55
  56 void log_show_color(bool b);
  57 bool log_get_show_color(void) _pure_;
  58 void log_show_location(bool b);
  59 bool log_get_show_location(void) _pure_;
  60
  61 int log_show_color_from_string(const char *e);
  62 int log_show_location_from_string(const char *e);
  63
  64 LogTarget log_get_target(void) _pure_;
  65 int log_get_max_level_realm(LogRealm realm) _pure_;
  66 #define log_get_max_level()                     \
  67         log_get_max_level_realm(LOG_REALM)
  68
  69 /* Functions below that open and close logs or configure logging based on the
  70  * environment should not be called from library code — this is always a job
  71  * for the application itself.
  72  */
  73
  74 int log_open(void);
  75 void log_close(void);
  76 void log_forget_fds(void);
  77
  78 void log_parse_environment_realm(LogRealm realm);
  79 #define log_parse_environment() \
  80         log_parse_environment_realm(LOG_REALM)
  81
  82 int log_dispatch_internal(
  83                 int level,
  84                 int error,
  85                 const char *file,
  86                 int line,
  87                 const char *func,
  88                 const char *object_field,
  89                 const char *object,
  90                 const char *extra,
  91                 const char *extra_field,
  92                 char *buffer);
  93
  94 int log_internal_realm(
  95                 int level,
  96                 int error,
  97                 const char *file,
  98                 int line,
  99                 const char *func,
 100                 const char *format, ...) _printf_(6,7);
 101 #define log_internal(level, ...) \
 102         log_internal_realm(LOG_REALM_PLUS_LEVEL(LOG_REALM, (level)), __VA_ARGS__)
 103
 104 int log_internalv_realm(
 105                 int level,
 106                 int error,
 107                 const char *file,
 108                 int line,
 109                 const char *func,
 110                 const char *format,
 111                 va_list ap) _printf_(6,0);
 112 #define log_internalv(level, ...) \
 113         log_internalv_realm(LOG_REALM_PLUS_LEVEL(LOG_REALM, (level)), __VA_ARGS__)
 114
 115 /* Realm is fixed to LOG_REALM_SYSTEMD for those */
 116 int log_object_internal(
 117                 int level,
 118                 int error,
 119                 const char *file,
 120                 int line,
 121                 const char *func,
 122                 const char *object_field,
 123                 const char *object,
 124                 const char *extra_field,
 125                 const char *extra,
 126                 const char *format, ...) _printf_(10,11);
 127
 128 int log_struct_internal(
 129                 int level,
 130                 int error,
 131                 const char *file,
 132                 int line,
 133                 const char *func,
 134                 const char *format, ...) _printf_(6,0) _sentinel_;
 135
 136 int log_oom_internal(
 137                 LogRealm realm,
 138                 const char *file,
 139                 int line,
 140                 const char *func);
 141
 142 int log_format_iovec(
 143                 struct iovec *iovec,
 144                 size_t iovec_len,
 145                 size_t *n,
 146                 bool newline_separator,
 147                 int error,
 148                 const char *format,
 149                 va_list ap) _printf_(6, 0);
 150
 151 int log_struct_iovec_internal(
 152                 int level,
 153                 int error,
 154                 const char *file,
 155                 int line,
 156                 const char *func,
 157                 const struct iovec *input_iovec,
 158                 size_t n_input_iovec);
 159
 160 /* This modifies the buffer passed! */
 161 int log_dump_internal(
 162                 int level,
 163                 int error,
 164                 const char *file,
 165                 int line,
 166                 const char *func,
 167                 char *buffer);
 168
 169 /* Logging for various assertions */
 170 _noreturn_ void log_assert_failed_realm(
 171                 LogRealm realm,
 172                 const char *text,
 173                 const char *file,
 174                 int line,
 175                 const char *func);
 176 #define log_assert_failed(text, ...) \
 177         log_assert_failed_realm(LOG_REALM, (text), __VA_ARGS__)
 178
 179 _noreturn_ void log_assert_failed_unreachable_realm(
 180                 LogRealm realm,
 181                 const char *text,
 182                 const char *file,
 183                 int line,
 184                 const char *func);
 185 #define log_assert_failed_unreachable(text, ...) \
 186         log_assert_failed_unreachable_realm(LOG_REALM, (text), __VA_ARGS__)
 187
 188 void log_assert_failed_return_realm(
 189                 LogRealm realm,
 190                 const char *text,
 191                 const char *file,
 192                 int line,
 193                 const char *func);
 194 #define log_assert_failed_return(text, ...) \
 195         log_assert_failed_return_realm(LOG_REALM, (text), __VA_ARGS__)
 196
 197 #define log_dispatch(level, error, buffer)                              \
 198         log_dispatch_internal(level, error, __FILE__, __LINE__, __func__, NULL, NULL, NULL, NULL, buffer)
 199
 200 /* Logging with level */
 201 #define log_full_errno_realm(realm, level, error, ...)                  \
 202         ({                                                              \
 203                 int _level = (level), _e = (error), _realm = (realm);   \
 204                 (log_get_max_level_realm(_realm) >= LOG_PRI(_level))   \
 205                         ? log_internal_realm(LOG_REALM_PLUS_LEVEL(_realm, _level), _e, \
 206                                              __FILE__, __LINE__, __func__, __VA_ARGS__) \
 207                         : -abs(_e);                                     \
 208         })
 209
 210 #define log_full_errno(level, error, ...)                               \
 211         log_full_errno_realm(LOG_REALM, (level), (error), __VA_ARGS__)
 212
 213 #define log_full(level, ...) log_full_errno((level), 0, __VA_ARGS__)
 214
 215 int log_emergency_level(void);
 216
 217 /* Normal logging */
 218 #define log_debug(...)     log_full(LOG_DEBUG,   __VA_ARGS__)
 219 #define log_info(...)      log_full(LOG_INFO,    __VA_ARGS__)
 220 #define log_notice(...)    log_full(LOG_NOTICE,  __VA_ARGS__)
 221 #define log_warning(...)   log_full(LOG_WARNING, __VA_ARGS__)
 222 #define log_error(...)     log_full(LOG_ERR,     __VA_ARGS__)
 223 #define log_emergency(...) log_full(log_emergency_level(), __VA_ARGS__)
 224
 225 /* Logging triggered by an errno-like error */
 226 #define log_debug_errno(error, ...)     log_full_errno(LOG_DEBUG,   error, __VA_ARGS__)
 227 #define log_info_errno(error, ...)      log_full_errno(LOG_INFO,    error, __VA_ARGS__)
 228 #define log_notice_errno(error, ...)    log_full_errno(LOG_NOTICE,  error, __VA_ARGS__)
 229 #define log_warning_errno(error, ...)   log_full_errno(LOG_WARNING, error, __VA_ARGS__)
 230 #define log_error_errno(error, ...)     log_full_errno(LOG_ERR,     error, __VA_ARGS__)
 231 #define log_emergency_errno(error, ...) log_full_errno(log_emergency_level(), error, __VA_ARGS__)
 232
 233 #ifdef LOG_TRACE
 234 #  define log_trace(...) log_debug(__VA_ARGS__)
 235 #else
 236 #  define log_trace(...) do {} while (0)
 237 #endif
 238
 239 /* Structured logging */
 240 #define log_struct_errno(level, error, ...) \
 241         log_struct_internal(LOG_REALM_PLUS_LEVEL(LOG_REALM, level), \
 242                             error, __FILE__, __LINE__, __func__, __VA_ARGS__, NULL)
 243 #define log_struct(level, ...) log_struct_errno(level, 0, __VA_ARGS__)
 244
 245 #define log_struct_iovec_errno(level, error, iovec, n_iovec)            \
 246         log_struct_iovec_internal(LOG_REALM_PLUS_LEVEL(LOG_REALM, level), \
 247                                   error, __FILE__, __LINE__, __func__, iovec, n_iovec)
 248 #define log_struct_iovec(level, iovec, n_iovec) log_struct_iovec_errno(level, 0, iovec, n_iovec)
 249
 250 /* This modifies the buffer passed! */
 251 #define log_dump(level, buffer) \
 252         log_dump_internal(LOG_REALM_PLUS_LEVEL(LOG_REALM, level), \
 253                           0, __FILE__, __LINE__, __func__, buffer)
 254
 255 #define log_oom() log_oom_internal(LOG_REALM, __FILE__, __LINE__, __func__)
 256
 257 bool log_on_console(void) _pure_;
 258
 259 const char *log_target_to_string(LogTarget target) _const_;
 260 LogTarget log_target_from_string(const char *s) _pure_;
 261
 262 /* Helper to prepare various field for structured logging */
 263 #define LOG_MESSAGE(fmt, ...) "MESSAGE=" fmt, ##__VA_ARGS__
 264
 265 void log_received_signal(int level, const struct signalfd_siginfo *si);
 266
 267 /* If turned on, any requests for a log target involving "syslog" will be implicitly upgraded to the equivalent journal target */
 268 void log_set_upgrade_syslog_to_journal(bool b);
 269
 270 /* If turned on, and log_open() is called, we'll not use STDERR_FILENO for logging ever, but rather open /dev/console */
 271 void log_set_always_reopen_console(bool b);
 272
 273 /* If turned on, we'll open the log stream implicitly if needed on each individual log call. This is normally not
 274  * desired as we want to reuse our logging streams. It is useful however  */
 275 void log_set_open_when_needed(bool b);
 276
 277 /* If turned on, then we'll never use IPC-based logging, i.e. never log to syslog or the journal. We'll only log to
 278  * stderr, the console or kmsg */
 279 void log_set_prohibit_ipc(bool b);
 280
 281 int log_dup_console(void);
 282
 283 int log_syntax_internal(
 284                 const char *unit,
 285                 int level,
 286                 const char *config_file,
 287                 unsigned config_line,
 288                 int error,
 289                 const char *file,
 290                 int line,
 291                 const char *func,
 292                 const char *format, ...) _printf_(9, 10);
 293
 294 int log_syntax_invalid_utf8_internal(
 295                 const char *unit,
 296                 int level,
 297                 const char *config_file,
 298                 unsigned config_line,
 299                 const char *file,
 300                 int line,
 301                 const char *func,
 302                 const char *rvalue);
 303
 304 #define log_syntax(unit, level, config_file, config_line, error, ...)   \
 305         ({                                                              \
 306                 int _level = (level), _e = (error);                     \
 307                 (log_get_max_level() >= LOG_PRI(_level))                \
 308                         ? log_syntax_internal(unit, _level, config_file, config_line, _e, __FILE__, __LINE__, __func__, __VA_ARGS__) \
 309                         : -abs(_e);                                     \
 310         })
 311
 312 #define log_syntax_invalid_utf8(unit, level, config_file, config_line, rvalue) \
 313         ({                                                              \
 314                 int _level = (level);                                   \
 315                 (log_get_max_level() >= LOG_PRI(_level))                \
 316                         ? log_syntax_invalid_utf8_internal(unit, _level, config_file, config_line, __FILE__, __LINE__, __func__, rvalue) \
 317                         : -EINVAL;                                      \
 318         })
 319
 320 #define DEBUG_LOGGING _unlikely_(log_get_max_level() >= LOG_DEBUG)