rsys

commit 33f1ae10ae8455f4733b0ec25b43f704c35a3b30
parent 89cbc6bdeaafc0f3443b9c1ccfbc22900af03fe2
Author: vaplv <vaplv@free.fr>
Date:   Wed,  2 Dec 2015 16:42:17 +0100

Make the logger thread safe

Diffstat:
M
src/logger.c
 | 
10
++++++++--
M
src/logger.h
 | 
43
++++++++++++++++++++++++++++++++++---------

2 files changed, 42 insertions(+), 11 deletions(-)
diff --git a/src/logger.c b/src/logger.c
@@ -46,9 +46,11 @@ logger_vprint
     return RES_OK;
   }
 
-  if(!logger->streams[type].writer)
+  if(!logger_has_stream(logger, type))
     return RES_OK;
 
+  mutex_lock(logger->mutex);
+
   VA_COPY(vargs_list_cp, vargs_list);
   sz = vsnprintf
     (darray_char_data_get(&logger->buffer),
@@ -60,8 +62,10 @@ logger_vprint
   /* If there is not sufficient space in the logger buffer, resize it */
   if((size_t)sz >= darray_char_size_get(&logger->buffer)) {
     res_T res = darray_char_resize(&logger->buffer, (size_t)sz+1/*+1<=>'\0'*/);
-    if(res != RES_OK)
+    if(res != RES_OK) {
+      mutex_unlock(logger->mutex);
       return res;
+    }
 
     VA_COPY(vargs_list_cp, vargs_list);
     sz = vsnprintf
@@ -71,8 +75,10 @@ logger_vprint
     va_end(vargs_list_cp);
     ASSERT((size_t)sz < darray_char_size_get(&logger->buffer));
   }
+  mutex_unlock(logger->mutex);
   /* Print the formatted string */
   logger->streams[type].writer
     (darray_char_cdata_get(&logger->buffer), logger->streams[type].ctx);
   return RES_OK;
 }
+
diff --git a/src/logger.h b/src/logger.h
@@ -19,6 +19,7 @@
 #include "dynamic_array_char.h"
 #include "list.h"
 #include "mem_allocator.h"
+#include "mutex.h"
 
 #include <stdarg.h>
 
@@ -37,22 +38,47 @@ struct logger {
     void (*writer)(const char* msg, void* ctx);
     void* ctx;
   } streams[LOG_TYPES_COUNT__];
+  struct mutex* mutex;
   struct mem_allocator* allocator;
   struct darray_char buffer;
 };
 
+static INLINE void
+logger_release(struct logger* logger)
+{
+  ASSERT(logger);
+  darray_char_release(&logger->buffer);
+  if(logger->mutex) mutex_destroy(logger->mutex);
+}
+
 static INLINE res_T
 logger_init
   (struct mem_allocator* allocator, /* May be NULL <=> default allocator */
    struct logger* logger)
 {
   int i;
+  res_T res = RES_OK;
   ASSERT(logger);
+
+  memset(logger, 0, sizeof(struct logger));
   logger->allocator = allocator ? allocator : &mem_default_allocator;
   FOR_EACH(i, 0, LOG_TYPES_COUNT__) logger->streams[i].writer = NULL;
 
   darray_char_init(logger->allocator, &logger->buffer);
-  return darray_char_resize(&logger->buffer, 256);
+  res = darray_char_resize(&logger->buffer, 256);
+  if(res != RES_OK) goto error;
+
+  logger->mutex = mutex_create();
+  if(!logger->mutex) {
+    res = RES_MEM_ERR;
+    goto error;
+  }
+
+exit:
+  return res;
+error:
+  logger_release(logger);
+  goto exit;
 }
 
 static INLINE void
@@ -64,13 +90,6 @@ logger_clear(struct logger* logger)
 }
 
 static INLINE void
-logger_release(struct logger* logger)
-{
-  ASSERT(logger);
-  darray_char_release(&logger->buffer);
-}
-
-static INLINE void
 logger_set_stream
   (struct logger* logger,
    const enum log_type type,
@@ -78,8 +97,10 @@ logger_set_stream
    void* ctx) /* May be NULL */
 {
   ASSERT(logger && (unsigned)type < LOG_TYPES_COUNT__);
+  mutex_lock(logger->mutex);
   logger->streams[type].writer = writer;
   logger->streams[type].ctx = ctx;
+  mutex_unlock(logger->mutex);
 }
 
 static FINLINE char
@@ -87,8 +108,12 @@ logger_has_stream
   (struct logger* logger,
    const enum log_type type)
 {
+  char b;
   ASSERT(logger && (unsigned)type < LOG_TYPES_COUNT__);
-  return logger->streams[type].writer != NULL;
+  mutex_lock(logger->mutex);
+  b = logger->streams[type].writer != NULL;
+  mutex_unlock(logger->mutex);
+  return b;
 }
 
 BEGIN_DECLS