cfm: Warn when delayed sending CCMs.
[openvswitch] / lib / vlog.c
1 /*
2  * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <config.h>
18 #include "vlog.h"
19 #include <assert.h>
20 #include <ctype.h>
21 #include <errno.h>
22 #include <stdarg.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <sys/stat.h>
26 #include <sys/types.h>
27 #include <syslog.h>
28 #include <time.h>
29 #include <unistd.h>
30 #include "dirs.h"
31 #include "dynamic-string.h"
32 #include "sat-math.h"
33 #include "svec.h"
34 #include "timeval.h"
35 #include "unixctl.h"
36 #include "util.h"
37
38 VLOG_DEFINE_THIS_MODULE(vlog);
39
40 /* Name for each logging level. */
41 static const char *level_names[VLL_N_LEVELS] = {
42 #define VLOG_LEVEL(NAME, SYSLOG_LEVEL) #NAME,
43     VLOG_LEVELS
44 #undef VLOG_LEVEL
45 };
46
47 /* Syslog value for each logging level. */
48 static int syslog_levels[VLL_N_LEVELS] = {
49 #define VLOG_LEVEL(NAME, SYSLOG_LEVEL) SYSLOG_LEVEL,
50     VLOG_LEVELS
51 #undef VLOG_LEVEL
52 };
53
54 /* The log modules. */
55 #if USE_LINKER_SECTIONS
56 extern struct vlog_module *__start_vlog_modules[];
57 extern struct vlog_module *__stop_vlog_modules[];
58 #define vlog_modules __start_vlog_modules
59 #define n_vlog_modules (__stop_vlog_modules - __start_vlog_modules)
60 #else
61 #define VLOG_MODULE VLOG_DEFINE_MODULE__
62 #include "vlog-modules.def"
63 #undef VLOG_MODULE
64
65 struct vlog_module *vlog_modules[] = {
66 #define VLOG_MODULE(NAME) &VLM_##NAME,
67 #include "vlog-modules.def"
68 #undef VLOG_MODULE
69 };
70 #define n_vlog_modules ARRAY_SIZE(vlog_modules)
71 #endif
72
73 /* Information about each facility. */
74 struct facility {
75     const char *name;           /* Name. */
76     char *pattern;              /* Current pattern. */
77     bool default_pattern;       /* Whether current pattern is the default. */
78 };
79 static struct facility facilities[VLF_N_FACILITIES] = {
80 #define VLOG_FACILITY(NAME, PATTERN) {#NAME, PATTERN, true},
81     VLOG_FACILITIES
82 #undef VLOG_FACILITY
83 };
84
85 /* VLF_FILE configuration. */
86 static char *log_file_name;
87 static FILE *log_file;
88
89 /* vlog initialized? */
90 static bool vlog_inited;
91
92 static void format_log_message(const struct vlog_module *, enum vlog_level,
93                                enum vlog_facility, unsigned int msg_num,
94                                const char *message, va_list, struct ds *)
95     PRINTF_FORMAT(5, 0);
96
97 /* Searches the 'n_names' in 'names'.  Returns the index of a match for
98  * 'target', or 'n_names' if no name matches. */
99 static size_t
100 search_name_array(const char *target, const char **names, size_t n_names)
101 {
102     size_t i;
103
104     for (i = 0; i < n_names; i++) {
105         assert(names[i]);
106         if (!strcasecmp(names[i], target)) {
107             break;
108         }
109     }
110     return i;
111 }
112
113 /* Returns the name for logging level 'level'. */
114 const char *
115 vlog_get_level_name(enum vlog_level level)
116 {
117     assert(level < VLL_N_LEVELS);
118     return level_names[level];
119 }
120
121 /* Returns the logging level with the given 'name', or VLL_N_LEVELS if 'name'
122  * is not the name of a logging level. */
123 enum vlog_level
124 vlog_get_level_val(const char *name)
125 {
126     return search_name_array(name, level_names, ARRAY_SIZE(level_names));
127 }
128
129 /* Returns the name for logging facility 'facility'. */
130 const char *
131 vlog_get_facility_name(enum vlog_facility facility)
132 {
133     assert(facility < VLF_N_FACILITIES);
134     return facilities[facility].name;
135 }
136
137 /* Returns the logging facility named 'name', or VLF_N_FACILITIES if 'name' is
138  * not the name of a logging facility. */
139 enum vlog_facility
140 vlog_get_facility_val(const char *name)
141 {
142     size_t i;
143
144     for (i = 0; i < VLF_N_FACILITIES; i++) {
145         if (!strcasecmp(facilities[i].name, name)) {
146             break;
147         }
148     }
149     return i;
150 }
151
152 /* Returns the name for logging module 'module'. */
153 const char *
154 vlog_get_module_name(const struct vlog_module *module)
155 {
156     return module->name;
157 }
158
159 /* Returns the logging module named 'name', or NULL if 'name' is not the name
160  * of a logging module. */
161 struct vlog_module *
162 vlog_module_from_name(const char *name)
163 {
164     struct vlog_module **mp;
165
166     for (mp = vlog_modules; mp < &vlog_modules[n_vlog_modules]; mp++) {
167         if (!strcasecmp(name, (*mp)->name)) {
168             return *mp;
169         }
170     }
171     return NULL;
172 }
173
174 /* Returns the current logging level for the given 'module' and 'facility'. */
175 enum vlog_level
176 vlog_get_level(const struct vlog_module *module, enum vlog_facility facility)
177 {
178     assert(facility < VLF_N_FACILITIES);
179     return module->levels[facility];
180 }
181
182 static void
183 update_min_level(struct vlog_module *module)
184 {
185     enum vlog_facility facility;
186
187     module->min_level = VLL_OFF;
188     for (facility = 0; facility < VLF_N_FACILITIES; facility++) {
189         if (log_file || facility != VLF_FILE) {
190             enum vlog_level level = module->levels[facility];
191             if (level > module->min_level) {
192                 module->min_level = level;
193             }
194         }
195     }
196 }
197
198 static void
199 set_facility_level(enum vlog_facility facility, struct vlog_module *module,
200                    enum vlog_level level)
201 {
202     assert(facility >= 0 && facility < VLF_N_FACILITIES);
203     assert(level < VLL_N_LEVELS);
204
205     if (!module) {
206         struct vlog_module **mp;
207
208         for (mp = vlog_modules; mp < &vlog_modules[n_vlog_modules]; mp++) {
209             (*mp)->levels[facility] = level;
210             update_min_level(*mp);
211         }
212     } else {
213         module->levels[facility] = level;
214         update_min_level(module);
215     }
216 }
217
218 /* Sets the logging level for the given 'module' and 'facility' to 'level'.  A
219  * null 'module' or a 'facility' of VLF_ANY_FACILITY is treated as a wildcard
220  * across all modules or facilities, respectively. */
221 void
222 vlog_set_levels(struct vlog_module *module, enum vlog_facility facility,
223                 enum vlog_level level)
224 {
225     assert(facility < VLF_N_FACILITIES || facility == VLF_ANY_FACILITY);
226     if (facility == VLF_ANY_FACILITY) {
227         for (facility = 0; facility < VLF_N_FACILITIES; facility++) {
228             set_facility_level(facility, module, level);
229         }
230     } else {
231         set_facility_level(facility, module, level);
232     }
233 }
234
235 static void
236 do_set_pattern(enum vlog_facility facility, const char *pattern)
237 {
238     struct facility *f = &facilities[facility];
239     if (!f->default_pattern) {
240         free(f->pattern);
241     } else {
242         f->default_pattern = false;
243     }
244     f->pattern = xstrdup(pattern);
245 }
246
247 /* Sets the pattern for the given 'facility' to 'pattern'. */
248 void
249 vlog_set_pattern(enum vlog_facility facility, const char *pattern)
250 {
251     assert(facility < VLF_N_FACILITIES || facility == VLF_ANY_FACILITY);
252     if (facility == VLF_ANY_FACILITY) {
253         for (facility = 0; facility < VLF_N_FACILITIES; facility++) {
254             do_set_pattern(facility, pattern);
255         }
256     } else {
257         do_set_pattern(facility, pattern);
258     }
259 }
260
261 /* Returns the name of the log file used by VLF_FILE, or a null pointer if no
262  * log file has been set.  (A non-null return value does not assert that the
263  * named log file is in use: if vlog_set_log_file() or vlog_reopen_log_file()
264  * fails, it still sets the log file name.) */
265 const char *
266 vlog_get_log_file(void)
267 {
268     return log_file_name;
269 }
270
271 /* Sets the name of the log file used by VLF_FILE to 'file_name', or to the
272  * default file name if 'file_name' is null.  Returns 0 if successful,
273  * otherwise a positive errno value. */
274 int
275 vlog_set_log_file(const char *file_name)
276 {
277     char *old_log_file_name;
278     struct vlog_module **mp;
279     int error;
280
281     /* Close old log file. */
282     if (log_file) {
283         VLOG_INFO("closing log file");
284         fclose(log_file);
285         log_file = NULL;
286     }
287
288     /* Update log file name and free old name.  The ordering is important
289      * because 'file_name' might be 'log_file_name' or some suffix of it. */
290     old_log_file_name = log_file_name;
291     log_file_name = (file_name
292                      ? xstrdup(file_name)
293                      : xasprintf("%s/%s.log", ovs_logdir(), program_name));
294     free(old_log_file_name);
295     file_name = NULL;           /* Might have been freed. */
296
297     /* Open new log file and update min_levels[] to reflect whether we actually
298      * have a log_file. */
299     log_file = fopen(log_file_name, "a");
300     for (mp = vlog_modules; mp < &vlog_modules[n_vlog_modules]; mp++) {
301         update_min_level(*mp);
302     }
303
304     /* Log success or failure. */
305     if (!log_file) {
306         VLOG_WARN("failed to open %s for logging: %s",
307                   log_file_name, strerror(errno));
308         error = errno;
309     } else {
310         VLOG_INFO("opened log file %s", log_file_name);
311         error = 0;
312     }
313
314     return error;
315 }
316
317 /* Closes and then attempts to re-open the current log file.  (This is useful
318  * just after log rotation, to ensure that the new log file starts being used.)
319  * Returns 0 if successful, otherwise a positive errno value. */
320 int
321 vlog_reopen_log_file(void)
322 {
323     struct stat old, new;
324
325     /* Skip re-opening if there's nothing to reopen. */
326     if (!log_file_name) {
327         return 0;
328     }
329
330     /* Skip re-opening if it would be a no-op because the old and new files are
331      * the same.  (This avoids writing "closing log file" followed immediately
332      * by "opened log file".) */
333     if (log_file
334         && !fstat(fileno(log_file), &old)
335         && !stat(log_file_name, &new)
336         && old.st_dev == new.st_dev
337         && old.st_ino == new.st_ino) {
338         return 0;
339     }
340
341     return vlog_set_log_file(log_file_name);
342 }
343
344 /* Set debugging levels.  Returns null if successful, otherwise an error
345  * message that the caller must free(). */
346 char *
347 vlog_set_levels_from_string(const char *s_)
348 {
349     char *s = xstrdup(s_);
350     char *save_ptr = NULL;
351     char *msg = NULL;
352     char *word;
353
354     word = strtok_r(s, " ,:\t", &save_ptr);
355     if (word && !strcasecmp(word, "PATTERN")) {
356         enum vlog_facility facility;
357
358         word = strtok_r(NULL, " ,:\t", &save_ptr);
359         if (!word) {
360             msg = xstrdup("missing facility");
361             goto exit;
362         }
363
364         facility = (!strcasecmp(word, "ANY")
365                     ? VLF_ANY_FACILITY
366                     : vlog_get_facility_val(word));
367         if (facility == VLF_N_FACILITIES) {
368             msg = xasprintf("unknown facility \"%s\"", word);
369             goto exit;
370         }
371         vlog_set_pattern(facility, save_ptr);
372     } else {
373         struct vlog_module *module = NULL;
374         enum vlog_level level = VLL_N_LEVELS;
375         enum vlog_facility facility = VLF_N_FACILITIES;
376
377         for (; word != NULL; word = strtok_r(NULL, " ,:\t", &save_ptr)) {
378             if (!strcasecmp(word, "ANY")) {
379                 continue;
380             } else if (vlog_get_facility_val(word) != VLF_N_FACILITIES) {
381                 if (facility != VLF_N_FACILITIES) {
382                     msg = xstrdup("cannot specify multiple facilities");
383                     goto exit;
384                 }
385                 facility = vlog_get_facility_val(word);
386             } else if (vlog_get_level_val(word) != VLL_N_LEVELS) {
387                 if (level != VLL_N_LEVELS) {
388                     msg = xstrdup("cannot specify multiple levels");
389                     goto exit;
390                 }
391                 level = vlog_get_level_val(word);
392             } else if (vlog_module_from_name(word)) {
393                 if (module) {
394                     msg = xstrdup("cannot specify multiple modules");
395                     goto exit;
396                 }
397                 module = vlog_module_from_name(word);
398             } else {
399                 msg = xasprintf("no facility, level, or module \"%s\"", word);
400                 goto exit;
401             }
402         }
403
404         if (facility == VLF_N_FACILITIES) {
405             facility = VLF_ANY_FACILITY;
406         }
407         if (level == VLL_N_LEVELS) {
408             level = VLL_DBG;
409         }
410         vlog_set_levels(module, facility, level);
411     }
412
413 exit:
414     free(s);
415     return msg;
416 }
417
418 /* If 'arg' is null, configure maximum verbosity.  Otherwise, sets
419  * configuration according to 'arg' (see vlog_set_levels_from_string()). */
420 void
421 vlog_set_verbosity(const char *arg)
422 {
423     if (arg) {
424         char *msg = vlog_set_levels_from_string(arg);
425         if (msg) {
426             ovs_fatal(0, "processing \"%s\": %s", arg, msg);
427         }
428     } else {
429         vlog_set_levels(NULL, VLF_ANY_FACILITY, VLL_DBG);
430     }
431 }
432
433 static void
434 vlog_unixctl_set(struct unixctl_conn *conn, int argc, const char *argv[],
435                  void *aux OVS_UNUSED)
436 {
437     int i;
438
439     for (i = 1; i < argc; i++) {
440         char *msg = vlog_set_levels_from_string(argv[i]);
441         if (msg) {
442             unixctl_command_reply_error(conn, msg);
443             free(msg);
444             return;
445         }
446     }
447     unixctl_command_reply(conn, NULL);
448 }
449
450 static void
451 vlog_unixctl_list(struct unixctl_conn *conn, int argc OVS_UNUSED,
452                   const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
453 {
454     char *msg = vlog_get_levels();
455     unixctl_command_reply(conn, msg);
456     free(msg);
457 }
458
459 static void
460 vlog_unixctl_reopen(struct unixctl_conn *conn, int argc OVS_UNUSED,
461                     const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
462 {
463     if (log_file_name) {
464         int error = vlog_reopen_log_file();
465         if (error) {
466             unixctl_command_reply_error(conn, strerror(errno));
467         } else {
468             unixctl_command_reply(conn, NULL);
469         }
470     } else {
471         unixctl_command_reply_error(conn, "Logging to file not configured");
472     }
473 }
474
475 /* Initializes the logging subsystem and registers its unixctl server
476  * commands. */
477 void
478 vlog_init(void)
479 {
480     static char *program_name_copy;
481     time_t now;
482
483     if (vlog_inited) {
484         return;
485     }
486     vlog_inited = true;
487
488     /* openlog() is allowed to keep the pointer passed in, without making a
489      * copy.  The daemonize code sometimes frees and replaces 'program_name',
490      * so make a private copy just for openlog().  (We keep a pointer to the
491      * private copy to suppress memory leak warnings in case openlog() does
492      * make its own copy.) */
493     program_name_copy = program_name ? xstrdup(program_name) : NULL;
494     openlog(program_name_copy, LOG_NDELAY, LOG_DAEMON);
495
496     now = time_wall();
497     if (now < 0) {
498         struct tm tm;
499         char s[128];
500
501         localtime_r(&now, &tm);
502         strftime(s, sizeof s, "%a, %d %b %Y %H:%M:%S %z", &tm);
503         VLOG_ERR("current time is negative: %s (%ld)", s, (long int) now);
504     }
505
506     unixctl_command_register(
507         "vlog/set", "{spec | PATTERN:facility:pattern}",
508         1, INT_MAX, vlog_unixctl_set, NULL);
509     unixctl_command_register("vlog/list", "", 0, 0, vlog_unixctl_list, NULL);
510     unixctl_command_register("vlog/reopen", "", 0, 0,
511                              vlog_unixctl_reopen, NULL);
512 }
513
514 /* Closes the logging subsystem. */
515 void
516 vlog_exit(void)
517 {
518     if (vlog_inited) {
519         closelog();
520         vlog_inited = false;
521     }
522 }
523
524 /* Print the current logging level for each module. */
525 char *
526 vlog_get_levels(void)
527 {
528     struct ds s = DS_EMPTY_INITIALIZER;
529     struct vlog_module **mp;
530     struct svec lines = SVEC_EMPTY_INITIALIZER;
531     char *line;
532     size_t i;
533
534     ds_put_format(&s, "                 console    syslog    file\n");
535     ds_put_format(&s, "                 -------    ------    ------\n");
536
537     for (mp = vlog_modules; mp < &vlog_modules[n_vlog_modules]; mp++) {
538         line = xasprintf("%-16s  %4s       %4s       %4s\n",
539            vlog_get_module_name(*mp),
540            vlog_get_level_name(vlog_get_level(*mp, VLF_CONSOLE)),
541            vlog_get_level_name(vlog_get_level(*mp, VLF_SYSLOG)),
542            vlog_get_level_name(vlog_get_level(*mp, VLF_FILE)));
543         svec_add_nocopy(&lines, line);
544     }
545
546     svec_sort(&lines);
547     SVEC_FOR_EACH (i, line, &lines) {
548         ds_put_cstr(&s, line);
549     }
550     svec_destroy(&lines);
551
552     return ds_cstr(&s);
553 }
554
555 /* Returns true if a log message emitted for the given 'module' and 'level'
556  * would cause some log output, false if that module and level are completely
557  * disabled. */
558 bool
559 vlog_is_enabled(const struct vlog_module *module, enum vlog_level level)
560 {
561     return module->min_level >= level;
562 }
563
564 static const char *
565 fetch_braces(const char *p, const char *def, char *out, size_t out_size)
566 {
567     if (*p == '{') {
568         size_t n = strcspn(p + 1, "}");
569         size_t n_copy = MIN(n, out_size - 1);
570         memcpy(out, p + 1, n_copy);
571         out[n_copy] = '\0';
572         p += n + 2;
573     } else {
574         ovs_strlcpy(out, def, out_size);
575     }
576     return p;
577 }
578
579 static void
580 format_log_message(const struct vlog_module *module, enum vlog_level level,
581                    enum vlog_facility facility, unsigned int msg_num,
582                    const char *message, va_list args_, struct ds *s)
583 {
584     char tmp[128];
585     va_list args;
586     const char *p;
587
588     ds_clear(s);
589     for (p = facilities[facility].pattern; *p != '\0'; ) {
590         enum { LEFT, RIGHT } justify = RIGHT;
591         int pad = '0';
592         size_t length, field, used;
593
594         if (*p != '%') {
595             ds_put_char(s, *p++);
596             continue;
597         }
598
599         p++;
600         if (*p == '-') {
601             justify = LEFT;
602             p++;
603         }
604         if (*p == '0') {
605             pad = '0';
606             p++;
607         }
608         field = 0;
609         while (isdigit((unsigned char)*p)) {
610             field = (field * 10) + (*p - '0');
611             p++;
612         }
613
614         length = s->length;
615         switch (*p++) {
616         case 'A':
617             ds_put_cstr(s, program_name);
618             break;
619         case 'c':
620             p = fetch_braces(p, "", tmp, sizeof tmp);
621             ds_put_cstr(s, vlog_get_module_name(module));
622             break;
623         case 'd':
624             p = fetch_braces(p, "%Y-%m-%d %H:%M:%S", tmp, sizeof tmp);
625             ds_put_strftime(s, tmp, false);
626             break;
627         case 'D':
628             p = fetch_braces(p, "%Y-%m-%d %H:%M:%S", tmp, sizeof tmp);
629             ds_put_strftime(s, tmp, true);
630             break;
631         case 'm':
632             /* Format user-supplied log message and trim trailing new-lines. */
633             length = s->length;
634             va_copy(args, args_);
635             ds_put_format_valist(s, message, args);
636             va_end(args);
637             while (s->length > length && s->string[s->length - 1] == '\n') {
638                 s->length--;
639             }
640             break;
641         case 'N':
642             ds_put_format(s, "%u", msg_num);
643             break;
644         case 'n':
645             ds_put_char(s, '\n');
646             break;
647         case 'p':
648             ds_put_cstr(s, vlog_get_level_name(level));
649             break;
650         case 'P':
651             ds_put_format(s, "%ld", (long int) getpid());
652             break;
653         case 'r':
654             ds_put_format(s, "%lld", time_msec() - time_boot_msec());
655             break;
656         default:
657             ds_put_char(s, p[-1]);
658             break;
659         }
660         used = s->length - length;
661         if (used < field) {
662             size_t n_pad = field - used;
663             if (justify == RIGHT) {
664                 ds_put_uninit(s, n_pad);
665                 memmove(&s->string[length + n_pad], &s->string[length], used);
666                 memset(&s->string[length], pad, n_pad);
667             } else {
668                 ds_put_char_multiple(s, pad, n_pad);
669             }
670         }
671     }
672 }
673
674 /* Writes 'message' to the log at the given 'level' and as coming from the
675  * given 'module'.
676  *
677  * Guaranteed to preserve errno. */
678 void
679 vlog_valist(const struct vlog_module *module, enum vlog_level level,
680             const char *message, va_list args)
681 {
682     bool log_to_console = module->levels[VLF_CONSOLE] >= level;
683     bool log_to_syslog = module->levels[VLF_SYSLOG] >= level;
684     bool log_to_file = module->levels[VLF_FILE] >= level && log_file;
685     if (log_to_console || log_to_syslog || log_to_file) {
686         int save_errno = errno;
687         static unsigned int msg_num;
688         struct ds s;
689
690         vlog_init();
691
692         ds_init(&s);
693         ds_reserve(&s, 1024);
694         msg_num++;
695
696         if (log_to_console) {
697             format_log_message(module, level, VLF_CONSOLE, msg_num,
698                                message, args, &s);
699             ds_put_char(&s, '\n');
700             fputs(ds_cstr(&s), stderr);
701         }
702
703         if (log_to_syslog) {
704             int syslog_level = syslog_levels[level];
705             char *save_ptr = NULL;
706             char *line;
707
708             format_log_message(module, level, VLF_SYSLOG, msg_num,
709                                message, args, &s);
710             for (line = strtok_r(s.string, "\n", &save_ptr); line;
711                  line = strtok_r(NULL, "\n", &save_ptr)) {
712                 syslog(syslog_level, "%s", line);
713             }
714         }
715
716         if (log_to_file) {
717             format_log_message(module, level, VLF_FILE, msg_num,
718                                message, args, &s);
719             ds_put_char(&s, '\n');
720             fputs(ds_cstr(&s), log_file);
721             fflush(log_file);
722         }
723
724         ds_destroy(&s);
725         errno = save_errno;
726     }
727 }
728
729 void
730 vlog(const struct vlog_module *module, enum vlog_level level,
731      const char *message, ...)
732 {
733     va_list args;
734
735     va_start(args, message);
736     vlog_valist(module, level, message, args);
737     va_end(args);
738 }
739
740 void
741 vlog_fatal_valist(const struct vlog_module *module_,
742                   const char *message, va_list args)
743 {
744     struct vlog_module *module = (struct vlog_module *) module_;
745
746     /* Don't log this message to the console to avoid redundancy with the
747      * message written by the later ovs_fatal_valist(). */
748     module->levels[VLF_CONSOLE] = VLL_OFF;
749
750     vlog_valist(module, VLL_EMER, message, args);
751     ovs_fatal_valist(0, message, args);
752 }
753
754 void
755 vlog_fatal(const struct vlog_module *module, const char *message, ...)
756 {
757     va_list args;
758
759     va_start(args, message);
760     vlog_fatal_valist(module, message, args);
761     va_end(args);
762 }
763
764 bool
765 vlog_should_drop(const struct vlog_module *module, enum vlog_level level,
766                  struct vlog_rate_limit *rl)
767 {
768     if (!vlog_is_enabled(module, level)) {
769         return true;
770     }
771
772     if (rl->tokens < VLOG_MSG_TOKENS) {
773         time_t now = time_now();
774         if (rl->last_fill > now) {
775             /* Last filled in the future?  Time must have gone backward, or
776              * 'rl' has not been used before. */
777             rl->tokens = rl->burst;
778         } else if (rl->last_fill < now) {
779             unsigned int add = sat_mul(rl->rate, now - rl->last_fill);
780             unsigned int tokens = sat_add(rl->tokens, add);
781             rl->tokens = MIN(tokens, rl->burst);
782             rl->last_fill = now;
783         }
784         if (rl->tokens < VLOG_MSG_TOKENS) {
785             if (!rl->n_dropped) {
786                 rl->first_dropped = now;
787             }
788             rl->last_dropped = now;
789             rl->n_dropped++;
790             return true;
791         }
792     }
793     rl->tokens -= VLOG_MSG_TOKENS;
794
795     if (rl->n_dropped) {
796         time_t now = time_now();
797         unsigned int first_dropped_elapsed = now - rl->first_dropped;
798         unsigned int last_dropped_elapsed = now - rl->last_dropped;
799
800         vlog(module, level,
801              "Dropped %u log messages in last %u seconds (most recently, "
802              "%u seconds ago) due to excessive rate",
803              rl->n_dropped, first_dropped_elapsed, last_dropped_elapsed);
804
805         rl->n_dropped = 0;
806     }
807     return false;
808 }
809
810 void
811 vlog_rate_limit(const struct vlog_module *module, enum vlog_level level,
812                 struct vlog_rate_limit *rl, const char *message, ...)
813 {
814     if (!vlog_should_drop(module, level, rl)) {
815         va_list args;
816
817         va_start(args, message);
818         vlog_valist(module, level, message, args);
819         va_end(args);
820     }
821 }
822
823 void
824 vlog_usage(void)
825 {
826     printf("\nLogging options:\n"
827            "  -v, --verbose=[SPEC]    set logging levels\n"
828            "  -v, --verbose           set maximum verbosity level\n"
829            "  --log-file[=FILE]       enable logging to specified FILE\n"
830            "                          (default: %s/%s.log)\n",
831            ovs_logdir(), program_name);
832 }