install/log.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   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 <stdarg.h>
  23 #include <stdio.h>
  24 #include <errno.h>
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <sys/socket.h>
  28 #include <sys/un.h>
  29 #include <stddef.h>
  30
  31 #include "log.h"
  32 #include "util.h"
  33 #include "macro.h"
  34
  35 #define SNDBUF_SIZE (8*1024*1024)
  36
  37 static LogTarget log_target = LOG_TARGET_CONSOLE;
  38 static int log_max_level = LOG_WARNING;
  39 static int log_facility = LOG_DAEMON;
  40
  41 static int console_fd = STDERR_FILENO;
  42
  43 static bool show_location = false;
  44
  45 /* Akin to glibc's __abort_msg; which is private and we hence cannot
  46  * use here. */
  47 static char *log_abort_msg = NULL;
  48
  49 void log_close_console(void) {
  50
  51         if (console_fd < 0)
  52                 return;
  53
  54         if (getpid() == 1) {
  55                 if (console_fd >= 3)
  56                         close_nointr_nofail(console_fd);
  57
  58                 console_fd = -1;
  59         }
  60 }
  61
  62 static int log_open_console(void) {
  63
  64         if (console_fd >= 0)
  65                 return 0;
  66
  67         if (getpid() == 1) {
  68
  69                 console_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
  70                 if (console_fd < 0) {
  71                         log_error("Failed to open /dev/console for logging: %s", strerror(-console_fd));
  72                         return console_fd;
  73                 }
  74
  75                 log_debug("Successfully opened /dev/console for logging.");
  76         } else
  77                 console_fd = STDERR_FILENO;
  78
  79         return 0;
  80 }
  81
  82
  83 int log_open(void) {
  84         return log_open_console();
  85 }
  86
  87
  88 void log_close(void) {
  89         log_close_console();
  90 }
  91
  92
  93 void log_set_max_level(int level) {
  94         assert((level & LOG_PRIMASK) == level);
  95
  96         log_max_level = level;
  97 }
  98
  99 void log_set_facility(int facility) {
 100         log_facility = facility;
 101 }
 102
 103 static int write_to_console(
 104                 int level,
 105                 const char*file,
 106                 int line,
 107                 const char *func,
 108                 const char *buffer) {
 109
 110         char location[64];
 111         struct iovec iovec[5];
 112         unsigned n = 0;
 113
 114         if (console_fd < 0)
 115                 return 0;
 116
 117         zero(iovec);
 118
 119         IOVEC_SET_STRING(iovec[n++], "dracut-install: ");
 120
 121         if (show_location) {
 122                 snprintf(location, sizeof(location), "(%s:%u) ", file, line);
 123                 IOVEC_SET_STRING(iovec[n++], location);
 124         }
 125
 126         IOVEC_SET_STRING(iovec[n++], buffer);
 127         IOVEC_SET_STRING(iovec[n++], "\n");
 128
 129         if (writev(console_fd, iovec, n) < 0)
 130                 return -errno;
 131
 132         return 1;
 133 }
 134
 135 static int log_dispatch(
 136         int level,
 137         const char*file,
 138         int line,
 139         const char *func,
 140         char *buffer) {
 141
 142         int r = 0;
 143
 144         if (log_target == LOG_TARGET_NULL)
 145                 return 0;
 146
 147         /* Patch in LOG_DAEMON facility if necessary */
 148         if ((level & LOG_FACMASK) == 0)
 149                 level = log_facility | LOG_PRI(level);
 150
 151         do {
 152                 char *e;
 153                 int k = 0;
 154
 155                 buffer += strspn(buffer, NEWLINE);
 156
 157                 if (buffer[0] == 0)
 158                         break;
 159
 160                 if ((e = strpbrk(buffer, NEWLINE)))
 161                         *(e++) = 0;
 162
 163                 k = write_to_console(level, file, line, func, buffer);
 164                 if (k < 0)
 165                         return k;
 166                 buffer = e;
 167         } while (buffer);
 168
 169         return r;
 170 }
 171
 172 int log_metav(
 173         int level,
 174         const char*file,
 175         int line,
 176         const char *func,
 177         const char *format,
 178         va_list ap) {
 179
 180         char buffer[LINE_MAX];
 181         int saved_errno, r;
 182
 183         if (_likely_(LOG_PRI(level) > log_max_level))
 184                 return 0;
 185
 186         saved_errno = errno;
 187         vsnprintf(buffer, sizeof(buffer), format, ap);
 188         char_array_0(buffer);
 189
 190         r = log_dispatch(level, file, line, func, buffer);
 191         errno = saved_errno;
 192
 193         return r;
 194 }
 195
 196 int log_meta(
 197         int level,
 198         const char*file,
 199         int line,
 200         const char *func,
 201         const char *format, ...) {
 202
 203         int r;
 204         va_list ap;
 205
 206         va_start(ap, format);
 207         r = log_metav(level, file, line, func, format, ap);
 208         va_end(ap);
 209
 210         return r;
 211 }
 212
 213 #pragma GCC diagnostic push
 214 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
 215 _noreturn_ static void log_assert(const char *text, const char *file, int line, const char *func, const char *format) {
 216         static char buffer[LINE_MAX];
 217
 218         snprintf(buffer, sizeof(buffer), format, text, file, line, func);
 219
 220         char_array_0(buffer);
 221         log_abort_msg = buffer;
 222
 223         log_dispatch(LOG_CRIT, file, line, func, buffer);
 224         abort();
 225 }
 226 #pragma GCC diagnostic pop
 227
 228 _noreturn_ void log_assert_failed(const char *text, const char *file, int line, const char *func) {
 229         log_assert(text, file, line, func, "Assertion '%s' failed at %s:%u, function %s(). Aborting.");
 230 }
 231
 232 _noreturn_ void log_assert_failed_unreachable(const char *text, const char *file, int line, const char *func) {
 233         log_assert(text, file, line, func, "Code should not be reached '%s' at %s:%u, function %s(). Aborting.");
 234 }
 235
 236 void log_set_target(LogTarget target) {
 237         assert(target >= 0);
 238         assert(target < _LOG_TARGET_MAX);
 239
 240         log_target = target;
 241 }
 242
 243 int log_set_target_from_string(const char *e) {
 244         LogTarget t;
 245
 246         t = log_target_from_string(e);
 247         if (t < 0)
 248                 return -EINVAL;
 249
 250         log_set_target(t);
 251         return 0;
 252 }
 253
 254 int log_set_max_level_from_string(const char *e) {
 255         int t;
 256
 257         t = log_level_from_string(e);
 258         if (t < 0)
 259                 return t;
 260
 261         log_set_max_level(t);
 262         return 0;
 263 }
 264
 265 void log_parse_environment(void) {
 266         const char *e;
 267
 268         if ((e = getenv("DRACUT_LOG_TARGET")))
 269                 if (log_set_target_from_string(e) < 0)
 270                         log_warning("Failed to parse log target %s. Ignoring.", e);
 271
 272         if ((e = getenv("DRACUT_LOG_LEVEL")))
 273                 if (log_set_max_level_from_string(e) < 0)
 274                         log_warning("Failed to parse log level %s. Ignoring.", e);
 275
 276 }
 277
 278 LogTarget log_get_target(void) {
 279         return log_target;
 280 }
 281
 282 int log_get_max_level(void) {
 283         return log_max_level;
 284 }
 285
 286
 287 static const char *const log_target_table[] = {
 288         [LOG_TARGET_CONSOLE] = "console",
 289         [LOG_TARGET_AUTO] = "auto",
 290         [LOG_TARGET_SAFE] = "safe",
 291         [LOG_TARGET_NULL] = "null"
 292 };
 293
 294 DEFINE_STRING_TABLE_LOOKUP(log_target, LogTarget);