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 static size_t _lvm_errmsg_size = 0;
  47 static size_t _lvm_errmsg_len = 0;
  48 #define MAX_ERRMSG_LEN (512 * 1024)  /* Max size of error buffer 512KB */
  49
  50 void init_log_fn(lvm2_log_fn_t log_fn)
  51 {
  52         if (log_fn)
  53                 _lvm2_log_fn = log_fn;
  54         else
  55                 _lvm2_log_fn = NULL;
  56 }
  57
  58 void init_log_file(const char *log_file, int append)
  59 {
  60         const char *open_mode = append ? "a" : "w";
  61
  62         if (!(_log_file = fopen(log_file, open_mode))) {
  63                 log_sys_error("fopen", log_file);
  64                 return;
  65         }
  66
  67         _log_to_file = 1;
  68 }
  69
  70 void init_log_direct(const char *log_file, int append)
  71 {
  72         int open_flags = append ? 0 : O_TRUNC;
  73
  74         dev_create_file(log_file, &_log_dev, &_log_dev_alias, 1);
  75         if (!dev_open_flags(&_log_dev, O_RDWR | O_CREAT | open_flags, 1, 0))
  76                 return;
  77
  78         _log_direct = 1;
  79 }
  80
  81 void init_log_while_suspended(int log_while_suspended)
  82 {
  83         _log_while_suspended = log_while_suspended;
  84 }
  85
  86 void init_syslog(int facility)
  87 {
  88         openlog("lvm", LOG_PID, facility);
  89         _syslog = 1;
  90 }
  91
  92 int log_suppress(int suppress)
  93 {
  94         int old_suppress = _log_suppress;
  95
  96         _log_suppress = suppress;
  97
  98         return old_suppress;
  99 }
 100
 101 void release_log_memory(void)
 102 {
 103         if (!_log_direct)
 104                 return;
 105
 106         dm_free((char *) _log_dev_alias.str);
 107         _log_dev_alias.str = "activate_log file";
 108 }
 109
 110 void fin_log(void)
 111 {
 112         if (_log_direct) {
 113                 (void) dev_close(&_log_dev);
 114                 _log_direct = 0;
 115         }
 116
 117         if (_log_to_file) {
 118                 if (dm_fclose(_log_file)) {
 119                         if (errno)
 120                               fprintf(stderr, "failed to write log file: %s\n",
 121                                       strerror(errno));
 122                         else
 123                               fprintf(stderr, "failed to write log file\n");
 124
 125                 }
 126                 _log_to_file = 0;
 127         }
 128 }
 129
 130 void fin_syslog(void)
 131 {
 132         if (_syslog)
 133                 closelog();
 134         _syslog = 0;
 135 }
 136
 137 void init_msg_prefix(const char *prefix)
 138 {
 139         strncpy(_msg_prefix, prefix, sizeof(_msg_prefix) - 1);
 140         _msg_prefix[sizeof(_msg_prefix) - 1] = '\0';
 141 }
 142
 143 void init_indent(int indent)
 144 {
 145         _indent = indent;
 146 }
 147
 148 void init_abort_on_internal_errors(int fatal)
 149 {
 150         _abort_on_internal_errors = fatal;
 151 }
 152
 153 void reset_lvm_errno(int store_errmsg)
 154 {
 155         _lvm_errno = 0;
 156
 157         if (_lvm_errmsg) {
 158                 dm_free(_lvm_errmsg);
 159                 _lvm_errmsg = NULL;
 160                 _lvm_errmsg_size = _lvm_errmsg_len = 0;
 161         }
 162
 163         _store_errmsg = store_errmsg;
 164 }
 165
 166 int stored_errno(void)
 167 {
 168         return _lvm_errno;
 169 }
 170
 171 const char *stored_errmsg(void)
 172 {
 173         return _lvm_errmsg ? : "";
 174 }
 175
 176 static struct dm_hash_table *_duplicated = NULL;
 177
 178 void reset_log_duplicated(void) {
 179         if (_duplicated) {
 180                 dm_hash_destroy(_duplicated);
 181                 _duplicated = NULL;
 182         }
 183 }
 184
 185 void print_log(int level, const char *file, int line, int dm_errno,
 186                const char *format, ...)
 187 {
 188         va_list ap;
 189         char buf[1024], locn[4096];
 190         int bufused, n;
 191         const char *message;
 192         const char *trformat;           /* Translated format string */
 193         char *newbuf;
 194         int use_stderr = level & _LOG_STDERR;
 195         int log_once = level & _LOG_ONCE;
 196         int fatal_internal_error = 0;
 197         size_t msglen;
 198
 199         level &= ~(_LOG_STDERR|_LOG_ONCE);
 200
 201         if (_abort_on_internal_errors &&
 202             !strncmp(format, INTERNAL_ERROR,
 203                      strlen(INTERNAL_ERROR))) {
 204                 fatal_internal_error = 1;
 205                 /* Internal errors triggering abort cannot be suppressed. */
 206                 _log_suppress = 0;
 207                 level = _LOG_FATAL;
 208         }
 209
 210         if (_log_suppress == 2)
 211                 return;
 212
 213         if (level <= _LOG_ERR)
 214                 init_error_message_produced(1);
 215
 216         trformat = _(format);
 217
 218         if (dm_errno && !_lvm_errno)
 219                 _lvm_errno = dm_errno;
 220
 221         if (_lvm2_log_fn ||
 222             (_store_errmsg && (level <= _LOG_ERR)) ||
 223             log_once) {
 224                 va_start(ap, format);
 225                 n = vsnprintf(locn, sizeof(locn) - 1, trformat, ap);
 226                 va_end(ap);
 227
 228                 if (n < 0) {
 229                         fprintf(stderr, _("vsnprintf failed: skipping external "
 230                                         "logging function"));
 231                         goto log_it;
 232                 }
 233
 234                 locn[sizeof(locn) - 1] = '\0';
 235                 message = locn;
 236         }
 237
 238 /* FIXME Avoid pointless use of message buffer when it'll never be read! */
 239         if (_store_errmsg && (level <= _LOG_ERR) &&
 240             _lvm_errmsg_len < MAX_ERRMSG_LEN) {
 241                 msglen = strlen(message);
 242                 if ((_lvm_errmsg_len + msglen + 1) >= _lvm_errmsg_size) {
 243                         _lvm_errmsg_size = 2 * (_lvm_errmsg_len + msglen + 1);
 244                         if ((newbuf = dm_realloc(_lvm_errmsg,
 245                                                  _lvm_errmsg_size)))
 246                                 _lvm_errmsg = newbuf;
 247                         else
 248                                 _lvm_errmsg_size = _lvm_errmsg_len;
 249                 }
 250                 if (_lvm_errmsg &&
 251                     (_lvm_errmsg_len + msglen + 2) < _lvm_errmsg_size) {
 252                         /* prepend '\n' and copy with '\0' but do not count in */
 253                         if (_lvm_errmsg_len)
 254                                 _lvm_errmsg[_lvm_errmsg_len++] = '\n';
 255                         memcpy(_lvm_errmsg + _lvm_errmsg_len, message, msglen + 1);
 256                         _lvm_errmsg_len += msglen;
 257                 }
 258         }
 259
 260         if (log_once) {
 261                 if (!_duplicated)
 262                         _duplicated = dm_hash_create(128);
 263                 if (_duplicated) {
 264                         if (dm_hash_lookup(_duplicated, message))
 265                                 level = _LOG_NOTICE;
 266                         (void) dm_hash_insert(_duplicated, message, (void*)1);
 267                 }
 268         }
 269
 270         if (_lvm2_log_fn) {
 271                 _lvm2_log_fn(level, file, line, 0, message);
 272                 if (fatal_internal_error)
 273                         abort();
 274                 return;
 275         }
 276
 277       log_it:
 278         if (!_log_suppress) {
 279                 if (verbose_level() > _LOG_DEBUG)
 280                         (void) dm_snprintf(locn, sizeof(locn), "#%s:%d ",
 281                                            file, line);
 282                 else
 283                         locn[0] = '\0';
 284
 285                 va_start(ap, format);
 286                 switch (level) {
 287                 case _LOG_DEBUG:
 288                         if (!strcmp("<backtrace>", format) &&
 289                             verbose_level() <= _LOG_DEBUG)
 290                                 break;
 291                         if (verbose_level() >= _LOG_DEBUG) {
 292                                 fprintf(stderr, "%s%s%s", locn, log_command_name(),
 293                                         _msg_prefix);
 294                                 if (_indent)
 295                                         fprintf(stderr, "      ");
 296                                 vfprintf(stderr, trformat, ap);
 297                                 fputc('\n', stderr);
 298                         }
 299                         break;
 300
 301                 case _LOG_INFO:
 302                         if (verbose_level() >= _LOG_INFO) {
 303                                 fprintf(stderr, "%s%s%s", locn, log_command_name(),
 304                                         _msg_prefix);
 305                                 if (_indent)
 306                                         fprintf(stderr, "    ");
 307                                 vfprintf(stderr, trformat, ap);
 308                                 fputc('\n', stderr);
 309                         }
 310                         break;
 311                 case _LOG_NOTICE:
 312                         if (verbose_level() >= _LOG_NOTICE) {
 313                                 fprintf(stderr, "%s%s%s", locn, log_command_name(),
 314                                         _msg_prefix);
 315                                 if (_indent)
 316                                         fprintf(stderr, "  ");
 317                                 vfprintf(stderr, trformat, ap);
 318                                 fputc('\n', stderr);
 319                         }
 320                         break;
 321                 case _LOG_WARN:
 322                         if (verbose_level() >= _LOG_WARN) {
 323                                 fprintf(use_stderr ? stderr : stdout, "%s%s",
 324                                         log_command_name(), _msg_prefix);
 325                                 vfprintf(use_stderr ? stderr : stdout, trformat, ap);
 326                                 fputc('\n', use_stderr ? stderr : stdout);
 327                         }
 328                         break;
 329                 case _LOG_ERR:
 330                         if (verbose_level() >= _LOG_ERR) {
 331                                 fprintf(stderr, "%s%s%s", locn, log_command_name(),
 332                                         _msg_prefix);
 333                                 vfprintf(stderr, trformat, ap);
 334                                 fputc('\n', stderr);
 335                         }
 336                         break;
 337                 case _LOG_FATAL:
 338                 default:
 339                         if (verbose_level() >= _LOG_FATAL) {
 340                                 fprintf(stderr, "%s%s%s", locn, log_command_name(),
 341                                         _msg_prefix);
 342                                 vfprintf(stderr, trformat, ap);
 343                                 fputc('\n', stderr);
 344                         }
 345                         break;
 346                 }
 347                 va_end(ap);
 348         }
 349
 350         if (fatal_internal_error)
 351                 abort();
 352
 353         if (level > debug_level())
 354                 return;
 355
 356         if (_log_to_file && (_log_while_suspended || !critical_section())) {
 357                 fprintf(_log_file, "%s:%d %s%s", file, line, log_command_name(),
 358                         _msg_prefix);
 359
 360                 va_start(ap, format);
 361                 vfprintf(_log_file, trformat, ap);
 362                 va_end(ap);
 363
 364                 fprintf(_log_file, "\n");
 365                 fflush(_log_file);
 366         }
 367
 368         if (_syslog && (_log_while_suspended || !critical_section())) {
 369                 va_start(ap, format);
 370                 vsyslog(level, trformat, ap);
 371                 va_end(ap);
 372         }
 373
 374         /* FIXME This code is unfinished - pre-extend & condense. */
 375         if (!_already_logging && _log_direct && critical_section()) {
 376                 _already_logging = 1;
 377                 memset(&buf, ' ', sizeof(buf));
 378                 bufused = 0;
 379                 if ((n = dm_snprintf(buf, sizeof(buf) - 1,
 380                                       "%s:%d %s%s", file, line, log_command_name(),
 381                                       _msg_prefix)) == -1)
 382                         goto done;
 383
 384                 bufused += n;
 385
 386                 va_start(ap, format);
 387                 n = vsnprintf(buf + bufused - 1, sizeof(buf) - bufused - 1,
 388                               trformat, ap);
 389                 va_end(ap);
 390                 bufused += n;
 391
 392                 buf[bufused - 1] = '\n';
 393               done:
 394                 buf[bufused] = '\n';
 395                 buf[sizeof(buf) - 1] = '\n';
 396                 /* FIXME real size bufused */
 397                 dev_append(&_log_dev, sizeof(buf), buf);
 398                 _already_logging = 0;
 399         }
 400 }