src/basic/log.h

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