src/basic/log.h

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