Deleted Added
sdiff udiff text old ( 218132 ) new ( 219369 )
full compact
pjdlog.c (218132) pjdlog.c (219369)
1/*-
2 * Copyright (c) 2009-2010 The FreeBSD Foundation
3 * Copyright (c) 2011 Pawel Jakub Dawidek <pjd@FreeBSD.org>
4 * All rights reserved.
5 *
6 * This software was developed by Pawel Jakub Dawidek under sponsorship from
7 * the FreeBSD Foundation.
8 *

--- 15 unchanged lines hidden (view full) ---

24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31#include <sys/cdefs.h>
1/*-
2 * Copyright (c) 2009-2010 The FreeBSD Foundation
3 * Copyright (c) 2011 Pawel Jakub Dawidek <pjd@FreeBSD.org>
4 * All rights reserved.
5 *
6 * This software was developed by Pawel Jakub Dawidek under sponsorship from
7 * the FreeBSD Foundation.
8 *

--- 15 unchanged lines hidden (view full) ---

24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31#include <sys/cdefs.h>
32__FBSDID("$FreeBSD: head/sbin/hastd/pjdlog.c 218132 2011-01-31 15:52:00Z pjd $");
32__FBSDID("$FreeBSD: head/sbin/hastd/pjdlog.c 219369 2011-03-07 10:33:52Z pjd $");
33
34#include <assert.h>
35#include <errno.h>
36#include <stdarg.h>
33
34#include <assert.h>
35#include <errno.h>
36#include <stdarg.h>
37#include <stdbool.h>
38#include <stdio.h>
39#include <stdlib.h>
40#include <string.h>
41#include <syslog.h>
42
43#include "pjdlog.h"
44
37#include <stdio.h>
38#include <stdlib.h>
39#include <string.h>
40#include <syslog.h>
41
42#include "pjdlog.h"
43
45static bool pjdlog_initialized = false;
44#define PJDLOG_NEVER_INITIALIZED 0
45#define PJDLOG_NOT_INITIALIZED 1
46#define PJDLOG_INITIALIZED 2
47
48static int pjdlog_initialized = PJDLOG_NEVER_INITIALIZED;
46static int pjdlog_mode, pjdlog_debug_level;
47static char pjdlog_prefix[128];
48
49void
50pjdlog_init(int mode)
51{
52
49static int pjdlog_mode, pjdlog_debug_level;
50static char pjdlog_prefix[128];
51
52void
53pjdlog_init(int mode)
54{
55
53 assert(!pjdlog_initialized);
56 assert(pjdlog_initialized == PJDLOG_NEVER_INITIALIZED ||
57 pjdlog_initialized == PJDLOG_NOT_INITIALIZED);
54 assert(mode == PJDLOG_MODE_STD || mode == PJDLOG_MODE_SYSLOG);
55
56 if (mode == PJDLOG_MODE_SYSLOG)
57 openlog(NULL, LOG_PID | LOG_NDELAY, LOG_DAEMON);
58 pjdlog_mode = mode;
59 pjdlog_debug_level = 0;
60 bzero(pjdlog_prefix, sizeof(pjdlog_prefix));
61
58 assert(mode == PJDLOG_MODE_STD || mode == PJDLOG_MODE_SYSLOG);
59
60 if (mode == PJDLOG_MODE_SYSLOG)
61 openlog(NULL, LOG_PID | LOG_NDELAY, LOG_DAEMON);
62 pjdlog_mode = mode;
63 pjdlog_debug_level = 0;
64 bzero(pjdlog_prefix, sizeof(pjdlog_prefix));
65
62 pjdlog_initialized = true;
66 pjdlog_initialized = PJDLOG_INITIALIZED;
63}
64
65void
66pjdlog_fini(void)
67{
68
67}
68
69void
70pjdlog_fini(void)
71{
72
69 assert(pjdlog_initialized);
73 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
70
71 if (pjdlog_mode == PJDLOG_MODE_SYSLOG)
72 closelog();
73
74
75 if (pjdlog_mode == PJDLOG_MODE_SYSLOG)
76 closelog();
77
74 pjdlog_initialized = false;
78 pjdlog_initialized = PJDLOG_NOT_INITIALIZED;
75}
76
77/*
78 * Configure where the logs should go.
79 * By default they are send to stdout/stderr, but after going into background
80 * (eg. by calling daemon(3)) application is responsible for changing mode to
81 * PJDLOG_MODE_SYSLOG, so logs will be send to syslog.
82 */
83void
84pjdlog_mode_set(int mode)
85{
86
79}
80
81/*
82 * Configure where the logs should go.
83 * By default they are send to stdout/stderr, but after going into background
84 * (eg. by calling daemon(3)) application is responsible for changing mode to
85 * PJDLOG_MODE_SYSLOG, so logs will be send to syslog.
86 */
87void
88pjdlog_mode_set(int mode)
89{
90
87 assert(pjdlog_initialized);
91 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
88 assert(mode == PJDLOG_MODE_STD || mode == PJDLOG_MODE_SYSLOG);
89
90 if (pjdlog_mode == mode)
91 return;
92
93 if (mode == PJDLOG_MODE_SYSLOG)
94 openlog(NULL, LOG_PID | LOG_NDELAY, LOG_DAEMON);
95 else /* if (mode == PJDLOG_MODE_STD) */

--- 4 unchanged lines hidden (view full) ---

100
101/*
102 * Return current mode.
103 */
104int
105pjdlog_mode_get(void)
106{
107
92 assert(mode == PJDLOG_MODE_STD || mode == PJDLOG_MODE_SYSLOG);
93
94 if (pjdlog_mode == mode)
95 return;
96
97 if (mode == PJDLOG_MODE_SYSLOG)
98 openlog(NULL, LOG_PID | LOG_NDELAY, LOG_DAEMON);
99 else /* if (mode == PJDLOG_MODE_STD) */

--- 4 unchanged lines hidden (view full) ---

104
105/*
106 * Return current mode.
107 */
108int
109pjdlog_mode_get(void)
110{
111
108 assert(pjdlog_initialized);
112 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
109
110 return (pjdlog_mode);
111}
112
113/*
114 * Set debug level. All the logs above the level specified here will be
115 * ignored.
116 */
117void
118pjdlog_debug_set(int level)
119{
120
113
114 return (pjdlog_mode);
115}
116
117/*
118 * Set debug level. All the logs above the level specified here will be
119 * ignored.
120 */
121void
122pjdlog_debug_set(int level)
123{
124
121 assert(pjdlog_initialized);
125 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
122 assert(level >= 0);
123
124 pjdlog_debug_level = level;
125}
126
127/*
128 * Return current debug level.
129 */
130int
131pjdlog_debug_get(void)
132{
133
126 assert(level >= 0);
127
128 pjdlog_debug_level = level;
129}
130
131/*
132 * Return current debug level.
133 */
134int
135pjdlog_debug_get(void)
136{
137
134 assert(pjdlog_initialized);
138 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
135
136 return (pjdlog_debug_level);
137}
138
139/*
140 * Set prefix that will be used before each log.
141 * Setting prefix to NULL will remove it.
142 */
143void
144pjdlog_prefix_set(const char *fmt, ...)
145{
146 va_list ap;
147
139
140 return (pjdlog_debug_level);
141}
142
143/*
144 * Set prefix that will be used before each log.
145 * Setting prefix to NULL will remove it.
146 */
147void
148pjdlog_prefix_set(const char *fmt, ...)
149{
150 va_list ap;
151
148 assert(pjdlog_initialized);
152 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
149
150 va_start(ap, fmt);
151 pjdlogv_prefix_set(fmt, ap);
152 va_end(ap);
153}
154
155/*
156 * Set prefix that will be used before each log.
157 * Setting prefix to NULL will remove it.
158 */
159void
160pjdlogv_prefix_set(const char *fmt, va_list ap)
161{
162
153
154 va_start(ap, fmt);
155 pjdlogv_prefix_set(fmt, ap);
156 va_end(ap);
157}
158
159/*
160 * Set prefix that will be used before each log.
161 * Setting prefix to NULL will remove it.
162 */
163void
164pjdlogv_prefix_set(const char *fmt, va_list ap)
165{
166
163 assert(pjdlog_initialized);
167 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
164 assert(fmt != NULL);
165
166 vsnprintf(pjdlog_prefix, sizeof(pjdlog_prefix), fmt, ap);
167}
168
169/*
170 * Convert log level into string.
171 */

--- 26 unchanged lines hidden (view full) ---

198/*
199 * Common log routine.
200 */
201void
202pjdlog_common(int loglevel, int debuglevel, int error, const char *fmt, ...)
203{
204 va_list ap;
205
168 assert(fmt != NULL);
169
170 vsnprintf(pjdlog_prefix, sizeof(pjdlog_prefix), fmt, ap);
171}
172
173/*
174 * Convert log level into string.
175 */

--- 26 unchanged lines hidden (view full) ---

202/*
203 * Common log routine.
204 */
205void
206pjdlog_common(int loglevel, int debuglevel, int error, const char *fmt, ...)
207{
208 va_list ap;
209
206 assert(pjdlog_initialized);
210 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
207
208 va_start(ap, fmt);
209 pjdlogv_common(loglevel, debuglevel, error, fmt, ap);
210 va_end(ap);
211}
212
213/*
214 * Common log routine, which can handle regular log level as well as debug
215 * level. We decide here where to send the logs (stdout/stderr or syslog).
216 */
217void
218pjdlogv_common(int loglevel, int debuglevel, int error, const char *fmt,
219 va_list ap)
220{
221
211
212 va_start(ap, fmt);
213 pjdlogv_common(loglevel, debuglevel, error, fmt, ap);
214 va_end(ap);
215}
216
217/*
218 * Common log routine, which can handle regular log level as well as debug
219 * level. We decide here where to send the logs (stdout/stderr or syslog).
220 */
221void
222pjdlogv_common(int loglevel, int debuglevel, int error, const char *fmt,
223 va_list ap)
224{
225
222 assert(pjdlog_initialized);
226 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
223 assert(loglevel == LOG_EMERG || loglevel == LOG_ALERT ||
224 loglevel == LOG_CRIT || loglevel == LOG_ERR ||
225 loglevel == LOG_WARNING || loglevel == LOG_NOTICE ||
226 loglevel == LOG_INFO || loglevel == LOG_DEBUG);
227 assert(loglevel != LOG_DEBUG || debuglevel > 0);
228 assert(error >= -1);
229
230 /* Ignore debug above configured level. */

--- 60 unchanged lines hidden (view full) ---

291
292/*
293 * Regular logs.
294 */
295void
296pjdlogv(int loglevel, const char *fmt, va_list ap)
297{
298
227 assert(loglevel == LOG_EMERG || loglevel == LOG_ALERT ||
228 loglevel == LOG_CRIT || loglevel == LOG_ERR ||
229 loglevel == LOG_WARNING || loglevel == LOG_NOTICE ||
230 loglevel == LOG_INFO || loglevel == LOG_DEBUG);
231 assert(loglevel != LOG_DEBUG || debuglevel > 0);
232 assert(error >= -1);
233
234 /* Ignore debug above configured level. */

--- 60 unchanged lines hidden (view full) ---

295
296/*
297 * Regular logs.
298 */
299void
300pjdlogv(int loglevel, const char *fmt, va_list ap)
301{
302
299 assert(pjdlog_initialized);
303 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
300
301 /* LOG_DEBUG is invalid here, pjdlogv?_debug() should be used. */
302 assert(loglevel == LOG_EMERG || loglevel == LOG_ALERT ||
303 loglevel == LOG_CRIT || loglevel == LOG_ERR ||
304 loglevel == LOG_WARNING || loglevel == LOG_NOTICE ||
305 loglevel == LOG_INFO);
306
307 pjdlogv_common(loglevel, 0, -1, fmt, ap);
308}
309
310/*
311 * Regular logs.
312 */
313void
314pjdlog(int loglevel, const char *fmt, ...)
315{
316 va_list ap;
317
304
305 /* LOG_DEBUG is invalid here, pjdlogv?_debug() should be used. */
306 assert(loglevel == LOG_EMERG || loglevel == LOG_ALERT ||
307 loglevel == LOG_CRIT || loglevel == LOG_ERR ||
308 loglevel == LOG_WARNING || loglevel == LOG_NOTICE ||
309 loglevel == LOG_INFO);
310
311 pjdlogv_common(loglevel, 0, -1, fmt, ap);
312}
313
314/*
315 * Regular logs.
316 */
317void
318pjdlog(int loglevel, const char *fmt, ...)
319{
320 va_list ap;
321
318 assert(pjdlog_initialized);
322 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
319
320 va_start(ap, fmt);
321 pjdlogv(loglevel, fmt, ap);
322 va_end(ap);
323}
324
325/*
326 * Debug logs.
327 */
328void
329pjdlogv_debug(int debuglevel, const char *fmt, va_list ap)
330{
331
323
324 va_start(ap, fmt);
325 pjdlogv(loglevel, fmt, ap);
326 va_end(ap);
327}
328
329/*
330 * Debug logs.
331 */
332void
333pjdlogv_debug(int debuglevel, const char *fmt, va_list ap)
334{
335
332 assert(pjdlog_initialized);
336 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
333
334 pjdlogv_common(LOG_DEBUG, debuglevel, -1, fmt, ap);
335}
336
337/*
338 * Debug logs.
339 */
340void
341pjdlog_debug(int debuglevel, const char *fmt, ...)
342{
343 va_list ap;
344
337
338 pjdlogv_common(LOG_DEBUG, debuglevel, -1, fmt, ap);
339}
340
341/*
342 * Debug logs.
343 */
344void
345pjdlog_debug(int debuglevel, const char *fmt, ...)
346{
347 va_list ap;
348
345 assert(pjdlog_initialized);
349 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
346
347 va_start(ap, fmt);
348 pjdlogv_debug(debuglevel, fmt, ap);
349 va_end(ap);
350}
351
352/*
353 * Error logs with errno logging.
354 */
355void
356pjdlogv_errno(int loglevel, const char *fmt, va_list ap)
357{
358
350
351 va_start(ap, fmt);
352 pjdlogv_debug(debuglevel, fmt, ap);
353 va_end(ap);
354}
355
356/*
357 * Error logs with errno logging.
358 */
359void
360pjdlogv_errno(int loglevel, const char *fmt, va_list ap)
361{
362
359 assert(pjdlog_initialized);
363 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
360
361 pjdlogv_common(loglevel, 0, errno, fmt, ap);
362}
363
364/*
365 * Error logs with errno logging.
366 */
367void
368pjdlog_errno(int loglevel, const char *fmt, ...)
369{
370 va_list ap;
371
364
365 pjdlogv_common(loglevel, 0, errno, fmt, ap);
366}
367
368/*
369 * Error logs with errno logging.
370 */
371void
372pjdlog_errno(int loglevel, const char *fmt, ...)
373{
374 va_list ap;
375
372 assert(pjdlog_initialized);
376 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
373
374 va_start(ap, fmt);
375 pjdlogv_errno(loglevel, fmt, ap);
376 va_end(ap);
377}
378
379/*
380 * Log error, errno and exit.
381 */
382void
383pjdlogv_exit(int exitcode, const char *fmt, va_list ap)
384{
385
377
378 va_start(ap, fmt);
379 pjdlogv_errno(loglevel, fmt, ap);
380 va_end(ap);
381}
382
383/*
384 * Log error, errno and exit.
385 */
386void
387pjdlogv_exit(int exitcode, const char *fmt, va_list ap)
388{
389
386 assert(pjdlog_initialized);
390 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
387
388 pjdlogv_errno(LOG_ERR, fmt, ap);
389 exit(exitcode);
390 /* NOTREACHED */
391}
392
393/*
394 * Log error, errno and exit.
395 */
396void
397pjdlog_exit(int exitcode, const char *fmt, ...)
398{
399 va_list ap;
400
391
392 pjdlogv_errno(LOG_ERR, fmt, ap);
393 exit(exitcode);
394 /* NOTREACHED */
395}
396
397/*
398 * Log error, errno and exit.
399 */
400void
401pjdlog_exit(int exitcode, const char *fmt, ...)
402{
403 va_list ap;
404
401 assert(pjdlog_initialized);
405 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
402
403 va_start(ap, fmt);
404 pjdlogv_exit(exitcode, fmt, ap);
405 /* NOTREACHED */
406 va_end(ap);
407}
408
409/*
410 * Log error and exit.
411 */
412void
413pjdlogv_exitx(int exitcode, const char *fmt, va_list ap)
414{
415
406
407 va_start(ap, fmt);
408 pjdlogv_exit(exitcode, fmt, ap);
409 /* NOTREACHED */
410 va_end(ap);
411}
412
413/*
414 * Log error and exit.
415 */
416void
417pjdlogv_exitx(int exitcode, const char *fmt, va_list ap)
418{
419
416 assert(pjdlog_initialized);
420 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
417
418 pjdlogv(LOG_ERR, fmt, ap);
419 exit(exitcode);
420 /* NOTREACHED */
421}
422
423/*
424 * Log error and exit.
425 */
426void
427pjdlog_exitx(int exitcode, const char *fmt, ...)
428{
429 va_list ap;
430
421
422 pjdlogv(LOG_ERR, fmt, ap);
423 exit(exitcode);
424 /* NOTREACHED */
425}
426
427/*
428 * Log error and exit.
429 */
430void
431pjdlog_exitx(int exitcode, const char *fmt, ...)
432{
433 va_list ap;
434
431 assert(pjdlog_initialized);
435 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
432
433 va_start(ap, fmt);
434 pjdlogv_exitx(exitcode, fmt, ap);
435 /* NOTREACHED */
436 va_end(ap);
437}
438
439/*
440 * Log failure message and exit.
441 */
442void
443pjdlog_abort(const char *func, const char *file, int line,
444 const char *failedexpr, const char *fmt, ...)
445{
446 va_list ap;
447
436
437 va_start(ap, fmt);
438 pjdlogv_exitx(exitcode, fmt, ap);
439 /* NOTREACHED */
440 va_end(ap);
441}
442
443/*
444 * Log failure message and exit.
445 */
446void
447pjdlog_abort(const char *func, const char *file, int line,
448 const char *failedexpr, const char *fmt, ...)
449{
450 va_list ap;
451
448 assert(pjdlog_initialized);
452 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
449
450 /*
451 * When there is no message we pass __func__ as 'fmt'.
452 * It would be cleaner to pass NULL or "", but gcc generates a warning
453 * for both of those.
454 */
455 if (fmt != func) {
456 va_start(ap, fmt);

--- 22 unchanged lines hidden --- 		453
454 /*
455 * When there is no message we pass __func__ as 'fmt'.
456 * It would be cleaner to pass NULL or "", but gcc generates a warning
457 * for both of those.
458 */
459 if (fmt != func) {
460 va_start(ap, fmt);

--- 22 unchanged lines hidden ---