pintos-os.org Git - openvswitch/blob - lib/vlog.c

   1 /* Copyright (c) 2008 The Board of Trustees of The Leland Stanford
   2  * Junior University
   3  *
   4  * We are making the OpenFlow specification and associated documentation
   5  * (Software) available for public use and benefit with the expectation
   6  * that others will use, modify and enhance the Software and contribute
   7  * those enhancements back to the community. However, since we would
   8  * like to make the Software available for broadest use, with as few
   9  * restrictions as possible permission is hereby granted, free of
  10  * charge, to any person obtaining a copy of this Software to deal in
  11  * the Software under the copyrights without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sublicense, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be
  18  * included in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  24  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  25  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  26  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  27  * SOFTWARE.
  28  *
  29  * The name and trademarks of copyright holder(s) may NOT be used in
  30  * advertising or publicity pertaining to the Software or any
  31  * derivatives without specific, written prior permission.
  32  */
  33
  34 #include "vlog.h"
  35 #include <assert.h>
  36 #include <errno.h>
  37 #include <stdarg.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <sys/ipc.h>
  41 #include <sys/shm.h>
  42 #include <syslog.h>
  43 #include <time.h>
  44 #include "dynamic-string.h"
  45 #include "util.h"
  46
  47 #define THIS_MODULE VLM_vlog
  48
  49 /* Name for each logging level. */
  50 static const char *level_names[VLL_N_LEVELS] = {
  51     [VLL_EMER] = "EMER",
  52     [VLL_ERR] = "ERR",
  53     [VLL_WARN] = "WARN",
  54     [VLL_DBG] = "DBG",
  55 };
  56
  57 /* Name for each logging facility. */
  58 static const char *facility_names[VLF_N_FACILITIES] = {
  59     [VLF_CONSOLE] = "console",
  60     [VLF_SYSLOG] = "syslog",
  61 };
  62
  63 /* Name for each logging module */
  64 static const char *module_names[VLM_N_MODULES] = {
  65 #define VLOG_MODULE(NAME) #NAME,
  66     VLOG_MODULES
  67 #undef VLOG_MODULES
  68 };
  69
  70 static int levels[VLM_N_MODULES][VLF_N_FACILITIES];
  71
  72 /* Searches the 'n_names' in 'names'.  Returns the index of a match for
  73  * 'target', or 'n_names' if no name matches. */
  74 static size_t
  75 search_name_array(const char *target, const char **names, size_t n_names)
  76 {
  77     size_t i;
  78
  79     for (i = 0; i < n_names; i++) {
  80         assert(names[i]);
  81         if (!strcasecmp(names[i], target)) {
  82             break;
  83         }
  84     }
  85     return i;
  86 }
  87
  88 /* Returns the name for logging level 'level'. */
  89 const char *
  90 vlog_get_level_name(enum vlog_level level)
  91 {
  92     assert(level < VLL_N_LEVELS);
  93     return level_names[level];
  94 }
  95
  96 /* Returns the logging level with the given 'name', or VLL_N_LEVELS if 'name'
  97  * is not the name of a logging level. */
  98 enum vlog_level
  99 vlog_get_level_val(const char *name)
 100 {
 101     return search_name_array(name, level_names, ARRAY_SIZE(level_names));
 102 }
 103
 104 /* Returns the name for logging facility 'facility'. */
 105 const char *
 106 vlog_get_facility_name(enum vlog_facility facility)
 107 {
 108     assert(facility < VLF_N_FACILITIES);
 109     return facility_names[facility];
 110 }
 111
 112 /* Returns the logging facility named 'name', or VLF_N_FACILITIES if 'name' is
 113  * not the name of a logging facility. */
 114 enum vlog_facility
 115 vlog_get_facility_val(const char *name)
 116 {
 117     return search_name_array(name, facility_names, ARRAY_SIZE(facility_names));
 118 }
 119
 120 /* Returns the name for logging module 'module'. */
 121 const char *vlog_get_module_name(enum vlog_module module)
 122 {
 123     assert(module < VLM_N_MODULES);
 124     return module_names[module];
 125 }
 126
 127 /* Returns the logging module named 'name', or VLM_N_MODULES if 'name' is not
 128  * the name of a logging module. */
 129 enum vlog_module
 130 vlog_get_module_val(const char *name)
 131 {
 132     return search_name_array(name, module_names, ARRAY_SIZE(module_names));
 133 }
 134
 135 /* Returns the current logging level for the given 'module' and 'facility'. */
 136 enum vlog_level
 137 vlog_get_level(enum vlog_module module, enum vlog_facility facility)
 138 {
 139     assert(module < VLM_N_MODULES);
 140     assert(facility < VLF_N_FACILITIES);
 141     return levels[module][facility];
 142 }
 143
 144 static void
 145 set_facility_level(enum vlog_facility facility, enum vlog_module module,
 146                    enum vlog_level level)
 147 {
 148     assert(facility >= 0 && facility < VLF_N_FACILITIES);
 149     assert(level < VLL_N_LEVELS);
 150
 151     if (module == VLM_ANY_MODULE) {
 152         for (module = 0; module < VLM_N_MODULES; module++) {
 153             levels[module][facility] = level;
 154         }
 155     } else {
 156         levels[module][facility] = level;
 157     }
 158 }
 159
 160 /* Sets the logging level for the given 'module' and 'facility' to 'level'. */
 161 void
 162 vlog_set_levels(enum vlog_module module, enum vlog_facility facility,
 163                 enum vlog_level level)
 164 {
 165     assert(facility < VLF_N_FACILITIES || facility == VLF_ANY_FACILITY);
 166     if (facility == VLF_ANY_FACILITY) {
 167         for (facility = 0; facility < VLF_N_FACILITIES; facility++) {
 168             set_facility_level(facility, module, level);
 169         }
 170     } else {
 171         set_facility_level(facility, module, level);
 172     }
 173 }
 174
 175 /* Set debugging levels:
 176  *
 177  *  mod:facility:level mod2:facility:level ...
 178  *
 179  * Return null if successful, otherwise an error message that the caller must
 180  * free().
 181  */
 182 char *
 183 vlog_set_levels_from_string(const char *s_)
 184 {
 185     char *save_ptr;
 186     char *s = xstrdup(s_);
 187     char *module, *level, *facility;
 188
 189     for (module = strtok_r(s, ": \t", &save_ptr); module != NULL;
 190          module = strtok_r(NULL, ": \t", &save_ptr)) {
 191         enum vlog_module e_module;
 192         enum vlog_level e_level;
 193         enum vlog_facility e_facility;
 194
 195         facility = strtok_r(NULL, ":", &save_ptr);
 196         level = strtok_r(NULL, ":", &save_ptr);
 197         if (level == NULL || facility == NULL) {
 198             free(s);
 199             return xstrdup("syntax error in level string");
 200         }
 201
 202         if (!strcmp(module, "ANY")) {
 203             e_module = VLM_ANY_MODULE;
 204         } else {
 205             e_module = vlog_get_module_val(module);
 206             if (e_module >= VLM_N_MODULES) {
 207                 char *msg = xasprintf("unknown module \"%s\"", module);
 208                 free(s);
 209                 return msg;
 210             }
 211         }
 212
 213         if (!strcmp(facility, "ANY")) {
 214             e_facility = VLF_ANY_FACILITY;
 215         } else {
 216             e_facility = vlog_get_facility_val(facility);
 217             if (e_facility >= VLF_N_FACILITIES) {
 218                 char *msg = xasprintf("unknown facility \"%s\"", facility);
 219                 free(s);
 220                 return msg;
 221             }
 222         }
 223
 224         e_level = vlog_get_level_val(level);
 225         if (e_level >= VLL_N_LEVELS) {
 226             char *msg = xasprintf("unknown level \"%s\"", level);
 227             free(s);
 228             return msg;
 229         }
 230
 231         vlog_set_levels(e_module, e_facility, e_level);
 232     }
 233     free(s);
 234     return NULL;
 235 }
 236
 237 /* If 'arg' is null, configure maximum verbosity.  Otherwise, sets
 238  * configuration according to 'arg' (see vlog_set_levels_from_string()). */
 239 void
 240 vlog_set_verbosity(const char *arg)
 241 {
 242     if (arg) {
 243         char *msg = vlog_set_levels_from_string(arg);
 244         if (msg) {
 245             fatal(0, "processing \"%s\": %s", arg, msg);
 246         }
 247     } else {
 248         vlog_set_levels(VLM_ANY_MODULE, VLF_ANY_FACILITY, VLL_DBG);
 249     }
 250 }
 251
 252 /* Initializes the logging subsystem. */
 253 void
 254 vlog_init(void)
 255 {
 256     time_t now;
 257
 258     openlog(program_name, LOG_NDELAY, LOG_DAEMON);
 259     vlog_set_levels(VLM_ANY_MODULE, VLF_ANY_FACILITY, VLL_WARN);
 260
 261     now = time(0);
 262     if (now < 0) {
 263         struct tm tm;
 264         char s[128];
 265
 266         localtime_r(&now, &tm);
 267         strftime(s, sizeof s, "%a, %d %b %Y %H:%M:%S %z", &tm);
 268         VLOG_ERR("current time is negative: %s (%ld)", s, (long int) now);
 269     }
 270 }
 271
 272 /* Closes the logging subsystem. */
 273 void
 274 vlog_exit(void)
 275 {
 276     closelog();
 277 }
 278
 279 /* Print the current logging level for each module. */
 280 char *
 281 vlog_get_levels(void)
 282 {
 283     struct ds s = DS_EMPTY_INITIALIZER;
 284     enum vlog_module module;
 285
 286     ds_put_format(&s, "                 console    syslog\n");
 287     ds_put_format(&s, "                 -------    ------\n");
 288
 289     for (module = 0; module < VLM_N_MODULES; module++) {
 290         ds_put_format(&s, "%-16s  %4s       %4s\n",
 291            vlog_get_module_name(module),
 292            vlog_get_level_name(vlog_get_level(module, VLF_CONSOLE)),
 293            vlog_get_level_name(vlog_get_level(module, VLF_SYSLOG)));
 294     }
 295
 296     return ds_cstr(&s);
 297 }
 298
 299 /* Returns true if a log message emitted for the given 'module' and 'level'
 300  * would cause some log output, false if that module and level are completely
 301  * disabled. */
 302 bool
 303 vlog_is_enabled(enum vlog_module module, enum vlog_level level)
 304 {
 305     return (levels[module][VLF_CONSOLE] >= level
 306             || levels[module][VLF_SYSLOG] >= level);
 307 }
 308
 309 /* Writes 'message' to the log at the given 'level' and as coming from the
 310  * given 'module'.
 311  *
 312  * Guaranteed to preserve errno. */
 313 void
 314 vlog(enum vlog_module module, enum vlog_level level, const char *message, ...)
 315 {
 316     bool log_console = levels[module][VLF_CONSOLE] >= level;
 317     bool log_syslog = levels[module][VLF_SYSLOG] >= level;
 318     if (log_console || log_syslog) {
 319         int save_errno = errno;
 320         static int msg_num;
 321         const char *module_name = vlog_get_module_name(module);
 322         const char *level_name = vlog_get_level_name(level);
 323         time_t now;
 324         struct tm tm;
 325         va_list args;
 326         char s[1024];
 327         size_t len, time_len;
 328
 329         now = time(0);
 330         localtime_r(&now, &tm);
 331
 332         len = time_len = strftime(s, sizeof s, "%b %d %H:%M:%S|", &tm);
 333         len += sprintf(s + len, "%05d|%s|%s:",
 334                        ++msg_num, module_name, level_name);
 335         va_start(args, message);
 336         len += vsnprintf(s + len, sizeof s - len, message, args);
 337         va_end(args);
 338         if (len >= sizeof s) {
 339             len = sizeof s;
 340         }
 341         if (s[len - 1] == '\n') {
 342             s[len - 1] = '\0';
 343         }
 344
 345         if (log_console) {
 346             fprintf(stderr, "%s\n", s);
 347         }
 348
 349         if (log_syslog) {
 350             static const int syslog_levels[VLL_N_LEVELS] = {
 351                 [VLL_EMER] = LOG_EMERG,
 352                 [VLL_ERR] = LOG_ERR,
 353                 [VLL_WARN] = LOG_WARNING,
 354                 [VLL_DBG] = LOG_DEBUG,
 355             };
 356
 357             syslog(syslog_levels[level], "%s", s + time_len);
 358         }
 359         errno = save_errno;
 360     }
 361 }