From cf0560420c2461410ce43a66b42645efda2f38a3 Mon Sep 17 00:00:00 2001 From: Heinz Mauelshagen Date: Wed, 4 May 2005 11:52:07 +0000 Subject: [PATCH] o libmultilog needs introducing of list locking in order to stand multilog_add_type()/multilog_del_type cycles correctly. o fixed segfault in multilog_add_type() o fixed test-multilog.c o cleaned up libmultilog (list macros, indentation, braces, comments) --- dmeventd/dmevent.c | 2 + lib/event/dmeventd.c | 55 ++++++---- multilog/async/async_logger.c | 178 +++++++++++++++++---------------- multilog/libmultilog.c | 146 +++++++++++++-------------- multilog/libmultilog.h | 9 +- multilog/tests/test-multilog.c | 32 +++--- 6 files changed, 221 insertions(+), 201 deletions(-) diff --git a/dmeventd/dmevent.c b/dmeventd/dmevent.c index 646e208..74b5593 100644 --- a/dmeventd/dmevent.c +++ b/dmeventd/dmevent.c @@ -156,6 +156,8 @@ int main(int argc, char **argv) } out: + multilog_del_type(standard, ldata); + if (device_arg) free(device_arg); diff --git a/lib/event/dmeventd.c b/lib/event/dmeventd.c index d93aaf7..33e2185 100644 --- a/lib/event/dmeventd.c +++ b/lib/event/dmeventd.c @@ -24,7 +24,6 @@ #include "dmeventd.h" #include "libmultilog.h" - #include #include #include @@ -140,13 +139,13 @@ static struct thread_status *alloc_thread_status(struct message_data *data, struct thread_status *ret = (typeof(ret)) dbg_malloc(sizeof(*ret)); if (ret) { - memset(ret, 0, sizeof(*ret)); - if ((ret->device_path = dbg_strdup(data->device_path))) { - ret->dso_data = dso_data; - ret->events = data->events.field; - } else { + if (!memset(ret, 0, sizeof(*ret)) || + !(ret->device_path = dbg_strdup(data->device_path))) { dbg_free(ret); ret = NULL; + } else { + ret->dso_data = dso_data; + ret->events = data->events.field; } } @@ -165,8 +164,8 @@ static struct dso_data *alloc_dso_data(struct message_data *data) struct dso_data *ret = (typeof(ret)) dbg_malloc(sizeof(*ret)); if (ret) { - memset(ret, 0, sizeof(*ret)); - if (!(ret->dso_name = dbg_strdup(data->dso_name))) { + if (!memset(ret, 0, sizeof(*ret)) || + !(ret->dso_name = dbg_strdup(data->dso_name))) { dbg_free(ret); ret = NULL; } @@ -181,6 +180,14 @@ static void free_dso_data(struct dso_data *data) dbg_free(data); } +/* FIXME: Factor out. */ +static char *dm_basename(char *str) +{ + char *p = strrchr(str, '/'); + + return p ? p + 1 : str; +} + /* * Fetch a string off src and duplicate it into *ptr. * Pay attention to 0 lenght strings. @@ -334,7 +341,7 @@ static int error_detected(struct thread_status *thread, char *params) if ((len = strlen(params)) && params[len - 1] == 'F') { */ - if((len = strlen(params))){ + if (params && (len = strlen(params))) { thread->current_events |= DEVICE_ERROR; return 1; } @@ -355,7 +362,7 @@ static int event_wait(struct thread_status *thread) if (!(dmt = dm_task_create(DM_DEVICE_WAITEVENT))) return 0; - if ((ret = dm_task_set_name(dmt, basename(thread->device_path))) && + if ((ret = dm_task_set_name(dmt, dm_basename(thread->device_path))) && (ret = dm_task_set_event_nr(dmt, thread->event_nr)) && (ret = dm_task_run(dmt))) { do { @@ -368,8 +375,9 @@ static int event_wait(struct thread_status *thread) if ((ret = error_detected(thread, params))) break; } while(next); - dm_task_get_info(dmt, &info); - thread->event_nr = info.event_nr; + + if ((ret = dm_task_get_info(dmt, &info))) + thread->event_nr = info.event_nr; } dm_task_destroy(dmt); @@ -783,11 +791,16 @@ static int get_registered_device(struct message_data *message_data, int next) } /* Initialize a fifos structure with path names. */ -static void init_fifos(struct fifos *fifos) +static int init_fifos(struct fifos *fifos) { - memset(fifos, 0, sizeof(*fifos)); - fifos->client_path = FIFO_CLIENT; - fifos->server_path = FIFO_SERVER; + if (memset(fifos, 0, sizeof(*fifos))) { + fifos->client_path = FIFO_CLIENT; + fifos->server_path = FIFO_SERVER; + + return 1; + } + + return 0; } /* Open fifos used for client communication. */ @@ -905,8 +918,8 @@ static void process_request(struct fifos *fifos) /* FIXME: better error handling */ /* Read the request from the client. */ - memset(&msg, 0, sizeof(msg)); - if (!client_read(fifos, &msg)) { + if (!memset(&msg, 0, sizeof(msg)) || + !client_read(fifos, &msg)) { stack; return; } @@ -965,8 +978,10 @@ void dmeventd(void) int ret; struct fifos fifos; struct log_data *tsdata = malloc(sizeof(*tsdata)); + if(!tsdata) exit(-ENOMEM); + if(!memset(tsdata, 0, sizeof(*tsdata))) exit(-ENOMEM); @@ -985,9 +1000,9 @@ void dmeventd(void) tsdata->verbose_level = _LOG_DEBUG; multilog_add_type(threaded_syslog, tsdata); + if (!init_fifos(&fifos)) + exit (-ENOMEM); - - init_fifos(&fifos); pthread_mutex_init(&mutex, NULL); if (mlockall(MCL_FUTURE) == -1) diff --git a/multilog/async/async_logger.c b/multilog/async/async_logger.c index dc39faa..c65e17a 100644 --- a/multilog/async/async_logger.c +++ b/multilog/async/async_logger.c @@ -38,8 +38,10 @@ struct circ_buf { int initialized:1; }; -/* Need a circular buffer to hold the messages - this will have to be - * global so all threads can see it */ +/* + * Need a circular buffer to hold the messages - this will + * have to be global so all threads can see it. + */ static struct circ_buf cbuf = { .mutex = PTHREAD_MUTEX_INITIALIZER, .cond = PTHREAD_COND_INITIALIZER, @@ -53,18 +55,17 @@ static struct circ_buf cbuf = { static int will_overrun(int read_pos, int write_pos, int first_len, int second_len) { - if(((read_pos > write_pos) && - (write_pos + first_len >= read_pos)) || - ((read_pos < write_pos) && - (second_len >= read_pos))) - return 1; - else - return 0; + return (((read_pos > write_pos) && + (write_pos + first_len >= read_pos)) || + ((read_pos < write_pos) && + (second_len >= read_pos))); } -/* Messages are encoded in the buffer with the following format: - priority:file:line:msg -*/ +/* + * Messages are encoded in the buffer with the following format: + * + * priority:file:line:msg + */ void write_to_buf(void *data, int priority, const char *file, int line, const char *string) { @@ -82,35 +83,43 @@ void write_to_buf(void *data, int priority, const char *file, int line, written_len = snprintf(curpos, CBUFSIZE-1, ":%s:%d:", file, line); - /* file, func, line were too long for the buffer, - so leave them blank */ - if(written_len >= (CBUFSIZE-1)) { + + /* + * file, func, line were too long for the buffer, + * so leave them blank. + */ + if (written_len >= (CBUFSIZE-1)) { sprintf(curpos, ":::"); written_len = 3; } + curpos += written_len; - /* write message to circular buffer - what kind of delimiter do we - * want? Is NULL ok? */ - strncpy(curpos, string, CBUFSIZE-written_len); + /* + * write message to circular buffer - what kind of delimiter + * do we want? Is NULL ok? + */ + strncpy(curpos, string, CBUFSIZE - written_len); /* FIXME: should we warn somehow if the buffer was truncated? */ buf[CBUFSIZE-1] = '\0'; - /* FIXME - if the message is too long for the buffer, should - * we retry without the filename, function and line number? */ - + /* + * FIXME - if the message is too long for the buffer, should + * we retry without the filename, function and line number? + */ buf_len = strlen(buf) + 1; pthread_mutex_lock(&cbuf.mutex); /* Need to split the write into parts */ - if((cbuf.write_pos + buf_len) >= CBUFSIZE) { + if ((cbuf.write_pos + buf_len) >= CBUFSIZE) { first_len = CBUFSIZE - (cbuf.write_pos); second_len = buf_len - first_len; + /* Protect from overrun */ - if(!will_overrun(cbuf.read_pos, cbuf.write_pos, - first_len, second_len)) { + if (!will_overrun(cbuf.read_pos, cbuf.write_pos, + first_len, second_len)) { strncpy(&cbuf.buf[cbuf.write_pos], buf, first_len); strncpy(&cbuf.buf[0], buf + first_len, second_len); cbuf.write_pos = second_len; @@ -119,8 +128,7 @@ void write_to_buf(void *data, int priority, const char *file, int line, ret = 0; } else { /* Protect from overrun */ - if(!will_overrun(cbuf.read_pos, cbuf.write_pos, - buf_len, -1)) { + if (!will_overrun(cbuf.read_pos, cbuf.write_pos, buf_len, -1)) { strncpy(&cbuf.buf[cbuf.write_pos], buf, buf_len); cbuf.write_pos += buf_len; ret = 1; @@ -128,18 +136,16 @@ void write_to_buf(void *data, int priority, const char *file, int line, ret = 0; } - /* We don't need to signal the syslog thread when it's writing - * to syslog */ - if(cbuf.should_sig) + /* + * We don't need to signal the syslog thread + * when it's writing to syslog. + */ + if (cbuf.should_sig) pthread_cond_signal(&cbuf.cond); pthread_mutex_unlock(&cbuf.mutex); - - return; - } - static int read_from_buf(int *priority, char *file, int *line, char *msg, int len) { @@ -149,49 +155,51 @@ static int read_from_buf(int *priority, char *file, int *line, char tmpbuf[CBUFSIZE] = {0}; char *curpos = &cbuf.buf[cbuf.read_pos]; - /* Pull the entire message into a temporary buffer first to - * handle wraparound cleanly */ + /* + * Pull the entire message into a temporary + * buffer first to handle wraparound cleanly + */ first_len = CBUFSIZE - cbuf.read_pos; strncpy(tmpbuf, &cbuf.buf[cbuf.read_pos], first_len); - if(tmpbuf[first_len - 1] != '\0') { + if (tmpbuf[first_len - 1] != '\0') { /* FIXME: Make sure we're null terminated */ strncpy(tmpbuf+first_len, &cbuf.buf[0], cbuf.read_pos); cbuf.read_pos = strlen(&cbuf.buf[0]) + 1; - } else { + } else cbuf.read_pos += strlen(tmpbuf) + 1; - } /* Parse the message for various fields */ curpos = tmpbuf; - if(!(pos = strchr(curpos, ':'))) { + if (!(pos = strchr(curpos, ':'))) return 0; - } + pbuf[0] = curpos[0]; pbuf[1] = '\0'; sscanf(pbuf, "%d", priority); curpos = pos; - if(!(pos = strchr(curpos+1, ':'))) { + if (!(pos = strchr(curpos+1, ':'))) return 0; - } - if(pos != curpos + 1) { + + if (pos != curpos + 1) { strncpy(file, curpos + 1, MAX_FILELEN - 1); file[pos - (curpos + 1)] = '\0'; } + curpos = pos; - if(!(pos = strchr(curpos+1, ':'))) { + if (!(pos = strchr(curpos+1, ':'))) return 0; - } - if(pos != curpos + 1) { + + if (pos != curpos + 1) { strncpy(pbuf, curpos + 1, MIN(MAX_LINELEN, pos - (curpos + 1))); sscanf(pbuf, "%d", line); } else *line = -1; - curpos = pos + 1; + curpos = pos + 1; strncpy(msg, curpos, MIN(len, (CBUFSIZE - (curpos - tmpbuf)))); //cbuf.read_pos += strlen(msg) + (curpos - tmpbuf) + 1; @@ -207,15 +215,14 @@ static void finish_processing(void *arg) char mybuf[CBUFSIZE] = {0}; while(cbuf.write_pos != cbuf.read_pos) { - /*call read_from_buf, unlock mutex, - * and write to syslog */ - read_from_buf(&priority, file, &line, - mybuf, CBUFSIZE); + /* Call read_from_buf, unlock mutex, and write to syslog. */ + read_from_buf(&priority, file, &line, mybuf, CBUFSIZE); - /* Unlock the mutex before writing to syslog + /* + * Unlock the mutex before writing to syslog * so we don't block the writer threads - but - * then how to we handle - * pthread_cond_signal? */ + * then how to we handle pthread_cond_signal? + */ pthread_mutex_unlock(&cbuf.mutex); syslog(priority, "%s", mybuf); pthread_mutex_lock(&cbuf.mutex); @@ -224,8 +231,10 @@ static void finish_processing(void *arg) pthread_mutex_unlock(&cbuf.mutex); } -/* handle logging to syslog through circular buffer so that syslog - * blocking doesn't hold anyone up */ +/* + * Handle logging to syslog through circular buffer so that syslog + * blocking doesn't hold anyone up. + */ static void *process_syslog(void *arg) { char mybuf[CBUFSIZE] = {0}; @@ -233,73 +242,74 @@ static void *process_syslog(void *arg) char file[256]; int line; - /* We can lock this because cbuf is initialized at creation - time */ + /* We can lock this because cbuf is initialized at creation time */ pthread_mutex_lock(&cbuf.mutex); /* FIXME: Should I return an error code or something here? */ - /* Prevent multiple process_syslog threads from starting */ - if(cbuf.initialized) { + /* Prevent multiple process_syslog threads from starting. */ + if (cbuf.initialized) pthread_exit(NULL); - } cbuf.initialized = 1; - pthread_cleanup_push(finish_processing, NULL); - /* FIXME: The program name needs to be variable */ + + /* FIXME: The program name needs to be variable. */ openlog("dmeventd", LOG_NDELAY | LOG_PID, LOG_DAEMON); while (1) { /* check write_pos & read_pos */ - if(cbuf.write_pos != cbuf.read_pos) { - /*call read_from_buf, unlock mutex, - * and write to syslog */ - read_from_buf(&priority, file, &line, - mybuf, CBUFSIZE); - - /* Unlock the mutex before writing to syslog - * so we don't block the writer threads */ + if (cbuf.write_pos != cbuf.read_pos) { + /* + * Call read_from_buf, unlock mutex, + * and write to syslog. + */ + read_from_buf(&priority, file, &line, mybuf, CBUFSIZE); + + /* + * Unlock the mutex before writing to syslog + * so we don't block the writer threads. + */ pthread_mutex_unlock(&cbuf.mutex); - syslog(priority, "%s", mybuf); - pthread_mutex_lock(&cbuf.mutex); } else { - /* set the should_sig var before waiting so + /* + * Set the should_sig var before waiting so * the threads using the log know to signal it - * to wake up after adding to the log */ + * to wake up after adding to the log. + */ cbuf.should_sig = 1; pthread_cond_wait(&cbuf.cond, &cbuf.mutex); cbuf.should_sig = 0; } } + closelog(); pthread_cleanup_pop(0); + return NULL; } - int start_syslog_thread(pthread_t *thread, long usecs) { struct timeval ts = {0, usecs}; pthread_create(thread, NULL, process_syslog, NULL); - select(0, NULL, NULL, NULL, &ts); - /* Not grabbing the mutex before I check this - mainly + + /* + * Not grabbing the mutex before I check this - mainly * because it better be atomic - either 0 or 1, and if * it changes from 0 -> 1 while i'm reading it, I - * don't really care */ - if(cbuf.initialized) - return 1; - - return 0; + * don't really care. + */ + return cbuf.initialized ? 1 : 0; } - int stop_syslog_thread(struct log_data *data) { pthread_cancel(data->info.threaded_syslog.thread); pthread_join(data->info.threaded_syslog.thread, NULL); + return 1; } diff --git a/multilog/libmultilog.c b/multilog/libmultilog.c index 563562e..6c518e6 100644 --- a/multilog/libmultilog.c +++ b/multilog/libmultilog.c @@ -27,6 +27,8 @@ #include +/* FIXME: add locking while updating logs registry. */ + struct log_list { struct list list; enum log_type type; @@ -43,115 +45,104 @@ static void nop_log(void *data, int priority, const char *file, int line, { return; } + static void standard_log(void *data, int priority, const char *file, int line, const char *string) { struct log_data *ldata = (struct log_data *) data; - char locn[4096]; + /* FIXME: stack allocation of large buffer. */ + char locn[512]; if (ldata->verbose_level > _LOG_DEBUG) snprintf(locn, sizeof(locn), "#%s:%d ", file, line); else locn[0] = '\0'; - switch (ldata->verbose_level) { case _LOG_DEBUG: if (!strcmp("", string) && ldata->verbose_level <= _LOG_DEBUG) break; - if (ldata->verbose_level >= _LOG_DEBUG) { - fprintf(stderr, "%s%s", locn, string); - fputc('\n', stderr); - } + + if (ldata->verbose_level >= _LOG_DEBUG) + fprintf(stderr, "%s%s\n", locn, string); + break; case _LOG_INFO: - if (ldata->verbose_level >= _LOG_INFO) { - fprintf(stderr, "%s%s", locn, string); - fputc('\n', stderr); - } + if (ldata->verbose_level >= _LOG_INFO) + fprintf(stderr, "%s%s\n", locn, string); + break; case _LOG_NOTICE: - if (ldata->verbose_level >= _LOG_NOTICE) { - fprintf(stderr, "%s%s", locn, string); - fputc('\n', stderr); - } + if (ldata->verbose_level >= _LOG_NOTICE) + fprintf(stderr, "%s%s\n", locn, string); + break; case _LOG_WARN: - if (ldata->verbose_level >= _LOG_WARN) { - printf("%s", string); - putchar('\n'); - } + if (ldata->verbose_level >= _LOG_WARN) + printf("%s\n", string); + break; case _LOG_ERR: - if (ldata->verbose_level >= _LOG_ERR) { - fprintf(stderr, "%s%s", locn, string); - fputc('\n', stderr); - } + if (ldata->verbose_level >= _LOG_ERR) + fprintf(stderr, "%s%s\n", locn, string); + break; case _LOG_FATAL: default: - if (ldata->verbose_level >= _LOG_FATAL) { - fprintf(stderr, "%s%s", locn, string); - fputc('\n', stderr); - } + if (ldata->verbose_level >= _LOG_FATAL) + fprintf(stderr, "%s%s\n", locn, string); + break; }; } -static int start_threaded_syslog(struct log_list *logl, struct log_data *logdata) +static int start_threaded_syslog(struct log_list *logl, + struct log_data *logdata) { + void (*log_fxn) (void *data, int priority, const char *file, int line, + const char *string); + int (*start_syslog) (pthread_t *t, long usecs); - int i; - - if(!(logdata->info.threaded_syslog.dlh = dlopen("libmultilog_async.so", RTLD_NOW))) { + if (!(logdata->info.threaded_syslog.dlh = dlopen("libmultilog_async.so", RTLD_NOW))) { fprintf(stderr, "%s\n", dlerror()); return 0; } - void (*log_fxn) (void *data, int priority, const char *file, int line, - const char *string); - int (*start_syslog) (pthread_t *t, long usecs); - log_fxn = dlsym(logdata->info.threaded_syslog.dlh, "write_to_buf"); start_syslog = dlsym(logdata->info.threaded_syslog.dlh, "start_syslog_thread"); /* FIXME: the timeout here probably can be tweaked */ /* FIXME: Probably want to do something if this fails */ - if(start_syslog(&(logdata->info.threaded_syslog.thread), 100000)) + if (start_syslog(&(logdata->info.threaded_syslog.thread), 100000)) logl->log = log_fxn; - if(!logl->log) - return 0; - - return 1; - + return logl->log ? 1 : 0; } -/* FIXME: Can currently add multiple logging types */ +/* FIXME: Can currently add multiple logging types. */ int multilog_add_type(enum log_type type, struct log_data *data) { struct log_list *logl; - struct list *tmp; - if(!(logl = malloc(sizeof(*logl)))) - return 0; - if(!(memset(logl, 0, sizeof(*logl)))) - return 0; - - /* If the type has already been registered, it doesn't need to - * be registered again */ - list_iterate(tmp, &logs) { - logl = list_item(tmp, struct log_list); - if(logl->type == type) + /* + * If the type has already been registered, + * it doesn't need to be registered again. + */ + list_iterate_items(logl, &logs) { + if (logl->type == type) return 1; } - list_init(&logl->list); + if (!(logl = malloc(sizeof(*logl))) || + !(memset(logl, 0, sizeof(*logl)))) + return 0; + + list_init(&logl->list); /* Superfluous but safe ;) */ logl->type = type; logl->data = data; - switch(type) { + switch (type) { case standard: logl->log = standard_log; break; @@ -164,9 +155,9 @@ int multilog_add_type(enum log_type type, struct log_data *data) logl->log = nop_log; break; case threaded_syslog: - if(!start_threaded_syslog(logl, data)) { + if (!start_threaded_syslog(logl, data)) return 0; - } + break; case custom: /* Caller should use multilog_custom to set their @@ -176,6 +167,7 @@ int multilog_add_type(enum log_type type, struct log_data *data) } list_add(&logs, &logl->list); + return 1; } @@ -184,12 +176,13 @@ void multilog_clear_logging(void) { struct list *tmp, *next; struct log_list *logl; + list_iterate_safe(tmp, next, &logs) { logl = list_item(tmp, struct log_list); - if(logl->data) { + if (logl->data) free(logl->data); - } + list_del(tmp); } } @@ -202,14 +195,17 @@ void multilog_del_type(enum log_type type, struct log_data *data) list_iterate_safe(tmp, next, &logs) { logl = list_item(tmp, struct log_list); - if(logl->type == type) { - if(logl->type == threaded_syslog) { + + if (logl->type == type) { + if (logl->type == threaded_syslog) { int (*stop_syslog) (struct log_data *log); - stop_syslog = dlsym(data->info.threaded_syslog.dlh, - "stop_syslog_thread"); - stop_syslog(data); + + if ((stop_syslog = dlsym(data->info.threaded_syslog.dlh, "stop_syslog_thread"))) + stop_syslog(data); } + list_del(tmp); + free(logl); break; } } @@ -218,13 +214,14 @@ void multilog_del_type(enum log_type type, struct log_data *data) void multilog_custom(multilog_fn fn) { - struct list *tmp; struct log_list *logl; - /* FIXME: Should we present an error if we can't find a - * suitable target? */ - list_iterate(tmp, &logs) { - logl = list_item(tmp, struct log_list); - if(logl->type == custom && logl->log == nop_log) + + /* + * FIXME: Should we present an error if + * we can't find a suitable target? + */ + list_iterate_items(logl, &logs) { + if (logl->type == custom && logl->log == nop_log) logl->log = fn; } } @@ -232,21 +229,16 @@ void multilog_custom(multilog_fn fn) void multilog(int priority, const char *file, int line, const char *format, ...) { - struct list *tmp; - struct log_list *logl; + /* FIXME: stack allocation of large buffer. */ char buf[4096]; + struct log_list *logl; va_list args; /* FIXME: shove everything into a single string */ va_start(args, format); - vsnprintf(buf, 4096, format, args); - va_end(args); - list_iterate(tmp, &logs) { - logl = list_item(tmp, struct log_list); + list_iterate_items(logl, &logs) logl->log(logl->data, priority, file, line, buf); - } - } diff --git a/multilog/libmultilog.h b/multilog/libmultilog.h index 2253048..4c64148 100644 --- a/multilog/libmultilog.h +++ b/multilog/libmultilog.h @@ -27,7 +27,6 @@ #define _LOG_FATAL 2 - struct file_log { const char *filename; }; @@ -59,22 +58,20 @@ enum log_type { typedef void (*multilog_fn) (void *data, int level, const char *file, int line, const char *f); -void multilog(int level, const char *file, int line, const char *f, ...) - __attribute__ ((format(printf, 4, 5))); +void multilog(int priority, const char *file, int line, const char *f, ...) + __attribute__ ((format(printf, 4, 5))); + /* * The library user may wish to register their own * logging function, by default errors go to stderr. * Use dm_log_init(NULL) to restore the default log fn. */ - - int multilog_add_type(enum log_type type, struct log_data *data); void multilog_clear_logging(void); void multilog_del_type(enum log_type type, struct log_data *data); void multilog_custom(multilog_fn fn); void multilog_init_verbose(int level); - #undef plog #undef log_error #undef log_print diff --git a/multilog/tests/test-multilog.c b/multilog/tests/test-multilog.c index 14d903f..42295e3 100644 --- a/multilog/tests/test-multilog.c +++ b/multilog/tests/test-multilog.c @@ -1,5 +1,5 @@ #include - +#include #include #include #include "libmultilog.h" @@ -7,24 +7,24 @@ int main(int argc, char **argv) { int i; - struct threaded_syslog_log sl_logdata; + struct log_data logdata; - sl_logdata.verbose_level = 4; + logdata.verbose_level = 4; - if(!multilog_add_type(threaded_syslog, &sl_logdata)) { + if (!multilog_add_type(threaded_syslog, &logdata)) fprintf(stderr, "Unable to add threaded syslog logging\n"); - } - multilog_add_type(standard, NULL); - for( i = 0; i < 100; i++) { - log_err("Testing really long strings so that we can fill the buffer up and show skips %d", i); - if(i == 5) { + multilog_add_type(standard, &logdata); + + for (i = 0; i < 100; i++) { + log_err("Testing really long strings so that we can " + "fill the buffer up and show skips %d", i); + + if (i == 5) multilog_del_type(standard, NULL); - } } log_debug("Testing debug"); - log_err("Test of errors2"); sleep(2); @@ -32,12 +32,16 @@ int main(int argc, char **argv) log_err("Test of errors3"); log_err("Test of errors4"); - multilog_add_type(standard, NULL); + /* + * FIXME: locking on libmultilog bytes here, because the + * threaded log is still active. + */ + // multilog_add_type(standard, NULL); log_err("Test of errors5"); log_err("Test of errors6"); - multilog_del_type(threaded_syslog, &sl_logdata); + multilog_del_type(threaded_syslog, &logdata); - return 0; + exit(EXIT_SUCCESS); } -- 2.43.5