lib/log/log.c

   1 /*
   2  * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
   3  * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
   4  *
   5  * This file is part of LVM2.
   6  *
   7  * This copyrighted material is made available to anyone wishing to use,
   8  * modify, copy, or redistribute it subject to the terms and conditions
   9  * of the GNU Lesser General Public License v.2.1.
  10  *
  11  * You should have received a copy of the GNU Lesser General Public License
  12  * along with this program; if not, write to the Free Software Foundation,
  13  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  14  */
  15
  16 #include "lib.h"
  17 #include "device.h"
  18 #include "memlock.h"
  19 #include "lvm-string.h"
  20 #include "lvm-file.h"
  21 #include "defaults.h"
  22 #include "config.h"
  23
  24 #include <stdarg.h>
  25 #include <syslog.h>
  26
  27 static FILE *_log_file;
  28 static struct device _log_dev;
  29 static struct str_list _log_dev_alias;
  30
  31 static int _syslog = 0;
  32 static int _log_to_file = 0;
  33 static int _log_direct = 0;
  34 static int _log_while_suspended = 0;
  35 static int _indent = 1;
  36 static int _log_suppress = 0;
  37 static char _msg_prefix[30] = "  ";
  38 static int _already_logging = 0;
  39 static int _abort_on_internal_errors = 0;
  40
  41 static lvm2_log_fn_t _lvm2_log_fn = NULL;
  42
  43 static int _lvm_errno = 0;
  44 static int _store_errmsg = 0;
  45 static char *_lvm_errmsg = NULL;
  46
  47 void init_log_fn(lvm2_log_fn_t log_fn)
  48 {
  49         if (log_fn)
  50                 _lvm2_log_fn = log_fn;
  51         else
  52                 _lvm2_log_fn = NULL;
  53 }
  54
  55 void init_log_file(const char *log_file, int append)
  56 {
  57         const char *open_mode = append ? "a" : "w";
  58
  59         if (!(_log_file = fopen(log_file, open_mode))) {
  60                 log_sys_error("fopen", log_file);
  61                 return;
  62         }
  63
  64         _log_to_file = 1;
  65 }
  66
  67 void init_log_direct(const char *log_file, int append)
  68 {
  69         int open_flags = append ? 0 : O_TRUNC;
  70
  71         dev_create_file(log_file, &_log_dev, &_log_dev_alias, 1);
  72         if (!dev_open_flags(&_log_dev, O_RDWR | O_CREAT | open_flags, 1, 0))
  73                 return;
  74
  75         _log_direct = 1;
  76 }
  77
  78 void init_log_while_suspended(int log_while_suspended)
  79 {
  80         _log_while_suspended = log_while_suspended;
  81 }
  82
  83 void init_syslog(int facility)
  84 {
  85         openlog("lvm", LOG_PID, facility);
  86         _syslog = 1;
  87 }
  88
  89 int log_suppress(int suppress)
  90 {
  91         int old_suppress = _log_suppress;
  92
  93         _log_suppress = suppress;
  94
  95         return old_suppress;
  96 }
  97
  98 void release_log_memory(void)
  99 {
 100         if (!_log_direct)
 101                 return;
 102
 103         dm_free((char *) _log_dev_alias.str);
 104         _log_dev_alias.str = "activate_log file";
 105 }
 106
 107 void fin_log(void)
 108 {
 109         if (_log_direct) {
 110                 dev_close(&_log_dev);
 111                 _log_direct = 0;
 112         }
 113
 114         if (_log_to_file) {
 115                 if (dm_fclose(_log_file)) {
 116                         if (errno)
 117                               fprintf(stderr, "failed to write log file: %s\n",
 118                                       strerror(errno));
 119                         else
 120                               fprintf(stderr, "failed to write log file\n");
 121
 122                 }
 123                 _log_to_file = 0;
 124         }
 125 }
 126
 127 void fin_syslog()
 128 {
 129         if (_syslog)
 130                 closelog();
 131         _syslog = 0;
 132 }
 133
 134 void init_msg_prefix(const char *prefix)
 135 {
 136         strncpy(_msg_prefix, prefix, sizeof(_msg_prefix));
 137         _msg_prefix[sizeof(_msg_prefix) - 1] = '\0';
 138 }
 139
 140 void init_indent(int indent)
 141 {
 142         _indent = indent;
 143 }
 144
 145 void init_abort_on_internal_errors(int fatal)
 146 {
 147         _abort_on_internal_errors = fatal;
 148 }
 149
 150 void reset_lvm_errno(int store_errmsg)
 151 {
 152         _lvm_errno = 0;
 153
 154         if (_lvm_errmsg) {
 155                 dm_free(_lvm_errmsg);
 156                 _lvm_errmsg = NULL;
 157         }
 158
 159         _store_errmsg = store_errmsg;
 160 }
 161
 162 int stored_errno(void)
 163 {
 164         return _lvm_errno;
 165 }
 166
 167 const char *stored_errmsg(void)
 168 {
 169         return _lvm_errmsg ? : "";
 170 }
 171
 172 static struct dm_hash_table *_duplicated = NULL;
 173
 174 void reset_log_duplicated(void) {
 175         if (_duplicated)
 176                 dm_hash_destroy(_duplicated);
 177         _duplicated = NULL;
 178 }
 179
 180 void print_log(int level, const char *file, int line, int dm_errno,
 181                const char *format, ...)
 182 {
 183         va_list ap;
 184         char buf[1024], buf2[4096], locn[4096];
 185         int bufused, n;
 186         const char *message;
 187         const char *trformat;           /* Translated format string */
 188         char *newbuf;
 189         int use_stderr = level & _LOG_STDERR;
 190         int log_once = level & _LOG_ONCE;
 191         int fatal_internal_error = 0;
 192
 193         level &= ~(_LOG_STDERR|_LOG_ONCE);
 194
 195         if (_abort_on_internal_errors &&
 196             !strncmp(format, INTERNAL_ERROR,
 197                      strlen(INTERNAL_ERROR))) {
 198                 fatal_internal_error = 1;
 199                 /* Internal errors triggering abort cannot be suppressed. */
 200                 _log_suppress = 0;
 201                 level = _LOG_FATAL;
 202         }
 203
 204         if (_log_suppress == 2)
 205                 return;
 206
 207         if (level <= _LOG_ERR)
 208                 init_error_message_produced(1);
 209
 210         trformat = _(format);
 211
 212         if (dm_errno && !_lvm_errno)
 213                 _lvm_errno = dm_errno;
 214
 215         if (_lvm2_log_fn ||
 216             (_store_errmsg && (level <= _LOG_ERR)) ||
 217             log_once) {
 218                 va_start(ap, format);
 219                 n = vsnprintf(buf2, sizeof(buf2) - 1, trformat, ap);
 220                 va_end(ap);
 221
 222                 if (n < 0) {
 223                         fprintf(stderr, _("vsnprintf failed: skipping external "
 224                                         "logging function"));
 225                         goto log_it;
 226                 }
 227
 228                 buf2[sizeof(buf2) - 1] = '\0';
 229                 message = &buf2[0];
 230         }
 231
 232         if (_store_errmsg && (level <= _LOG_ERR)) {
 233                 if (!_lvm_errmsg)
 234                         _lvm_errmsg = dm_strdup(message);
 235                 else if ((newbuf = dm_realloc(_lvm_errmsg,
 236                                               strlen(_lvm_errmsg) +
 237                                               strlen(message) + 2))) {
 238                         _lvm_errmsg = strcat(newbuf, "\n");
 239                         _lvm_errmsg = strcat(newbuf, message);
 240                 }
 241         }
 242
 243         if (log_once) {
 244                 if (!_duplicated)
 245                         _duplicated = dm_hash_create(128);
 246                 if (_duplicated) {
 247                         if (dm_hash_lookup(_duplicated, message))
 248                                 level = _LOG_NOTICE;
 249                         dm_hash_insert(_duplicated, message, (void*)1);
 250                 }
 251         }
 252
 253         if (_lvm2_log_fn) {
 254                 _lvm2_log_fn(level, file, line, 0, message);
 255                 if (fatal_internal_error)
 256                         abort();
 257                 return;
 258         }
 259
 260       log_it:
 261         if (!_log_suppress) {
 262                 if (verbose_level() > _LOG_DEBUG)
 263                         dm_snprintf(locn, sizeof(locn), "#%s:%d ",
 264                                      file, line);
 265                 else
 266                         locn[0] = '\0';
 267
 268                 va_start(ap, format);
 269                 switch (level) {
 270                 case _LOG_DEBUG:
 271                         if (!strcmp("<backtrace>", format) &&
 272                             verbose_level() <= _LOG_DEBUG)
 273                                 break;
 274                         if (verbose_level() >= _LOG_DEBUG) {
 275                                 fprintf(stderr, "%s%s%s", locn, log_command_name(),
 276                                         _msg_prefix);
 277                                 if (_indent)
 278                                         fprintf(stderr, "      ");
 279                                 vfprintf(stderr, trformat, ap);
 280                                 fputc('\n', stderr);
 281                         }
 282                         break;
 283
 284                 case _LOG_INFO:
 285                         if (verbose_level() >= _LOG_INFO) {
 286                                 fprintf(stderr, "%s%s%s", locn, log_command_name(),
 287                                         _msg_prefix);
 288                                 if (_indent)
 289                                         fprintf(stderr, "    ");
 290                                 vfprintf(stderr, trformat, ap);
 291                                 fputc('\n', stderr);
 292                         }
 293                         break;
 294                 case _LOG_NOTICE:
 295                         if (verbose_level() >= _LOG_NOTICE) {
 296                                 fprintf(stderr, "%s%s%s", locn, log_command_name(),
 297                                         _msg_prefix);
 298                                 if (_indent)
 299                                         fprintf(stderr, "  ");
 300                                 vfprintf(stderr, trformat, ap);
 301                                 fputc('\n', stderr);
 302                         }
 303                         break;
 304                 case _LOG_WARN:
 305                         if (verbose_level() >= _LOG_WARN) {
 306                                 fprintf(use_stderr ? stderr : stdout, "%s%s",
 307                                         log_command_name(), _msg_prefix);
 308                                 vfprintf(use_stderr ? stderr : stdout, trformat, ap);
 309                                 fputc('\n', use_stderr ? stderr : stdout);
 310                         }
 311                         break;
 312                 case _LOG_ERR:
 313                         if (verbose_level() >= _LOG_ERR) {
 314                                 fprintf(stderr, "%s%s%s", locn, log_command_name(),
 315                                         _msg_prefix);
 316                                 vfprintf(stderr, trformat, ap);
 317                                 fputc('\n', stderr);
 318                         }
 319                         break;
 320                 case _LOG_FATAL:
 321                 default:
 322                         if (verbose_level() >= _LOG_FATAL) {
 323                                 fprintf(stderr, "%s%s%s", locn, log_command_name(),
 324                                         _msg_prefix);
 325                                 vfprintf(stderr, trformat, ap);
 326                                 fputc('\n', stderr);
 327                         }
 328                         break;
 329                 }
 330                 va_end(ap);
 331         }
 332
 333         if (fatal_internal_error)
 334                 abort();
 335
 336         if (level > debug_level())
 337                 return;
 338
 339         if (_log_to_file && (_log_while_suspended || !memlock())) {
 340                 fprintf(_log_file, "%s:%d %s%s", file, line, log_command_name(),
 341                         _msg_prefix);
 342
 343                 va_start(ap, format);
 344                 vfprintf(_log_file, trformat, ap);
 345                 va_end(ap);
 346
 347                 fprintf(_log_file, "\n");
 348                 fflush(_log_file);
 349         }
 350
 351         if (_syslog && (_log_while_suspended || !memlock())) {
 352                 va_start(ap, format);
 353                 vsyslog(level, trformat, ap);
 354                 va_end(ap);
 355         }
 356
 357         /* FIXME This code is unfinished - pre-extend & condense. */
 358         if (!_already_logging && _log_direct && memlock()) {
 359                 _already_logging = 1;
 360                 memset(&buf, ' ', sizeof(buf));
 361                 bufused = 0;
 362                 if ((n = dm_snprintf(buf, sizeof(buf) - 1,
 363                                       "%s:%d %s%s", file, line, log_command_name(),
 364                                       _msg_prefix)) == -1)
 365                         goto done;
 366
 367                 bufused += n;
 368
 369                 va_start(ap, format);
 370                 n = vsnprintf(buf + bufused - 1, sizeof(buf) - bufused - 1,
 371                               trformat, ap);
 372                 va_end(ap);
 373                 bufused += n;
 374
 375               done:
 376                 buf[bufused - 1] = '\n';
 377                 buf[bufused] = '\n';
 378                 buf[sizeof(buf) - 1] = '\n';
 379                 /* FIXME real size bufused */
 380                 dev_append(&_log_dev, sizeof(buf), buf);
 381                 _already_logging = 0;
 382         }
 383 }