Avoid extreme logging for large test runs

Author: BrianSipos

src/BPSecLib_Private.h

@@ -184,6 +184,32 @@ void BSL_openlog(void);
  */
 void BSL_closelog(void);
 
+/** Interpret a text name as a severity level.
+ *
+ * @param[out] severity The associated severity level.
+ * @param[in] name The text name, which is case insensitive.
+ * @return Zero if successful.
+ */
+int BSL_LogGetSeverity(int *severity, const char *name);
+
+/** Set the least severity enabled for logging.
+ * Other events will be dropped by the logging facility.
+ * This function is multi-thread safe.
+ *
+ * @param severity The severity from a subset of the POSIX syslog values.
+ * @sa BSL_log_is_enabled_for()
+ */
+void BSL_LogSetLeastSeverity(int severity);
+
+/** Determine if a particular severity is being logged.
+ * This function is multi-thread safe.
+ *
+ * @param severity The severity from a subset of the POSIX syslog values.
+ * @return True if the severity level will be logged.
+ * @sa BSL_log_set_least_severity()
+ */
+bool BSL_LogIsEnabledFor(int severity);
+
 /** Log an event.
  *
  * @param severity The severity from a subset of the POSIX syslog values.

src/backend/LoggingStderr.c

@@ -35,6 +35,7 @@
 
 #include <m-buffer.h>
 #include <m-string.h>
+#include <m-atomic.h>
 
 /// Number of events to buffer to I/O thread
 #define BSL_LOG_QUEUE_SIZE 100
@@ -82,14 +83,37 @@ static void BSL_LogEvent_event_deinit(BSL_LogEvent_event_t *obj)
     string_clear(obj->context);
 }
 
+static void BSL_LogEvent_event_init_set(BSL_LogEvent_event_t *obj, const BSL_LogEvent_event_t *src)
+{
+    obj->thread    = src->thread;
+    obj->timestamp = src->timestamp;
+    obj->severity  = src->severity;
+    string_init_set(obj->context, src->message);
+    string_init_set(obj->message, src->message);
+}
+
+static void BSL_LogEvent_event_set(BSL_LogEvent_event_t *obj, const BSL_LogEvent_event_t *src)
+{
+    obj->thread    = src->thread;
+    obj->timestamp = src->timestamp;
+    obj->severity  = src->severity;
+    string_set(obj->context, src->message);
+    string_set(obj->message, src->message);
+}
+
 /// OPLIST for BSL_LogEvent_event_t
-#define M_OPL_BSL_LogEvent_event_t() (INIT(API_2(BSL_LogEvent_event_init)), CLEAR(API_2(BSL_LogEvent_event_deinit)))
+#define M_OPL_BSL_LogEvent_event_t()                                                     \
+    (INIT(API_2(BSL_LogEvent_event_init)), INIT_SET(API_6(BSL_LogEvent_event_init_set)), \
+     SET(API_6(BSL_LogEvent_event_set)), CLEAR(API_2(BSL_LogEvent_event_deinit)))
 
 // NOLINTBEGIN
 /// @cond Doxygen_Suppress
 M_BUFFER_DEF(BSL_LogEvent_queue, BSL_LogEvent_event_t, BSL_LOG_QUEUE_SIZE, M_BUFFER_THREAD_SAFE | M_BUFFER_BLOCKING)
 /// @endcond
 
+/// Shared least severity
+static atomic_int least_severity = LOG_DEBUG;
+
 /// Shared safe queue
 static BSL_LogEvent_queue_t event_queue;
 /// Sink thread ID
@@ -159,14 +183,12 @@ static void *work_sink(void *arg _U_)
     while (true)
     {
         BSL_LogEvent_event_t event;
+        BSL_LogEvent_event_init(&event);
         BSL_LogEvent_queue_pop(&event, event_queue);
-        if (string_empty_p(event.message))
+        if (!string_empty_p(event.message))
         {
-            BSL_LogEvent_event_deinit(&event);
-            break;
+            write_log(&event);
         }
-
-        write_log(&event);
         BSL_LogEvent_event_deinit(&event);
     }
     return NULL;
@@ -198,6 +220,7 @@ void BSL_closelog(void)
     BSL_LogEvent_event_t event;
     BSL_LogEvent_event_init(&event);
     BSL_LogEvent_queue_push(event_queue, event);
+    BSL_LogEvent_event_deinit(&event);
 
     int res = pthread_join(thr_sink, NULL);
     if (res)
@@ -216,10 +239,54 @@ void BSL_closelog(void)
     }
 }
 
+int BSL_LogGetSeverity(int *severity, const char *name)
+{
+    CHKERR1(severity)
+    CHKERR1(name)
+
+    for (size_t ix = 0; ix < sizeof(sev_names) / sizeof(const char *); ++ix)
+    {
+        if (!sev_names[ix])
+        {
+            continue;
+        }
+        if (strcasecmp(sev_names[ix], name) == 0)
+        {
+            *severity = (int)ix;
+            return 0;
+        }
+    }
+    return 2;
+}
+
+void BSL_LogSetLeastSeverity(int severity)
+{
+    if ((severity < 0) || (severity > LOG_DEBUG))
+    {
+        return;
+    }
+
+    atomic_store(&least_severity, severity);
+}
+
+bool BSL_LogIsEnabledFor(int severity)
+{
+    if ((severity < 0) || (severity > LOG_DEBUG))
+    {
+        return false;
+    }
+
+    const int limit = atomic_load(&least_severity);
+    // lower severity has higher define value
+    const bool enabled = (limit >= severity);
+
+    return enabled;
+}
+
 // NOLINTBEGIN
 void BSL_LogEvent(int severity, const char *filename, int lineno, const char *funcname, const char *format, ...)
 {
-    if ((severity < 0) || (severity > LOG_DEBUG))
+    if (!BSL_LogIsEnabledFor(severity))
     {
         return;
     }
@@ -251,28 +318,25 @@ void BSL_LogEvent(int severity, const char *filename, int lineno, const char *fu
         va_end(val);
     }
 
-    if (string_empty_p(event.message))
+    // ignore empty messages
+    if (!string_empty_p(event.message))
     {
-        // ignore empty messages
-        BSL_LogEvent_event_deinit(&event);
-        return;
-    }
-
-    if (atomic_load(&thr_valid))
-    {
-        BSL_LogEvent_queue_push(event_queue, event);
-    }
-    else
-    {
-        BSL_LogEvent_event_t manual;
-        BSL_LogEvent_event_init(&manual);
-        manual.severity = LOG_CRIT;
-        string_set_str(manual.message, "BSL_LogEvent() called before BSL_openlog()");
-        write_log(&manual);
-        BSL_LogEvent_event_deinit(&manual);
+        if (atomic_load(&thr_valid))
+        {
+            BSL_LogEvent_queue_push(event_queue, event);
+        }
+        else
+        {
+            BSL_LogEvent_event_t manual;
+            BSL_LogEvent_event_init(&manual);
+            manual.severity = LOG_CRIT;
+            string_set_str(manual.message, "BSL_LogEvent() called before BSL_openlog()");
+            write_log(&manual);
+            BSL_LogEvent_event_deinit(&manual);
 
-        write_log(&event);
-        BSL_LogEvent_event_deinit(&event);
+            write_log(&event);
+        }
     }
+    BSL_LogEvent_event_deinit(&event);
 }
 // NOLINTEND

test/fuzz_mock_bpa_bpv7_cbor.cpp

@@ -35,6 +35,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
 extern "C" int LLVMFuzzerInitialize(int *argc _U_, char ***argv _U_)
 {
     BSL_openlog();
+    BSL_LogSetLeastSeverity(LOG_CRIT);
     bsl_mock_bpa_agent_init();
     return 0;
 }