Really restored changes

srtcore/api.cpp

@@ -4742,25 +4742,29 @@ void setloglevel(LogLevel::type ll)
 {
     ScopedLock gg(srt_logger_config.mutex);
     srt_logger_config.max_level = ll;
+    srt_logger_config.updateLoggersState();
 }
 
 void addlogfa(LogFA fa)
 {
     ScopedLock gg(srt_logger_config.mutex);
     srt_logger_config.enabled_fa.set(fa, true);
+    srt_logger_config.updateLoggersState();
 }
 
 void dellogfa(LogFA fa)
 {
     ScopedLock gg(srt_logger_config.mutex);
     srt_logger_config.enabled_fa.set(fa, false);
+    srt_logger_config.updateLoggersState();
 }
 
 void resetlogfa(set<LogFA> fas)
 {
     ScopedLock gg(srt_logger_config.mutex);
     for (int i = 0; i <= SRT_LOGFA_LASTNONE; ++i)
         srt_logger_config.enabled_fa.set(i, fas.count(i));
+    srt_logger_config.updateLoggersState();
 }
 
 void resetlogfa(const int* fara, size_t fara_size)
@@ -4769,6 +4773,7 @@ void resetlogfa(const int* fara, size_t fara_size)
     srt_logger_config.enabled_fa.reset();
     for (const int* i = fara; i != fara + fara_size; ++i)
         srt_logger_config.enabled_fa.set(*i, true);
+    srt_logger_config.updateLoggersState();
 }
 
 void setlogstream(std::ostream& stream)

srtcore/logging.cpp

@@ -14,7 +14,7 @@ written by
  *****************************************************************************/
 
 
-#include "srt_compat.h"
+
 #include "logging.h"
 
 using namespace std;
@@ -23,6 +23,69 @@ using namespace std;
 namespace srt_logging
 {
 
+// Note: subscribe() and unsubscribe() functions are being called
+// in the global constructor and destructor only, as the
+// Logger objects (and inside them also their LogDispatcher)
+// are being created. It's not predicted that LogDispatcher
+// object are going to be created any other way than as
+// global objects. Therefore the construction and destruction
+// of them happens always in the main thread.
+
+void LogConfig::subscribe(LogDispatcher* lg)
+{
+    vector<LogDispatcher*>::iterator p = std::find(loggers.begin(), loggers.end(), lg);
+    if (p != loggers.end())
+        return; // Do not register twice
+
+    loggers.push_back(lg);
+}
+
+void LogConfig::unsubscribe(LogDispatcher* lg)
+{
+    vector<LogDispatcher*>::iterator p = std::find(loggers.begin(), loggers.end(), lg);
+    if (p != loggers.end())
+    {
+        loggers.erase(p);
+    }
+}
+
+// This function doesn't have any protection on itself,
+// however the API functions from which it is called, call
+// it already under a mutex protection.
+void LogConfig::updateLoggersState()
+{
+    for (vector<LogDispatcher*>::iterator p = loggers.begin();
+            p != loggers.end(); ++p)
+    {
+        (*p)->Update();
+    }
+}
+
+void LogDispatcher::Update()
+{
+    bool enabled_in_fa = src_config->enabled_fa[fa];
+    enabled = enabled_in_fa && level <= src_config->max_level;
+}
+
+
+// SendLogLine can be compiled normally. It's intermediately used by:
+// - Proxy object, which is replaced by DummyProxy when !ENABLE_LOGGING
+// - PrintLogLine, which has empty body when !ENABLE_LOGGING
+void LogDispatcher::SendLogLine(const char* file, int line, const std::string& area, const std::string& msg)
+{
+    src_config->lock();
+    if ( src_config->loghandler_fn )
+    {
+        (*src_config->loghandler_fn)(src_config->loghandler_opaque, int(level), file, line, area.c_str(), msg.c_str());
+    }
+    else if ( src_config->log_stream )
+    {
+        (*src_config->log_stream) << msg;
+        src_config->log_stream->flush();
+    }
+    src_config->unlock();
+}
+
 
 #if ENABLE_LOGGING
 

srtcore/logging.h

@@ -20,6 +20,7 @@ written by
 #include <iostream>
 #include <iomanip>
 #include <set>
+#include <vector>
 #include <sstream>
 #include <cstdarg>
 #ifdef _WIN32
@@ -33,6 +34,7 @@ written by
 #include "utilities.h"
 #include "threadname.h"
 #include "logging_api.h"
+#include "srt_compat.h"
 #include "sync.h"
 
 #ifdef __GNUC__
@@ -114,6 +116,7 @@ struct LogConfig
     void* loghandler_opaque;
     mutable srt::sync::Mutex mutex;
     int flags;
+    std::vector<struct LogDispatcher*> loggers;
 
     LogConfig(const fa_bitset_t& efa,
             LogLevel::type l = LogLevel::warning,
@@ -136,6 +139,10 @@ struct LogConfig
 
     SRT_ATTR_RELEASE(mutex)
     void unlock() const { mutex.unlock(); }
+
+    void subscribe(LogDispatcher*);
+    void unsubscribe(LogDispatcher*);
+    void updateLoggersState();
 };
 
 // The LogDispatcher class represents the object that is responsible for
@@ -147,6 +154,7 @@ struct SRT_API LogDispatcher
     LogLevel::type level;
     static const size_t MAX_PREFIX_SIZE = 32;
     char prefix[MAX_PREFIX_SIZE+1];
+    srt::sync::atomic<bool> enabled;
     LogConfig* src_config;
 
     bool isset(int flg) { return (src_config->flags & flg) != 0; }
@@ -157,6 +165,7 @@ struct SRT_API LogDispatcher
             const char* logger_pfx /*[[nullable]]*/, LogConfig& config):
         fa(functional_area),
         level(log_level),
