src/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 General Public License as published by
  10   the Free Software Foundation; either version 2 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   General Public License for more details.
  17
  18   You should have received a copy of the GNU 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
  30 #include "log.h"
  31 #include "util.h"
  32 #include "macro.h"
  33
  34 #define SYSLOG_TIMEOUT_USEC (5*USEC_PER_SEC)
  35
  36 static LogTarget log_target = LOG_TARGET_CONSOLE;
  37 static int log_max_level = LOG_INFO;
  38
  39 static int console_fd = STDERR_FILENO;
  40 static int syslog_fd = -1;
  41 static int kmsg_fd = -1;
  42
  43 static bool syslog_is_stream = false;
  44
  45 static bool show_color = false;
  46 static bool show_location = false;
  47
  48 /* Akin to glibc's __abort_msg; which is private and we hence cannot
  49  * use here. */
  50 static char *log_abort_msg = NULL;
  51
  52 void log_close_console(void) {
  53
  54         if (console_fd < 0)
  55                 return;
  56
  57         if (getpid() == 1) {
  58                 if (console_fd >= 3)
  59                         close_nointr_nofail(console_fd);
  60
  61                 console_fd = -1;
  62         }
  63 }
  64
  65 static int log_open_console(void) {
  66
  67         if (console_fd >= 0)
  68                 return 0;
  69
  70         if (getpid() == 1) {
  71
  72                 if ((console_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC)) < 0) {
  73                         log_error("Failed to open /dev/console for logging: %s", strerror(-console_fd));
  74                         return console_fd;
  75                 }
  76
  77                 log_debug("Successfully opened /dev/console for logging.");
  78         } else
  79                 console_fd = STDERR_FILENO;
  80
  81         return 0;
  82 }
  83
  84 void log_close_kmsg(void) {
  85
  86         if (kmsg_fd < 0)
  87                 return;
  88
  89         close_nointr_nofail(kmsg_fd);
  90         kmsg_fd = -1;
  91 }
  92
  93 static int log_open_kmsg(void) {
  94
  95         if (kmsg_fd >= 0)
  96                 return 0;
  97
  98         if ((kmsg_fd = open("/dev/kmsg", O_WRONLY|O_NOCTTY|O_CLOEXEC)) < 0) {
  99                 log_error("Failed to open /dev/kmsg for logging: %s", strerror(errno));
 100                 return -errno;
 101         }
 102
 103         log_debug("Successfully opened /dev/kmsg for logging.");
 104
 105         return 0;
 106 }
 107
 108 void log_close_syslog(void) {
 109
 110         if (syslog_fd < 0)
 111                 return;
 112
 113         close_nointr_nofail(syslog_fd);
 114         syslog_fd = -1;
 115 }
 116
 117 static int create_log_socket(int type) {
 118         struct timeval tv;
 119         int fd;
 120
 121         if (getpid() == 1)
 122                 /* systemd should not block on syslog */
 123                 type |= SOCK_NONBLOCK;
 124         if ((fd = socket(AF_UNIX, type|SOCK_CLOEXEC, 0)) < 0)
 125                 return -errno;
 126
 127         /* Make sure we don't block for more than 5s when talking to
 128          * syslog */
 129         timeval_store(&tv, SYSLOG_TIMEOUT_USEC);
 130         if (setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0) {
 131                 close_nointr_nofail(fd);
 132                 return -errno;
 133         }
 134
 135         return fd;
 136 }
 137
 138 static int log_open_syslog(void) {
 139         union {
 140                 struct sockaddr sa;
 141                 struct sockaddr_un un;
 142         } sa;
 143         int r;
 144
 145         if (syslog_fd >= 0)
 146                 return 0;
 147
 148         zero(sa);
 149         sa.un.sun_family = AF_UNIX;
 150         strncpy(sa.un.sun_path, "/dev/log", sizeof(sa.un.sun_path));
 151
 152         if ((syslog_fd = create_log_socket(SOCK_DGRAM)) < 0) {
 153                 r = -errno;
 154                 goto fail;
 155         }
 156
 157         if (connect(syslog_fd, &sa.sa, sizeof(sa)) < 0) {
 158                 close_nointr_nofail(syslog_fd);
 159
 160                 /* Some legacy syslog systems still use stream
 161                  * sockets. They really shouldn't. But what can we
 162                  * do... */
 163                 if ((syslog_fd = create_log_socket(SOCK_STREAM)) < 0) {
 164                         r = -errno;
 165                         goto fail;
 166                 }
 167
 168                 if (connect(syslog_fd, &sa.sa, sizeof(sa)) < 0) {
 169                         r = -errno;
 170                         goto fail;
 171                 }
 172
 173                 syslog_is_stream = true;
 174         } else
 175                 syslog_is_stream = false;
 176
 177         log_debug("Successfully opened syslog for logging.");
 178
 179         return 0;
 180
 181 fail:
 182         log_close_syslog();
 183         log_debug("Failed to open syslog for logging: %s", strerror(-r));
 184         return r;
 185 }
 186
 187 int log_open(void) {
 188         int r;
 189
 190         /* If we don't use the console we close it here, to not get
 191          * killed by SAK. If we don't use syslog we close it here so
 192          * that we are not confused by somebody deleting the socket in
 193          * the fs. If we don't use /dev/kmsg we still keep it open,
 194          * because there is no reason to close it. */
 195
 196         if (log_target == LOG_TARGET_NULL) {
 197                 log_close_syslog();
 198                 log_close_console();
 199                 return 0;
 200         }
 201
 202         if (log_target != LOG_TARGET_AUTO ||
 203             getpid() == 1 ||
 204             isatty(STDERR_FILENO) <= 0) {
 205
 206                 if (log_target == LOG_TARGET_AUTO ||
 207                     log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
 208                     log_target == LOG_TARGET_SYSLOG)
 209                         if ((r = log_open_syslog()) >= 0) {
 210                                 log_close_console();
 211                                 return r;
 212                         }
 213                 if (log_target == LOG_TARGET_AUTO ||
 214                     log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
 215                     log_target == LOG_TARGET_KMSG)
 216                         if ((r = log_open_kmsg()) >= 0) {
 217                                 log_close_syslog();
 218                                 log_close_console();
 219                                 return r;
 220                         }
 221         }
 222
 223         log_close_syslog();
 224
 225         /* Get the real /dev/console if we are PID=1, hence reopen */
 226         log_close_console();
 227         return log_open_console();
 228 }
 229
 230 void log_set_target(LogTarget target) {
 231         assert(target >= 0);
 232         assert(target < _LOG_TARGET_MAX);
 233
 234         log_target = target;
 235 }
 236
 237 void log_close(void) {
 238         log_close_console();
 239         log_close_kmsg();
 240         log_close_syslog();
 241 }
 242
 243 void log_forget_fds(void) {
 244         console_fd = kmsg_fd = syslog_fd = -1;
 245 }
 246
 247 void log_set_max_level(int level) {
 248         assert((level & LOG_PRIMASK) == level);
 249
 250         log_max_level = level;
 251 }
 252
 253 static int write_to_console(
 254                 int level,
 255                 const char*file,
 256                 int line,
 257                 const char *func,
 258                 const char *buffer) {
 259
 260         char location[64];
 261         struct iovec iovec[5];
 262         unsigned n = 0;
 263         bool highlight;
 264
 265         if (console_fd < 0)
 266                 return 0;
 267
 268         snprintf(location, sizeof(location), "(%s:%u) ", file, line);
 269         char_array_0(location);
 270
 271         highlight = LOG_PRI(level) <= LOG_ERR && show_color;
 272
 273         zero(iovec);
 274         if (show_location)
 275                 IOVEC_SET_STRING(iovec[n++], location);
 276         if (highlight)
 277                 IOVEC_SET_STRING(iovec[n++], ANSI_HIGHLIGHT_ON);
 278         IOVEC_SET_STRING(iovec[n++], buffer);
 279         if (highlight)
 280                 IOVEC_SET_STRING(iovec[n++], ANSI_HIGHLIGHT_OFF);
 281         IOVEC_SET_STRING(iovec[n++], "\n");
 282
 283         if (writev(console_fd, iovec, n) < 0)
 284                 return -errno;
 285
 286         return 1;
 287 }
 288
 289 static int write_to_syslog(
 290         int level,
 291         const char*file,
 292         int line,
 293         const char *func,
 294         const char *buffer) {
 295
 296         char header_priority[16], header_time[64], header_pid[16];
 297         struct iovec iovec[5];
 298         struct msghdr msghdr;
 299         time_t t;
 300         struct tm *tm;
 301
 302         if (syslog_fd < 0)
 303                 return 0;
 304
 305         snprintf(header_priority, sizeof(header_priority), "<%i>", level);
 306         char_array_0(header_priority);
 307
 308         t = (time_t) (now(CLOCK_REALTIME) / USEC_PER_SEC);
 309         if (!(tm = localtime(&t)))
 310                 return -EINVAL;
 311
 312         if (strftime(header_time, sizeof(header_time), "%h %e %T ", tm) <= 0)
 313                 return -EINVAL;
 314
 315         snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) getpid());
 316         char_array_0(header_pid);
 317
 318         zero(iovec);
 319         IOVEC_SET_STRING(iovec[0], header_priority);
 320         IOVEC_SET_STRING(iovec[1], header_time);
 321         IOVEC_SET_STRING(iovec[2], program_invocation_short_name);
 322         IOVEC_SET_STRING(iovec[3], header_pid);
 323         IOVEC_SET_STRING(iovec[4], buffer);
 324
 325         /* When using syslog via SOCK_STREAM separate the messages by NUL chars */
 326         if (syslog_is_stream)
 327                 iovec[4].iov_len++;
 328
 329         zero(msghdr);
 330         msghdr.msg_iov = iovec;
 331         msghdr.msg_iovlen = ELEMENTSOF(iovec);
 332
 333         for (;;) {
 334                 ssize_t n;
 335
 336                 n = sendmsg(syslog_fd, &msghdr, MSG_NOSIGNAL);
 337                 if (n < 0)
 338                         return -errno;
 339
 340                 if (!syslog_is_stream ||
 341                     (size_t) n >= IOVEC_TOTAL_SIZE(iovec, ELEMENTSOF(iovec)))
 342                         break;
 343
 344                 IOVEC_INCREMENT(iovec, ELEMENTSOF(iovec), n);
 345         }
 346
 347         return 1;
 348 }
 349
 350 static int write_to_kmsg(
 351         int level,
 352         const char*file,
 353         int line,
 354         const char *func,
 355         const char *buffer) {
 356
 357         char header_priority[16], header_pid[16];
 358         struct iovec iovec[5];
 359
 360         if (kmsg_fd < 0)
 361                 return 0;
 362
 363         snprintf(header_priority, sizeof(header_priority), "<%i>", level);
 364         char_array_0(header_priority);
 365
 366         snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) getpid());
 367         char_array_0(header_pid);
 368
 369         zero(iovec);
 370         IOVEC_SET_STRING(iovec[0], header_priority);
 371         IOVEC_SET_STRING(iovec[1], program_invocation_short_name);
 372         IOVEC_SET_STRING(iovec[2], header_pid);
 373         IOVEC_SET_STRING(iovec[3], buffer);
 374         IOVEC_SET_STRING(iovec[4], "\n");
 375
 376         if (writev(kmsg_fd, iovec, ELEMENTSOF(iovec)) < 0)
 377                 return -errno;
 378
 379         return 1;
 380 }
 381
 382 static int log_dispatch(
 383         int level,
 384         const char*file,
 385         int line,
 386         const char *func,
 387         char *buffer) {
 388
 389         int r = 0;
 390
 391         if (log_target == LOG_TARGET_NULL)
 392                 return 0;
 393
 394         /* Patch in LOG_DAEMON facility if necessary */
 395         if ((level & LOG_FACMASK) == 0)
 396                 level = LOG_DAEMON | LOG_PRI(level);
 397
 398         do {
 399                 char *e;
 400                 int k = 0;
 401
 402                 buffer += strspn(buffer, NEWLINE);
 403
 404                 if (buffer[0] == 0)
 405                         break;
 406
 407                 if ((e = strpbrk(buffer, NEWLINE)))
 408                         *(e++) = 0;
 409
 410                 if (log_target == LOG_TARGET_AUTO ||
 411                     log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
 412                     log_target == LOG_TARGET_SYSLOG) {
 413
 414                         k = write_to_syslog(level, file, line, func, buffer);
 415                         if (k < 0) {
 416                                 if (k != -EAGAIN)
 417                                         log_close_syslog();
 418                                 log_open_kmsg();
 419                         } else if (k > 0)
 420                                 r++;
 421                 }
 422
 423                 if (k <= 0 &&
 424                     (log_target == LOG_TARGET_AUTO ||
 425                      log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
 426                      log_target == LOG_TARGET_KMSG)) {
 427
 428                         k = write_to_kmsg(level, file, line, func, buffer);
 429                         if (k < 0) {
 430                                 log_close_kmsg();
 431                                 log_open_console();
 432                         } else if (k > 0)
 433                                 r++;
 434                 }
 435
 436                 if (k <= 0) {
 437                         k = write_to_console(level, file, line, func, buffer);
 438                         if (k < 0)
 439                                 return k;
 440                 }
 441
 442                 buffer = e;
 443         } while (buffer);
 444
 445         return r;
 446 }
 447
 448 int log_dump_internal(
 449         int level,
 450         const char*file,
 451         int line,
 452         const char *func,
 453         char *buffer) {
 454
 455         int saved_errno, r;
 456
 457         /* This modifies the buffer... */
 458
 459         if (_likely_(LOG_PRI(level) > log_max_level))
 460                 return 0;
 461
 462         saved_errno = errno;
 463         r = log_dispatch(level, file, line, func, buffer);
 464         errno = saved_errno;
 465
 466         return r;
 467 }
 468
 469 int log_meta(
 470         int level,
 471         const char*file,
 472         int line,
 473         const char *func,
 474         const char *format, ...) {
 475
 476         char buffer[LINE_MAX];
 477         int saved_errno, r;
 478         va_list ap;
 479
 480         if (_likely_(LOG_PRI(level) > log_max_level))
 481                 return 0;
 482
 483         saved_errno = errno;
 484
 485         va_start(ap, format);
 486         vsnprintf(buffer, sizeof(buffer), format, ap);
 487         va_end(ap);
 488
 489         char_array_0(buffer);
 490
 491         r = log_dispatch(level, file, line, func, buffer);
 492         errno = saved_errno;
 493
 494         return r;
 495 }
 496
 497 void log_assert(
 498         const char*file,
 499         int line,
 500         const char *func,
 501         const char *format, ...) {
 502
 503         static char buffer[LINE_MAX];
 504         int saved_errno = errno;
 505         va_list ap;
 506
 507         va_start(ap, format);
 508         vsnprintf(buffer, sizeof(buffer), format, ap);
 509         va_end(ap);
 510
 511         char_array_0(buffer);
 512         log_abort_msg = buffer;
 513
 514         log_dispatch(LOG_CRIT, file, line, func, buffer);
 515         abort();
 516
 517         /* If the user chose to ignore this SIGABRT, we are happy to go on, as if nothing happened. */
 518         errno = saved_errno;
 519 }
 520
 521 int log_set_target_from_string(const char *e) {
 522         LogTarget t;
 523
 524         if ((t = log_target_from_string(e)) < 0)
 525                 return -EINVAL;
 526
 527         log_set_target(t);
 528         return 0;
 529 }
 530
 531 int log_set_max_level_from_string(const char *e) {
 532         int t;
 533
 534         if ((t = log_level_from_string(e)) < 0)
 535                 return -EINVAL;
 536
 537         log_set_max_level(t);
 538         return 0;
 539 }
 540
 541 void log_parse_environment(void) {
 542         const char *e;
 543
 544         if ((e = getenv("SYSTEMD_LOG_TARGET")))
 545                 if (log_set_target_from_string(e) < 0)
 546                         log_warning("Failed to parse log target %s. Ignoring.", e);
 547
 548         if ((e = getenv("SYSTEMD_LOG_LEVEL")))
 549                 if (log_set_max_level_from_string(e) < 0)
 550                         log_warning("Failed to parse log level %s. Ignoring.", e);
 551
 552         if ((e = getenv("SYSTEMD_LOG_COLOR")))
 553                 if (log_show_color_from_string(e) < 0)
 554                         log_warning("Failed to parse bool %s. Ignoring.", e);
 555
 556         if ((e = getenv("SYSTEMD_LOG_LOCATION")))
 557                 if (log_show_location_from_string(e) < 0)
 558                         log_warning("Failed to parse bool %s. Ignoring.", e);
 559 }
 560
 561 LogTarget log_get_target(void) {
 562         return log_target;
 563 }
 564
 565 int log_get_max_level(void) {
 566         return log_max_level;
 567 }
 568
 569 void log_show_color(bool b) {
 570         show_color = b;
 571 }
 572
 573 void log_show_location(bool b) {
 574         show_location = b;
 575 }
 576
 577 int log_show_color_from_string(const char *e) {
 578         int t;
 579
 580         if ((t = parse_boolean(e)) < 0)
 581                 return -EINVAL;
 582
 583         log_show_color(t);
 584         return 0;
 585 }
 586
 587 int log_show_location_from_string(const char *e) {
 588         int t;
 589
 590         if ((t = parse_boolean(e)) < 0)
 591                 return -EINVAL;
 592
 593         log_show_location(t);
 594         return 0;
 595 }
 596
 597 static const char *const log_target_table[] = {
 598         [LOG_TARGET_CONSOLE] = "console",
 599         [LOG_TARGET_SYSLOG] = "syslog",
 600         [LOG_TARGET_KMSG] = "kmsg",
 601         [LOG_TARGET_SYSLOG_OR_KMSG] = "syslog-or-kmsg",
 602         [LOG_TARGET_NULL] = "null",
 603         [LOG_TARGET_AUTO] = "auto"
 604 };
 605
 606 DEFINE_STRING_TABLE_LOOKUP(log_target, LogTarget);