+        enabled(false),
         src_config(&config)
     {
         // XXX stpcpy desired, but not enough portable
@@ -184,13 +193,18 @@ struct SRT_API LogDispatcher
             prefix[MAX_PREFIX_SIZE] = '\0';
 #endif
         }
+        config.subscribe(this);
+        Update();
     }
 
     ~LogDispatcher()
     {
+        src_config->unsubscribe(this);
     }
 
-    bool CheckEnabled();
+    void Update();
+
+    bool CheckEnabled() { return enabled; }
 
     void CreateLogLinePrefix(std::ostringstream&);
     void SendLogLine(const char* file, int line, const std::string& area, const std::string& sl);
@@ -414,24 +428,6 @@ class Logger
     }
 };
 
-inline bool LogDispatcher::CheckEnabled()
-{
-    // Don't use enabler caching. Check enabled state every time.
-
-    // These assume to be atomically read, so the lock is not needed
-    // (note that writing to this field is still mutex-protected).
-    // It's also no problem if the level was changed at the moment
-    // when the enabler check is tested here. Worst case, the log
-    // will be printed just a moment after it was turned off.
-    const LogConfig* config = src_config; // to enforce using const operator[]
-    config->lock();
-    int configured_enabled_fa = config->enabled_fa[fa];
-    int configured_maxlevel = config->max_level;
-    config->unlock();
-
-    return configured_enabled_fa && level <= configured_maxlevel;
-}
-
 
 #if HAVE_CXX11
 
@@ -482,24 +478,6 @@ inline void LogDispatcher::PrintLogLine(const char* file SRT_ATR_UNUSED, int lin
 
 #endif // HAVE_CXX11
 
-// SendLogLine can be compiled normally. It's intermediately used by:
-// - Proxy object, which is replaced by DummyProxy when !ENABLE_LOGGING
-// - PrintLogLine, which has empty body when !ENABLE_LOGGING
-inline void LogDispatcher::SendLogLine(const char* file, int line, const std::string& area, const std::string& msg)
-{
-    src_config->lock();
-    if ( src_config->loghandler_fn )
-    {
-        (*src_config->loghandler_fn)(src_config->loghandler_opaque, int(level), file, line, area.c_str(), msg.c_str());
-    }
-    else if ( src_config->log_stream )
-    {
-        (*src_config->log_stream) << msg;
-        (*src_config->log_stream).flush();
-    }
-    src_config->unlock();
-}
-
 }
 
 #endif // INC_SRT_LOGGING_H